FROM_TO_CACHE Class Reference

#include <from_to_cache.h>

Classes
struct	FT_ENDPOINT
struct	FT_PATH

Public Member Functions
	FROM_TO_CACHE (BOARD *aBoard=nullptr)
	~FROM_TO_CACHE ()
void	Rebuild (BOARD *aBoard)
bool	IsOnFromToPath (BOARD_CONNECTED_ITEM *aItem, const wxString &aFrom, const wxString &aTo)
FT_PATH *	QueryFromToPath (const std::set< BOARD_CONNECTED_ITEM * > &aItems)

Private Member Functions
int	cacheFromToPaths (const wxString &aFrom, const wxString &aTo)
void	buildEndpointList ()

Private Attributes
std::vector< FT_ENDPOINT >	m_ftEndpoints
std::vector< FT_PATH >	m_ftPaths
BOARD *	m_board

Detailed Description

Definition at line 28 of file from_to_cache.h.

Constructor & Destructor Documentation

FROM_TO_CACHE()

FROM_TO_CACHE::FROM_TO_CACHE ( BOARD *  aBoard = nullptr )

inline

Definition at line 49 of file from_to_cache.h.

                                             :
        m_board( aBoard )
    {
    }

~FROM_TO_CACHE()

FROM_TO_CACHE::~FROM_TO_CACHE ( )

inline

Definition at line 54 of file from_to_cache.h.

    {
    }

Member Function Documentation

buildEndpointList()

void FROM_TO_CACHE::buildEndpointList ( )

private

Definition at line 34 of file from_to_cache.cpp.

{
    m_ftEndpoints.clear();

    for( FOOTPRINT* footprint : m_board->Footprints() )
    {
        for( PAD* pad : footprint->Pads() )
        {
            FT_ENDPOINT ent;
            ent.name = footprint->GetReference() + "-" + pad->GetName();
            ent.parent = pad;
            m_ftEndpoints.push_back( ent );
            ent.name = footprint->GetReference();
            ent.parent = pad;
            m_ftEndpoints.push_back( ent );
        }
    }
}

References BOARD::Footprints(), m_board, m_ftEndpoints, FROM_TO_CACHE::FT_ENDPOINT::name, pad, and FROM_TO_CACHE::FT_ENDPOINT::parent.

Referenced by Rebuild().

cacheFromToPaths()

int FROM_TO_CACHE::cacheFromToPaths ( const wxString &  aFrom, const wxString &  aTo  )

private

Definition at line 121 of file from_to_cache.cpp.

{
    std::vector<FT_PATH> paths;
    auto connectivity = m_board->GetConnectivity();
    auto cnAlgo = connectivity->GetConnectivityAlgo();

    for( auto& endpoint : m_ftEndpoints )
    {
        if( WildCompareString( aFrom, endpoint.name, false ) )
        {
            FT_PATH p;
            p.net = endpoint.parent->GetNetCode();
            p.from = endpoint.parent;
            p.to = nullptr;
            paths.push_back(p);
        }
    }

    for( auto &path : paths )
    {
        int count = 0;
        auto netName = path.from->GetNetname();

        wxString fromName = path.from->GetParent()->GetReference() + "-" + path.from->GetName();

        const KICAD_T onlyRouting[] = { PCB_PAD_T, PCB_ARC_T, PCB_VIA_T, PCB_TRACE_T, EOT };

        auto padCandidates = connectivity->GetConnectedItems( path.from, onlyRouting );
        PAD* toPad = nullptr;

        for( auto pitem : padCandidates )
        {
            if( pitem == path.from )
                continue;

            if( pitem->Type() != PCB_PAD_T )
                continue;

            const PAD *pad = static_cast<const PAD*>( pitem );

            wxString toName = pad->GetParent()->GetReference() + "-" + pad->GetName();


            for ( const auto& endpoint : m_ftEndpoints )
            {
                if( pad == endpoint.parent )
                {
                        if( WildCompareString( aTo, endpoint.name, false ) )
                        {
                            count++;
                            toPad = endpoint.parent;

                            path.to = toPad;
                            path.fromName = fromName;
                            path.toName = toName;
                            path.fromWildcard = aFrom;
                            path.toWildcard = aTo;

                            if( count >= 2 )
                            {
                                // fixme: report this somewhere?
                                //printf("Multiple targets found, aborting...\n");
                                path.to = nullptr;
                            }
                        }
                    }
                }
        }
    }

    int newPaths = 0;

    for( auto &path : paths )
    {
        if( !path.from || !path.to )
            continue;


        CN_ITEM *cnFrom = cnAlgo->ItemEntry( path.from ).GetItems().front();
        CN_ITEM *cnTo = cnAlgo->ItemEntry( path.to ).GetItems().front();
        CN_ITEM::CONNECTED_ITEMS upath;

        auto result = uniquePathBetweenNodes( cnFrom, cnTo, upath );

        if( result == PS_OK )
            path.isUnique = true;
        else
            path.isUnique = false;


        //printf( "%s\n", (const char *) wxString::Format( _("Check path: %s -> %s (net %s)"), path.fromName, path.toName, cnFrom->Parent()->GetNetname() ) );

        if( result == PS_NO_PATH )
            continue;

        for( const auto item : upath )
        {
            path.pathItems.insert( item->Parent() );
        }

        m_ftPaths.push_back(path);
        newPaths++;
    }

    // reportAux( _("Cached %d paths\n"), newPaths );

    return newPaths;
}

