KiCad PCB EDA Suite
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_PATHQueryFromToPath (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_ENDPOINTm_ftEndpoints
 
std::vector< FT_PATHm_ftPaths
 
BOARDm_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.

49  :
50  m_board( aBoard )
51  {
52  }
BOARD * m_board
Definition: from_to_cache.h:71

◆ ~FROM_TO_CACHE()

FROM_TO_CACHE::~FROM_TO_CACHE ( )
inline

Definition at line 54 of file from_to_cache.h.

55  {
56  }

Member Function Documentation

◆ buildEndpointList()

void FROM_TO_CACHE::buildEndpointList ( )
private

Definition at line 34 of file from_to_cache.cpp.

35 {
36  m_ftEndpoints.clear();
37 
38  for( FOOTPRINT* footprint : m_board->Footprints() )
39  {
40  for( PAD* pad : footprint->Pads() )
41  {
42  FT_ENDPOINT ent;
43  ent.name = footprint->GetReference() + "-" + pad->GetName();
44  ent.parent = pad;
45  m_ftEndpoints.push_back( ent );
46  ent.name = footprint->GetReference();
47  ent.parent = pad;
48  m_ftEndpoints.push_back( ent );
49  }
50  }
51 }
std::vector< FT_ENDPOINT > m_ftEndpoints
Definition: from_to_cache.h:68
BOARD * m_board
Definition: from_to_cache.h:71
FOOTPRINTS & Footprints()
Definition: board.h:305
Definition: pad.h:60

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.

122 {
123  std::vector<FT_PATH> paths;
124  auto connectivity = m_board->GetConnectivity();
125  auto cnAlgo = connectivity->GetConnectivityAlgo();
126 
127  for( auto& endpoint : m_ftEndpoints )
128  {
129  if( WildCompareString( aFrom, endpoint.name, false ) )
130  {
131  FT_PATH p;
132  p.net = endpoint.parent->GetNetCode();
133  p.from = endpoint.parent;
134  p.to = nullptr;
135  paths.push_back(p);
136  }
137  }
138 
139  for( auto &path : paths )
140  {
141  int count = 0;
142  auto netName = path.from->GetNetname();
143 
144  wxString fromName = path.from->GetParent()->GetReference() + "-" + path.from->GetName();
145 
146  const KICAD_T onlyRouting[] = { PCB_PAD_T, PCB_ARC_T, PCB_VIA_T, PCB_TRACE_T, EOT };
147 
148  auto padCandidates = connectivity->GetConnectedItems( path.from, onlyRouting );
149  PAD* toPad = nullptr;
150 
151  for( auto pitem : padCandidates )
152  {
153  if( pitem == path.from )
154  continue;
155 
156  if( pitem->Type() != PCB_PAD_T )
157  continue;
158 
159  const PAD *pad = static_cast<const PAD*>( pitem );
160 
161  wxString toName = pad->GetParent()->GetReference() + "-" + pad->GetName();
162 
163 
164  for ( const auto& endpoint : m_ftEndpoints )
165  {
166  if( pad == endpoint.parent )
167  {
168  if( WildCompareString( aTo, endpoint.name, false ) )
169  {
170  count++;
171  toPad = endpoint.parent;
172 
173  path.to = toPad;
174  path.fromName = fromName;
175  path.toName = toName;
176  path.fromWildcard = aFrom;
177  path.toWildcard = aTo;
178 
179  if( count >= 2 )
180  {
181  // fixme: report this somewhere?
182  //printf("Multiple targets found, aborting...\n");
183  path.to = nullptr;
184  }
185  }
186  }
187  }
188  }
189  }
190 
191  int newPaths = 0;
192 
193  for( auto &path : paths )
194  {
195  if( !path.from || !path.to )
196  continue;
197 
198 
199  CN_ITEM *cnFrom = cnAlgo->ItemEntry( path.from ).GetItems().front();
200  CN_ITEM *cnTo = cnAlgo->ItemEntry( path.to ).GetItems().front();
202 
203  auto result = uniquePathBetweenNodes( cnFrom, cnTo, upath );
204 
205  if( result == PS_OK )
206  path.isUnique = true;
207  else
208  path.isUnique = false;
209 
210 
211  //printf( "%s\n", (const char *) wxString::Format( _("Check path: %s -> %s (net %s)"), path.fromName, path.toName, cnFrom->Parent()->GetNetname() ) );
212 
213  if( result == PS_NO_PATH )
214  continue;
215 
216  for( const auto item : upath )
217  {
218  path.pathItems.insert( item->Parent() );
219  }
220 
221  m_ftPaths.push_back(path);
222  newPaths++;
223  }
224 
225  // reportAux( _("Cached %d paths\n"), newPaths );
226 
227  return newPaths;
228 }
std::vector< CN_ITEM * > CONNECTED_ITEMS
std::vector< FT_ENDPOINT > m_ftEndpoints
Definition: from_to_cache.h:68
class ARC, an arc track segment on a copper layer
Definition: typeinfo.h:97
BOARD * m_board
Definition: from_to_cache.h:71
class PAD, a pad in a footprint
Definition: typeinfo.h:89
search types array terminator (End Of Types)
Definition: typeinfo.h:81
KICAD_T
The set of class identification values stored in EDA_ITEM::m_structType.
Definition: typeinfo.h:77
class TRACK, a track segment (segment on a copper layer)
Definition: typeinfo.h:95
std::vector< FT_PATH > m_ftPaths
Definition: from_to_cache.h:69
bool WildCompareString(const wxString &pattern, const wxString &string_to_tst, bool case_sensitive)
Compare a string against wild card (* and ?) pattern using the usual rules.
Definition: string.cpp:519
static PATH_STATUS uniquePathBetweenNodes(CN_ITEM *u, CN_ITEM *v, std::vector< CN_ITEM * > &outPath)
std::shared_ptr< CONNECTIVITY_DATA > GetConnectivity() const
Return a list of missing connections between components/tracks.
Definition: board.h:416
class VIA, a via (like a track segment on a copper layer)
Definition: typeinfo.h:96
Definition: pad.h:60

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.

231 {
232  int nFromTosFound = 0;
233 
234  if( !m_board )
235  return false;
236 
237  //printf("Check %d cached paths [%p]\n", m_ftPaths.size(), aItem );
238  for( int attempt = 0; attempt < 2; attempt++ )
239  {
240  // item already belongs to path
241  for( auto& ftPath : m_ftPaths )
242  {
243  if( aFrom == ftPath.fromWildcard &&
244  aTo == ftPath.toWildcard )
245  {
246  nFromTosFound++;
247 
248  if( ftPath.pathItems.count( aItem ) )
249  {
250  // printf("Found cached path for %p [%s->%s]\n", aItem, (const char *)ftPath.fromName, (const char *) ftPath.toName );
251  return true;
252  }
253  }
254  }
255 
256  if( !nFromTosFound )
257  cacheFromToPaths( aFrom, aTo );
258  else
259  return false;
260  }
261 
262  return false;
263 }
BOARD * m_board
Definition: from_to_cache.h:71
std::vector< FT_PATH > m_ftPaths
Definition: from_to_cache.h:69
int cacheFromToPaths(const wxString &aFrom, const wxString &aTo)

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.

275 {
276  for( auto& ftPath : m_ftPaths )
277  {
278  if ( ftPath.pathItems == aItems )
279  return &ftPath;
280  }
281 
282  return nullptr;
283 }
std::vector< FT_PATH > m_ftPaths
Definition: from_to_cache.h:69

References m_ftPaths.

◆ Rebuild()

void FROM_TO_CACHE::Rebuild ( BOARD aBoard)

Definition at line 266 of file from_to_cache.cpp.

267 {
268  m_board = aBoard;
270  m_ftPaths.clear();
271 }
BOARD * m_board
Definition: from_to_cache.h:71
std::vector< FT_PATH > m_ftPaths
Definition: from_to_cache.h:69
void buildEndpointList()

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: