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 33 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() + wxT( "-" ) + pad->GetNumber();
 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 122 of file from_to_cache.cpp.

{
 std::vector<FT_PATH> paths;
 std::shared_ptr<CONNECTIVITY_DATA> connectivity = m_board->GetConnectivity();
 std::shared_ptr<CN_CONNECTIVITY_ALGO> cnAlgo = connectivity->GetConnectivityAlgo();
 
 for( FT_ENDPOINT& 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( FT_PATH& path : paths )
 {
 int count = 0;
 
 wxString fromName = path.from->GetParent()->GetReference() + wxT( "-" )
 + path.from->GetNumber();
 
 auto padCandidates = connectivity->GetConnectedItems( path.from,
 { PCB_PAD_T, PCB_ARC_T, PCB_VIA_T, PCB_TRACE_T } );
 PAD* toPad = nullptr;
 
 for( BOARD_CONNECTED_ITEM* 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() + wxT( "-" ) + pad->GetNumber();
 
 
 for( const FT_ENDPOINT& 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( FT_PATH& 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();
 std::vector<CN_ITEM*> 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 FROM_TO_CACHE::FT_PATH::from, BOARD::GetConnectivity(), m_board, m_ftEndpoints, m_ftPaths, FROM_TO_CACHE::FT_PATH::net, pad, path, PCB_PAD_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 229 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( FT_PATH& 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 272 of file from_to_cache.cpp.

{
 for( FT_PATH& 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 264 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