References EOT, FROM_TO_CACHE::FT_PATH::from, BOARD::GetConnectivity(), m_board, m_ftEndpoints, m_ftPaths, FROM_TO_CACHE::FT_PATH::net, pad, path, PCB_ARC_T, PCB_PAD_T, PCB_TRACE_T, PCB_VIA_T, PS_NO_PATH, PS_OK, FROM_TO_CACHE::FT_PATH::to, uniquePathBetweenNodes(), and WildCompareString().

Referenced by IsOnFromToPath().

IsOnFromToPath()

bool FROM_TO_CACHE::IsOnFromToPath	(	BOARD_CONNECTED_ITEM *	aItem,
		const wxString &	aFrom,
		const wxString &	aTo
	)

Definition at line 230 of file from_to_cache.cpp.

{
    int nFromTosFound = 0;

    if( !m_board )
        return false;

    //printf("Check %d cached paths [%p]\n", m_ftPaths.size(), aItem );
    for( int attempt = 0; attempt < 2; attempt++ )
    {
        // item already belongs to path
        for( auto& ftPath : m_ftPaths )
        {
            if( aFrom == ftPath.fromWildcard &&
                    aTo == ftPath.toWildcard )
                {
                    nFromTosFound++;

                    if( ftPath.pathItems.count( aItem ) )
                    {
            //            printf("Found cached path for %p [%s->%s]\n", aItem, (const char *)ftPath.fromName, (const char *) ftPath.toName );
                        return true;
                    }
                }
        }

        if( !nFromTosFound )
            cacheFromToPaths( aFrom, aTo );
        else
            return false;
    }

    return false;
}

References cacheFromToPaths(), m_board, and m_ftPaths.

QueryFromToPath()

FROM_TO_CACHE::FT_PATH * FROM_TO_CACHE::QueryFromToPath

(

const std::set< BOARD_CONNECTED_ITEM * > &

aItems

)

Definition at line 274 of file from_to_cache.cpp.

{
    for( auto& ftPath : m_ftPaths )
    {
        if ( ftPath.pathItems == aItems )
            return &ftPath;
    }

    return nullptr;
}

References m_ftPaths.

Rebuild()

void FROM_TO_CACHE::Rebuild

(

BOARD *

aBoard

)

Definition at line 266 of file from_to_cache.cpp.

{
    m_board = aBoard;
    buildEndpointList();
    m_ftPaths.clear();
}

References buildEndpointList(), m_board, and m_ftPaths.

Member Data Documentation

m_board

BOARD* FROM_TO_CACHE::m_board

private

Definition at line 71 of file from_to_cache.h.

Referenced by buildEndpointList(), cacheFromToPaths(), IsOnFromToPath(), and Rebuild().

m_ftEndpoints

std::vector<FT_ENDPOINT> FROM_TO_CACHE::m_ftEndpoints

private

Definition at line 68 of file from_to_cache.h.

Referenced by buildEndpointList(), and cacheFromToPaths().

m_ftPaths

std::vector<FT_PATH> FROM_TO_CACHE::m_ftPaths

private

Definition at line 69 of file from_to_cache.h.

Referenced by cacheFromToPaths(), IsOnFromToPath(), QueryFromToPath(), and Rebuild().

---

The documentation for this class was generated from the following files:

• from_to_cache.h
• from_to_cache.cpp