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 33 of file from_to_cache.cpp.

34 {
35  m_ftEndpoints.clear();
36 
37  for( FOOTPRINT* footprint : m_board->Footprints() )
38  {
39  for( PAD* pad : footprint->Pads() )
40  {
41  FT_ENDPOINT ent;
42  ent.name = footprint->GetReference() + "-" + pad->GetNumber();
43  ent.parent = pad;
44  m_ftEndpoints.push_back( ent );
45  ent.name = footprint->GetReference();
46  ent.parent = pad;
47  m_ftEndpoints.push_back( ent );
48  }
49  }
50 }
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:234
Definition: pad.h:57

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 120 of file from_to_cache.cpp.

121 {
122  std::vector<FT_PATH> paths;
123  auto connectivity = m_board->GetConnectivity();
124  auto cnAlgo = connectivity->GetConnectivityAlgo();
125 
126  for( auto& endpoint : m_ftEndpoints )
127  {
128  if( WildCompareString( aFrom, endpoint.name, false ) )
129  {
130  FT_PATH p;
131  p.net = endpoint.parent->GetNetCode();
132  p.from = endpoint.parent;
133  p.to = nullptr;
134  paths.push_back(p);
135  }
136  }
137 
138  for( auto &path : paths )
139  {
140  int count = 0;
141  auto netName = path.from->GetNetname();
142 
143  wxString fromName = path.from->GetParent()->GetReference() + "-" + path.from->GetNumber();
144 
145  const KICAD_T onlyRouting[] = { PCB_PAD_T, PCB_ARC_T, PCB_VIA_T, PCB_TRACE_T, EOT };
146 
147  auto padCandidates = connectivity->GetConnectedItems( path.from, onlyRouting );
148  PAD* toPad = nullptr;
149 
150  for( auto pitem : padCandidates )
151  {
152  if( pitem == path.from )
153  continue;
154 
155  if( pitem->Type() != PCB_PAD_T )
156  continue;
157 
158  const PAD *pad = static_cast<const PAD*>( pitem );
159 
160  wxString toName = pad->GetParent()->GetReference() + "-" + pad->GetNumber();
161 
162 
163  for ( const auto& endpoint : m_ftEndpoints )
164  {
165  if( pad == endpoint.parent )
166  {
167  if( WildCompareString( aTo, endpoint.name, false ) )
168  {
169  count++;
170  toPad = endpoint.parent;
171 
172  path.to = toPad;
173  path.fromName = fromName;
174  path.toName = toName;
175  path.fromWildcard = aFrom;
176  path.toWildcard = aTo;
177 
178  if( count >= 2 )
179  {
180  // fixme: report this somewhere?
181  //printf("Multiple targets found, aborting...\n");
182  path.to = nullptr;
183  }
184  }
185  }
186  }
187  }
188  }
189 
190  int newPaths = 0;
191 
192  for( auto &path : paths )
193  {
194  if( !path.from || !path.to )
195  continue;
196 
197 
198  CN_ITEM *cnFrom = cnAlgo->ItemEntry( path.from ).GetItems().front();
199  CN_ITEM *cnTo = cnAlgo->ItemEntry( path.to ).GetItems().front();
201 
202  auto result = uniquePathBetweenNodes( cnFrom, cnTo, upath );
203 
204  if( result == PS_OK )
205  path.isUnique = true;
206  else
207  path.isUnique = false;
208 
209 
210  //printf( "%s\n", (const char *) wxString::Format( _("Check path: %s -> %s (net %s)"), path.fromName, path.toName, cnFrom->Parent()->GetNetname() ) );
211 
212  if( result == PS_NO_PATH )
213  continue;
214 
215  for( const auto item : upath )
216  {
217  path.pathItems.insert( item->Parent() );
218  }
219 
220  m_ftPaths.push_back(path);
221  newPaths++;
222  }
223 
224  // reportAux( _("Cached %d paths\n"), newPaths );
225 
226  return newPaths;
227 }
std::vector< CN_ITEM * > CONNECTED_ITEMS
std::vector< FT_ENDPOINT > m_ftEndpoints
Definition: from_to_cache.h:68
class PCB_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 PCB_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
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:345
CN_ITEM represents a BOARD_CONNETED_ITEM in the connectivity system (ie: a pad, track/arc/via,...
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.
class PCB_VIA, a via (like a track segment on a copper layer)
Definition: typeinfo.h:96
Definition: pad.h:57

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 229 of file from_to_cache.cpp.

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

274 {
275  for( auto& ftPath : m_ftPaths )
276  {
277  if ( ftPath.pathItems == aItems )
278  return &ftPath;
279  }
280 
281  return nullptr;
282 }
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 265 of file from_to_cache.cpp.

266 {
267  m_board = aBoard;
269  m_ftPaths.clear();
270 }
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: