SCH_REFERENCE_LIST Class Reference

Container to create a flattened list of symbols because in a complex hierarchy, a symbol can be used more than once and its reference designator is dependent on the sheet path for the same symbol. More...

#include <sch_reference_list.h>

Public Member Functions
	SCH_REFERENCE_LIST ()
SCH_REFERENCE &	operator[] (int aIndex)
const SCH_REFERENCE &	operator[] (int aIndex) const
void	Clear ()
size_t	GetCount () const
SCH_REFERENCE &	GetItem (int aIdx)
const SCH_REFERENCE &	GetItem (int aIdx) const
void	AddItem (const SCH_REFERENCE &aItem)
void	RemoveItem (unsigned int aIndex)
	Remove an item from the list of references. More...
bool	Contains (const SCH_REFERENCE &aItem) const
	Return true if aItem exists in this list. More...
void	SplitReferences ()
	Attempt to split all reference designators into a name (U) and number (1). More...
void	RemoveAnnotation (bool aIncludePowerSymbols)
	Treat all symbols in this list as non-annotated. More...
void	UpdateAnnotation ()
	Update the symbol references for the schematic project (or the current sheet). More...
void	ReannotateByOptions (ANNOTATE_ORDER_T aSortOption, ANNOTATE_ALGO_T aAlgoOption, int aStartNumber, const SCH_REFERENCE_LIST &aAdditionalRefs, bool aStartAtCurrent, SCH_SHEET_LIST *aHierarchy)
	Forces reannotation of the provided references. More...
void	ReannotateDuplicates (const SCH_REFERENCE_LIST &aAdditionalReferences)
	Convenience function for the Paste Unique functionality. More...
void	AnnotateByOptions (enum ANNOTATE_ORDER_T aSortOption, enum ANNOTATE_ALGO_T aAlgoOption, int aStartNumber, SCH_MULTI_UNIT_REFERENCE_MAP aLockedUnitMap, const SCH_REFERENCE_LIST &aAdditionalRefs, bool aStartAtCurrent)
	Annotate the references by the provided options. More...
void	Annotate (bool aUseSheetNum, int aSheetIntervalId, int aStartNumber, SCH_MULTI_UNIT_REFERENCE_MAP aLockedUnitMap, const SCH_REFERENCE_LIST &aAdditionalRefs, bool aStartAtCurrent=false)
	Set the reference designators in the list that have not been annotated. More...
int	CheckAnnotation (ANNOTATION_ERROR_HANDLER aErrorHandler)
	Check for annotations errors. More...
void	SortByXCoordinate ()
	Sort the list of references by X position. More...
void	SortByYCoordinate ()
	Sort the list of references by Y position. More...
void	SortByTimeStamp ()
	Sort the flat list by Time Stamp (sheet path + timestamp). More...
void	SortByRefAndValue ()
	Sort the list of references by value. More...
void	SortByReferenceOnly ()
	Sort the list of references by reference. More...
int	FindRef (const wxString &aPath) const
	Search the list for a symbol with a given reference. More...
int	FindUnit (size_t aIndex, int aUnit, bool aIncludeNew=false) const
	Search the sorted list of symbols for a another symbol with the same reference and a given part unit. More...
int	FindRefByPath (const wxString &aPath) const
	Search the list for a symbol with the given KIID path. More...
void	GetRefsInUse (int aIndex, std::vector< int > &aIdList, int aMinRefId) const
	Add all the reference designator numbers greater than aMinRefId to aIdList skipping the reference at aIndex. More...
std::vector< int >	GetUnitsMatchingRef (const SCH_REFERENCE &aRef) const
	Return all the unit numbers for a given reference, comparing library reference, value, reference number and reference prefix. More...
int	FindFirstUnusedReference (const SCH_REFERENCE &aRef, int aMinValue, const std::vector< int > &aRequiredUnits) const
	Return the first unused reference number from the properties given in aRef, ensuring all of the units in aRequiredUnits are also unused. More...
std::vector< SYMBOL_INSTANCE_REFERENCE >	GetSymbolInstances () const

Static Public Member Functions
static wxString	Shorthand (std::vector< SCH_REFERENCE > aList)
	Return a shorthand string representing all the references in the list. More...

Static Private Member Functions
static bool	sortByRefAndValue (const SCH_REFERENCE &item1, const SCH_REFERENCE &item2)
static bool	sortByXPosition (const SCH_REFERENCE &item1, const SCH_REFERENCE &item2)
static bool	sortByYPosition (const SCH_REFERENCE &item1, const SCH_REFERENCE &item2)
static bool	sortByTimeStamp (const SCH_REFERENCE &item1, const SCH_REFERENCE &item2)
static bool	sortByReferenceOnly (const SCH_REFERENCE &item1, const SCH_REFERENCE &item2)
static int	createFirstFreeRefId (std::vector< int > &aIdList, int aFirstValue)
	Search for the first free reference number in aListId of reference numbers in use. More...

Private Attributes
std::vector< SCH_REFERENCE >	flatList

Friends
class	BACK_ANNOTATION
class	BACK_ANNOTATE

Detailed Description

Container to create a flattened list of symbols because in a complex hierarchy, a symbol can be used more than once and its reference designator is dependent on the sheet path for the same symbol.

This flattened list is used for netlist generation, BOM generation, and schematic annotation.

Definition at line 241 of file sch_reference_list.h.

Constructor & Destructor Documentation

SCH_REFERENCE_LIST()

SCH_REFERENCE_LIST::SCH_REFERENCE_LIST ( )

inline

Definition at line 248 of file sch_reference_list.h.

 {
 }

Member Function Documentation

AddItem()

void SCH_REFERENCE_LIST::AddItem ( const SCH_REFERENCE &  aItem )

inline

Definition at line 272 of file sch_reference_list.h.

{ flatList.push_back( aItem ); }

References flatList.

Referenced by Annotate(), SCH_SHEET_LIST::AnnotatePowerSymbols(), SCH_EDIT_FRAME::AnnotateSymbols(), SCH_SHEET_PATH::AppendSymbol(), TEST_SCH_REFERENCE_LIST_FIXTURE::getAdditionalRefs(), SCH_EDITOR_CONTROL::Paste(), and SCH_DRAWING_TOOLS::PlaceSymbol().

Annotate()

void SCH_REFERENCE_LIST::Annotate	(	bool	aUseSheetNum,
		int	aSheetIntervalId,
		int	aStartNumber,
		SCH_MULTI_UNIT_REFERENCE_MAP	aLockedUnitMap,
		const SCH_REFERENCE_LIST &	aAdditionalRefs,
		bool	aStartAtCurrent = false
	)

Set the reference designators in the list that have not been annotated.

If a the sheet number is 2 and aSheetIntervalId is 100, then the first reference designator would be 201 and the last reference designator would be 299 when no overlap occurs with sheet number 3. If there are 150 items in sheet number 2, then items are referenced U201 to U351, and items in sheet 3 start from U352

Parameters

aUseSheetNum	Set to true to start annotation for each sheet at the sheet number times aSheetIntervalId. Otherwise annotate incrementally.
aSheetIntervalId	The per sheet reference designator multiplier.
aStartNumber	The number to start with if NOT numbering based on sheet number.
aLockedUnitMap	A SCH_MULTI_UNIT_REFERENCE_MAP of reference designator wxStrings to SCH_REFERENCE_LISTs. May be an empty map. If not empty, any multi-unit parts found in this map will be annotated as a group rather than individually.
aAdditionalRefs	Additional references to use for checking that there a reference designator doesn't already exist. The caller must ensure that none of the references in aAdditionalRefs exist in this list.
aStartAtCurrent	Use m_numRef for each reference as the start number (overrides aStartNumber)

Definition at line 469 of file component_references_lister.cpp.

{
 if ( flatList.size() == 0 )
 return;
 
 size_t originalSize = GetCount();
 
 // For multi units symbols, store the list of already used full references.
 // The algorithm tries to allocate the new reference to symbols having the same
 // old reference.
 // This algo works fine as long as the previous annotation has no duplicates.
 // But when a hierarchy is reannotated with this option, the previous annotation can
 // have duplicate references, and obviously we must fix these duplicate.
 // therefore do not try to allocate a full reference more than once when trying
 // to keep this order of multi units.
 // inUseRefs keep trace of previously allocated references
 std::unordered_set<wxString> inUseRefs;
 
 for( size_t i = 0; i < aAdditionalRefs.GetCount(); i++ )
 {
 SCH_REFERENCE additionalRef = aAdditionalRefs[i];
 additionalRef.Split();
 
 // Add the additional reference to the multi-unit set if annotated
 if( !additionalRef.m_isNew )
 inUseRefs.insert( buildFullReference( additionalRef ) );
 
 // We don't want to reannotate the additional references even if not annotated
 // so we change the m_isNew flag to be false after splitting
 additionalRef.m_isNew = false;
 AddItem( additionalRef ); //add to this container
 }
 
 int LastReferenceNumber = 0;
 
 /* calculate index of the first symbol with the same reference prefix
 * than the current symbol. All symbols having the same reference
 * prefix will receive a reference number with consecutive values:
 * IC .. will be set to IC4, IC4, IC5 ...
 */
 unsigned first = 0;
 
 // calculate the last used number for this reference prefix:
 int minRefId;
 
 // when using sheet number, ensure ref number >= sheet number* aSheetIntervalId
 if( aUseSheetNum )
 minRefId = flatList[first].m_sheetNum * aSheetIntervalId + 1;
 else
 minRefId = aStartNumber + 1;
 
 
 for( unsigned ii = 0; ii < flatList.size(); ii++ )
 {
 auto& ref_unit = flatList[ii];
 
 if( ref_unit.m_flag )
 continue;
 
 // Check whether this symbol is in aLockedUnitMap.
 SCH_REFERENCE_LIST* lockedList = nullptr;
 
 for( SCH_MULTI_UNIT_REFERENCE_MAP::value_type& pair : aLockedUnitMap )
 {
 unsigned n_refs = pair.second.GetCount();
 
 for( unsigned thisRefI = 0; thisRefI < n_refs; ++thisRefI )
 {
 SCH_REFERENCE &thisRef = pair.second[thisRefI];
 
 if( thisRef.IsSameInstance( ref_unit ) )
 {
 lockedList = &pair.second;
 break;
 }
 }
 
 if( lockedList != nullptr )
 break;
 }
 
 if( ( flatList[first].CompareRef( ref_unit ) != 0 )
 || ( aUseSheetNum && ( flatList[first].m_sheetNum != ref_unit.m_sheetNum ) ) )
 {
 // New reference found: we need a new ref number for this reference
 first = ii;
 
 // when using sheet number, ensure ref number >= sheet number* aSheetIntervalId
 if( aUseSheetNum )
 minRefId = ref_unit.m_sheetNum * aSheetIntervalId + 1;
 else
 minRefId = aStartNumber + 1;
 }
 
 // Find references greater than current reference (unless not annotated)
 if( aStartAtCurrent && ref_unit.m_numRef > 0 )
 minRefId = ref_unit.m_numRef;
 
 // Annotation of one part per package symbols (trivial case).
 if( ref_unit.GetLibPart()->GetUnitCount() <= 1 )
 {
 if( ref_unit.m_isNew )
 {
 std::vector<int> idList;
 GetRefsInUse( first, idList, minRefId );
 LastReferenceNumber = createFirstFreeRefId( idList, minRefId );
 ref_unit.m_numRef = LastReferenceNumber;
 }
 
 ref_unit.m_flag = 1;
 ref_unit.m_isNew = false;
 continue;
 }
 
 // If this symbol is in aLockedUnitMap, copy the annotation to all
 // symbols that are not it
 if( lockedList != nullptr )
 {
 unsigned n_refs = lockedList->GetCount();
 std::vector<int> units = lockedList->GetUnitsMatchingRef( ref_unit );
 
 if( ref_unit.m_isNew )
 {
 LastReferenceNumber = FindFirstUnusedReference( ref_unit, minRefId, units );
 ref_unit.m_numRef = LastReferenceNumber;
 ref_unit.m_isNew = false;
 ref_unit.m_flag = 1;
 }
 
 for( unsigned lockedRefI = 0; lockedRefI < n_refs; ++lockedRefI )
 {
 SCH_REFERENCE& lockedRef = ( *lockedList )[lockedRefI];
 
 if( lockedRef.IsSameInstance( ref_unit ) )
 {
 // This is the symbol we're currently annotating. Hold the unit!
 ref_unit.m_unit = lockedRef.m_unit;
 // lock this new full reference
 inUseRefs.insert( buildFullReference( ref_unit ) );
 }
 
 if( lockedRef.CompareValue( ref_unit ) != 0 )
 continue;
 
 if( lockedRef.CompareLibName( ref_unit ) != 0 )
 continue;
 
 // Find the matching symbol
 for( unsigned jj = ii + 1; jj < flatList.size(); jj++ )
 {
 if( !lockedRef.IsSameInstance( flatList[jj] ) )
 continue;
 
 wxString ref_candidate = buildFullReference( ref_unit, lockedRef.m_unit );
 
 // propagate the new reference and unit selection to the "old" symbol,
 // if this new full reference is not already used (can happens when initial
 // multiunits symbols have duplicate references)
 if( inUseRefs.find( ref_candidate ) == inUseRefs.end() )
 {
 flatList[jj].m_numRef = ref_unit.m_numRef;
 flatList[jj].m_isNew = false;
 flatList[jj].m_flag = 1;
 // lock this new full reference
 inUseRefs.insert( ref_candidate );
 break;
 }
 }
 }
 }
 else if( ref_unit.m_isNew )
 {
 // Reference belonging to multi-unit symbol that has not yet been annotated. We don't
 // know what group this might belong to, so just find the first unused reference for
 // this specific unit. The other units will be annotated in the following passes.
 std::vector<int> units = { ref_unit.GetUnit() };
 LastReferenceNumber = FindFirstUnusedReference( ref_unit, minRefId, units );
 ref_unit.m_numRef = LastReferenceNumber;
 ref_unit.m_isNew = false;
 ref_unit.m_flag = 1;
 }
 }
 
 // Remove aAdditionalRefs references
 for( size_t i = originalSize; i < ( aAdditionalRefs.GetCount() + originalSize ); i++ )
 RemoveItem( originalSize );
 
 wxASSERT( originalSize == GetCount() ); // Make sure we didn't make a mistake
}

References AddItem(), buildFullReference(), SCH_REFERENCE::CompareLibName(), SCH_REFERENCE::CompareValue(), createFirstFreeRefId(), FindFirstUnusedReference(), flatList, GetCount(), GetRefsInUse(), GetUnitsMatchingRef(), SCH_REFERENCE::IsSameInstance(), SCH_REFERENCE::m_isNew, SCH_REFERENCE::m_unit, RemoveItem(), and SCH_REFERENCE::Split().

Referenced by AnnotateByOptions(), SCH_SHEET_LIST::AnnotatePowerSymbols(), and UpdateAnnotation().

AnnotateByOptions()

void SCH_REFERENCE_LIST::AnnotateByOptions	(	enum ANNOTATE_ORDER_T	aSortOption,
		enum ANNOTATE_ALGO_T	aAlgoOption,
		int	aStartNumber,
		SCH_MULTI_UNIT_REFERENCE_MAP	aLockedUnitMap,
		const SCH_REFERENCE_LIST &	aAdditionalRefs,
		bool	aStartAtCurrent
	)

Annotate the references by the provided options.

Parameters

aSortOption	Define the annotation order. See ANNOTATE_ORDER_T.
aAlgoOption	Define the annotation style. See ANNOTATE_ALGO_T.
aStartNumber	The start number for non-sheet-based annotation styles.
appendUndo	True if the annotation operation should be added to an existing undo, false if it should be separately undo-able.
aLockedUnitMap	A SCH_MULTI_UNIT_REFERENCE_MAP of reference designator wxStrings to SCH_REFERENCE_LISTs. May be an empty map. If not empty, any multi-unit parts found in this map will be annotated as a group rather than individually.
aAdditionalReferences	Additional references to check for duplicates
aStartAtCurrent	Use m_numRef for each reference as the start number (overrides aStartNumber)

Definition at line 427 of file component_references_lister.cpp.

{
 switch( aSortOption )
 {
 default:
 case SORT_BY_X_POSITION: SortByXCoordinate(); break;
 case SORT_BY_Y_POSITION: SortByYCoordinate(); break;
 }
 
 bool useSheetNum;
 int idStep;
 
 switch( aAlgoOption )
 {
 default:
 case INCREMENTAL_BY_REF:
 useSheetNum = false;
 idStep = 1;
 break;
 
 case SHEET_NUMBER_X_100:
 useSheetNum = true;
 idStep = 100;
 aStartAtCurrent = false; // Not implemented for sheet # * 100
 break;
 
 case SHEET_NUMBER_X_1000:
 useSheetNum = true;
 idStep = 1000;
 aStartAtCurrent = false; // Not implemented for sheet # * 1000
 break;
 }
 
 Annotate( useSheetNum, idStep, aStartNumber, aLockedUnitMap, aAdditionalRefs, aStartAtCurrent );
}

References Annotate(), INCREMENTAL_BY_REF, SHEET_NUMBER_X_100, SHEET_NUMBER_X_1000, SORT_BY_X_POSITION, SORT_BY_Y_POSITION, SortByXCoordinate(), and SortByYCoordinate().

Referenced by SCH_EDIT_FRAME::AnnotateSymbols(), and ReannotateByOptions().

CheckAnnotation()

int SCH_REFERENCE_LIST::CheckAnnotation

(

ANNOTATION_ERROR_HANDLER

aErrorHandler

)

Check for annotations errors.

The following annotation error conditions are tested:

• Symbols not annotated.
• Symbols having the same reference designator (duplicates).
• Symbols with multiple parts per package having different reference designators.
• Symbols with multiple parts per package with invalid part count.

Parameters

aErrorHandler

A handler for errors.

Returns

The number of errors found.

Definition at line 662 of file component_references_lister.cpp.

{
 int error = 0;
 wxString tmp;
 wxString msg;
 
 SortByRefAndValue();
 
 // Split reference designators into name (prefix) and number: IC1 becomes IC, and 1.
 SplitReferences();
 
 // count not yet annotated items or annotation error.
 for( unsigned ii = 0; ii < flatList.size(); ii++ )
 {
 msg.Empty();
 tmp.Empty();
 
 if( flatList[ii].m_isNew ) // Not yet annotated
 {
 if( flatList[ii].m_numRef >= 0 )
 tmp << flatList[ii].m_numRef;
 else
 tmp = wxT( "?" );
 
 if( ( flatList[ii].m_unit > 0 ) && ( flatList[ii].m_unit < 0x7FFFFFFF ) )
 {
 msg.Printf( _( "Item not annotated: %s%s (unit %d)" ),
 flatList[ii].GetRef(),
 tmp,
 flatList[ii].m_unit );
 }
 else
 {
 msg.Printf( _( "Item not annotated: %s%s" ), flatList[ii].GetRef(), tmp );
 }
 
 aHandler( ERCE_UNANNOTATED, msg, &flatList[ii], nullptr );
 error++;
 break;
 }
 
 // Error if unit number selected does not exist (greater than the number of units in
 // the symbol). This can happen if a symbol has changed in a library after a
 // previous annotation.
 if( std::max( flatList[ii].GetLibPart()->GetUnitCount(), 1 ) < flatList[ii].m_unit )
 {
 if( flatList[ii].m_numRef >= 0 )
 tmp << flatList[ii].m_numRef;
 else
 tmp = wxT( "?" );
 
 msg.Printf( _( "Error: symbol %s%s%s (unit %d) exceeds units defined (%d)" ),
 flatList[ii].GetRef(),
 tmp,
 LIB_SYMBOL::SubReference( flatList[ii].m_unit ),
 flatList[ii].m_unit,
 flatList[ii].GetLibPart()->GetUnitCount() );
 
 aHandler( ERCE_EXTRA_UNITS, msg, &flatList[ii], nullptr );
 error++;
 break;
 }
 }
 
 // count the duplicated elements (if all are annotated)
 int imax = flatList.size() - 1;
 
 for( int ii = 0; ii < imax; ii++ )
 {
 msg.Empty();
 tmp.Empty();
 
 if( ( flatList[ii].CompareRef( flatList[ii + 1] ) != 0 )
 || ( flatList[ii].m_numRef != flatList[ ii + 1].m_numRef ) )
 {
 continue;
 }
 
 // Same reference found. If same unit, error!
 if( flatList[ii].m_unit == flatList[ ii + 1].m_unit )
 {
 if( flatList[ii].m_numRef >= 0 )
 tmp << flatList[ii].m_numRef;
 else
 tmp = wxT( "?" );
 
 if( ( flatList[ii].GetLibPart()->GetUnitCount() > 1 )
 && ( flatList[ii].m_unit > 0 )
 && ( flatList[ii].m_unit < 0x7FFFFFFF ) )
 {
 msg.Printf( _( "Duplicate items %s%s%s\n" ),
 flatList[ii].GetRef(),
 tmp,
 LIB_SYMBOL::SubReference( flatList[ii].m_unit ) );
 }
 else
 {
 msg.Printf( _( "Duplicate items %s%s\n" ), flatList[ii].GetRef(), tmp );
 }
 
 aHandler( ERCE_DUPLICATE_REFERENCE, msg, &flatList[ii], &flatList[ii+1] );
 error++;
 continue;
 }
 
 /* Test error if units are different but number of parts per package
 * too high (ex U3 ( 1 part) and we find U3B this is an error) */
 if( flatList[ii].GetLibPart()->GetUnitCount()
 != flatList[ ii + 1].GetLibPart()->GetUnitCount() )
 {
 if( flatList[ii].m_numRef >= 0 )
 tmp << flatList[ii].m_numRef;
 else
 tmp = wxT( "?" );
 
 if( ( flatList[ii].m_unit > 0 )
 && ( flatList[ii].m_unit < 0x7FFFFFFF ) )
 {
 msg.Printf( _( "Duplicate items %s%s%s\n" ),
 flatList[ii].GetRef(),
 tmp,
 LIB_SYMBOL::SubReference( flatList[ii].m_unit ) );
 }
 else
 {
 msg.Printf( _( "Duplicate items %s%s\n" ), flatList[ii].GetRef(), tmp );
 }
 
 aHandler( ERCE_DUPLICATE_REFERENCE, msg, &flatList[ii], &flatList[ii+1] );
 error++;
 }
 
 // Error if values are different between units, for the same reference
 int next = ii + 1;
 
 if( flatList[ii].CompareValue( flatList[next] ) != 0 )
 {
 msg.Printf( _( "Different values for %s%d%s (%s) and %s%d%s (%s)" ),
 flatList[ii].GetRef(),
 flatList[ii].m_numRef,
 LIB_SYMBOL::SubReference( flatList[ii].m_unit ),
 flatList[ii].m_value,
 flatList[next].GetRef(),
 flatList[next].m_numRef,
 LIB_SYMBOL::SubReference( flatList[next].m_unit ),
 flatList[next].m_value );
 
 aHandler( ERCE_DIFFERENT_UNIT_VALUE, msg, &flatList[ii], &flatList[ii+1] );
 error++;
 }
 }
 
 return error;
}

References _, ERCE_DIFFERENT_UNIT_VALUE, ERCE_DUPLICATE_REFERENCE, ERCE_EXTRA_UNITS, ERCE_UNANNOTATED, flatList, next(), SortByRefAndValue(), SplitReferences(), and LIB_SYMBOL::SubReference().

Referenced by SCH_EDIT_FRAME::CheckAnnotate().

Clear()

void SCH_REFERENCE_LIST::Clear ( )

inline

Definition at line 262 of file sch_reference_list.h.

 {
 flatList.clear();
 }

References flatList.

Referenced by TEST_SCH_REFERENCE_LIST_FIXTURE::loadTestCase().

Contains()

bool SCH_REFERENCE_LIST::Contains

(

const SCH_REFERENCE &

aItem

)

const

Return true if aItem exists in this list.

Parameters

aItem

Reference to check

Returns

true if aItem exists in this list

Definition at line 52 of file component_references_lister.cpp.

{
 for( unsigned ii = 0; ii < GetCount(); ii++ )
 {
 if( flatList[ii].IsSameInstance( aItem ) )
 return true;
 }
 
 return false;
}

References flatList, and GetCount().

Referenced by SCH_EDIT_FRAME::AnnotateSymbols(), and TEST_SCH_REFERENCE_LIST_FIXTURE::getAdditionalRefs().

createFirstFreeRefId()

int SCH_REFERENCE_LIST::createFirstFreeRefId ( std::vector< int > &  aIdList, int  aFirstValue  )

staticprivate

Search for the first free reference number in aListId of reference numbers in use.

This function just searches for a hole in a list of incremented numbers, this list must be sorted by increasing values and each value can be stored only once. The new value is added to the list.

See also

BuildRefIdInUseList to prepare this list

Parameters

aIdList	The buffer that contains the reference numbers in use.
aFirstValue	The first expected free value

Returns

The first free (not yet used) value.

Definition at line 329 of file component_references_lister.cpp.

{
 int expectedId = aFirstValue;
 
 // We search for expected Id a value >= aFirstValue.
 // Skip existing Id < aFirstValue
 unsigned ii = 0;
 
 for( ; ii < aIdList.size(); ii++ )
 {
 if( expectedId <= aIdList[ii] )
 break;
 }
 
 // Ids are sorted by increasing value, from aFirstValue
 // So we search from aFirstValue the first not used value, i.e. the first hole in list.
 for( ; ii < aIdList.size(); ii++ )
 {
 if( expectedId != aIdList[ii] ) // This id is not yet used.
 {
 // Insert this free Id, in order to keep list sorted
 aIdList.insert( aIdList.begin() + ii, expectedId );
 return expectedId;
 }
 
 expectedId++;
 }
 
 // All existing Id are tested, and all values are found in use.
 // So Create a new one.
 aIdList.push_back( expectedId );
 return expectedId;
}

Referenced by Annotate().

FindFirstUnusedReference()

int SCH_REFERENCE_LIST::FindFirstUnusedReference	(	const SCH_REFERENCE &	aRef,
		int	aMinValue,
		const std::vector< int > &	aRequiredUnits
	)		const

Return the first unused reference number from the properties given in aRef, ensuring all of the units in aRequiredUnits are also unused.

Parameters

aIndex	The index of the reference item used for the search pattern.
aMinValue	The minimum value for the current search.
aRequiredUnits	List of units to ensure are free

Definition at line 260 of file component_references_lister.cpp.

{
 // Create a map of references indexed by reference number, only including those with the same
 // reference prefix as aRef
 std::map<int, std::vector<SCH_REFERENCE>> refNumberMap;
 
 for( const SCH_REFERENCE& ref : flatList )
 {
 // search only for the current reference prefix:
 if( ref.CompareRef( aRef ) != 0 )
 continue;
 
 if( ref.m_isNew )
 continue; // It will be reannotated
 
 refNumberMap[ref.m_numRef].push_back( ref );
 }
 
 // Start at the given minimum value
 int minFreeNumber = aMinValue;
 
 for( ; refNumberMap[minFreeNumber].size() > 0; ++minFreeNumber )
 {
 auto isNumberInUse = [&]() -> bool
 {
 for( const int& unit : aRequiredUnits )
 {
 for( const SCH_REFERENCE& ref : refNumberMap[minFreeNumber] )
 {
 if( ref.CompareLibName( aRef ) || ref.CompareValue( aRef )
 || ref.GetUnit() == unit )
 {
 return true;
 }
 }
 }
 
 return false;
 };
 
 if( !isNumberInUse() )
 return minFreeNumber;
 }
 
 return minFreeNumber;
}

References flatList.

Referenced by Annotate().

FindRef()

int SCH_REFERENCE_LIST::FindRef

(

const wxString &

aPath

)

const

Search the list for a symbol with a given reference.

Definition at line 190 of file component_references_lister.cpp.

{
 for( size_t i = 0; i < flatList.size(); ++i )
 {
 if( flatList[i].GetRef() == aRef )
 return i;
 }
 
 return -1;
}

References flatList.

Referenced by BACK_ANNOTATE::getChangeList().

FindRefByPath()

int SCH_REFERENCE_LIST::FindRefByPath

(

const wxString &

aPath

)

const

Search the list for a symbol with the given KIID path.

Parameters

aPath

is the path to search.

Returns

index in aSymbolsList if found or -1 if not found.

Definition at line 178 of file component_references_lister.cpp.

{
 for( size_t i = 0; i < flatList.size(); ++i )
 {
 if( flatList[i].GetPath() == aPath )
 return i;
 }
 
 return -1;
}

References flatList.

Referenced by BACK_ANNOTATE::getChangeList().

FindUnit()

int SCH_REFERENCE_LIST::FindUnit	(	size_t	aIndex,
		int	aUnit,
		bool	aIncludeNew = false
	)		const

Search the sorted list of symbols for a another symbol with the same reference and a given part unit.

Use this method to manage symbols with multiple parts per package.

Parameters

aIndex	is the index in aSymbolsList for of given SCH_REFERENCE item to test.
aUnit	is the given unit number to search.
aIncludeNew	true to include references with the "new" flag in the search.

Returns

index in aSymbolsList if found or -1 if not found.

Definition at line 158 of file component_references_lister.cpp.

{
 int NumRef = flatList[aIndex].m_numRef;
 
 for( size_t ii = 0; ii < flatList.size(); ii++ )
 {
 if( ( aIndex == ii )
 || ( flatList[ii].m_isNew && !aIncludeNew )
 || ( flatList[ii].m_numRef != NumRef )
 || ( flatList[aIndex].CompareRef( flatList[ii] ) != 0 ) )
 continue;
 
 if( flatList[ii].m_unit == aUnit )
 return (int) ii;
 }
 
 return -1;
}

References flatList.

GetCount()

size_t SCH_REFERENCE_LIST::GetCount ( ) const

inline

Definition at line 267 of file sch_reference_list.h.

{ return flatList.size(); }

References flatList.

Referenced by FIELDS_EDITOR_GRID_DATA_MODEL::AddColumn(), Annotate(), SCH_SHEET_LIST::AnnotatePowerSymbols(), SCH_EDIT_FRAME::AnnotateSymbols(), FIELDS_EDITOR_GRID_DATA_MODEL::ApplyData(), SCH_EDITOR_CONTROL::AssignFootprints(), SCH_EDIT_FRAME::CheckAnnotate(), BACK_ANNOTATE::checkForUnusedSymbols(), CollectOtherUnits(), Contains(), SCHEMATIC::ConvertRefsToKIIDs(), SCH_EDITOR_CONTROL::ExportSymbolsToLibrary(), findSymbolsAndPins(), TEST_SCH_REFERENCE_LIST_FIXTURE::getAdditionalRefs(), BACK_ANNOTATE::getChangeList(), FIELDS_EDITOR_GRID_DATA_MODEL::GetDataWidth(), DIALOG_EDIT_SYMBOLS_LIBID::initDlg(), DIALOG_SYMBOL_FIELDS_TABLE::LoadFieldNames(), SCH_EDIT_FRAME::mapExistingAnnotation(), DIALOG_SCH_FIELD_PROPERTIES::onScintillaCharAdded(), DIALOG_TEXT_PROPERTIES::onScintillaCharAdded(), SCH_DRAWING_TOOLS::PlaceSymbol(), SCH_EDITOR_CONTROL::processCmpToFootprintLinkFile(), ReannotateByOptions(), FIELDS_EDITOR_GRID_DATA_MODEL::RebuildRows(), RemoveAnnotation(), FIELDS_EDITOR_GRID_DATA_MODEL::RemoveColumn(), sheetContainsOnlyWantedItems(), SplitReferences(), ERC_TESTER::TestMultiunitFootprints(), and UpdateAnnotation().

GetItem() [1/2]

SCH_REFERENCE & SCH_REFERENCE_LIST::GetItem ( int  aIdx )

inline

Definition at line 269 of file sch_reference_list.h.

{ return flatList[aIdx]; }

References flatList.

Referenced by ERC_TESTER::TestMultiunitFootprints().

GetItem() [2/2]

const SCH_REFERENCE & SCH_REFERENCE_LIST::GetItem ( int  aIdx ) const

inline

Definition at line 270 of file sch_reference_list.h.

{ return flatList[aIdx]; }

References flatList.

GetRefsInUse()

void SCH_REFERENCE_LIST::GetRefsInUse	(	int	aIndex,
		std::vector< int > &	aIdList,
		int	aMinRefId
	)		const

Add all the reference designator numbers greater than aMinRefId to aIdList skipping the reference at aIndex.

Parameters

aIndex	is the current symbol's index to use for reference prefix filtering.
aIdList	is the buffer to fill.
aMinRefId	is the minimum ID value to store. All values < aMinRefId are ignored.

Definition at line 202 of file component_references_lister.cpp.

{
 aIdList.clear();
 
 for( const SCH_REFERENCE& ref : flatList )
 {
 // Don't add new references to the list as we will reannotate those
 if( flatList[aIndex].CompareRef( ref ) == 0 && ref.m_numRef >= aMinRefId && !ref.m_isNew )
 aIdList.push_back( ref.m_numRef );
 }
 
 std::sort( aIdList.begin(), aIdList.end() );
 
 // Ensure each reference number appears only once. If there are symbols with
 // multiple parts per package the same number will be stored for each part.
 alg::remove_duplicates( aIdList );
}

References flatList, and alg::remove_duplicates().

Referenced by Annotate().

GetSymbolInstances()

std::vector< SYMBOL_INSTANCE_REFERENCE > SCH_REFERENCE_LIST::GetSymbolInstances

(

)

const

Definition at line 309 of file component_references_lister.cpp.

{
 std::vector<SYMBOL_INSTANCE_REFERENCE> retval;
 
 for( const SCH_REFERENCE& ref : flatList )
 {
 SYMBOL_INSTANCE_REFERENCE instance;
 instance.m_Path = ref.GetSheetPath().Path();
 instance.m_Reference = ref.GetRef();
 instance.m_Unit = ref.GetUnit();
 instance.m_Value = ref.GetValue();
 instance.m_Footprint = ref.GetFootprint();
 
 retval.push_back( instance );
 }
 
 return retval;
}

References flatList, SYMBOL_INSTANCE_REFERENCE::m_Footprint, SYMBOL_INSTANCE_REFERENCE::m_Path, SYMBOL_INSTANCE_REFERENCE::m_Reference, SYMBOL_INSTANCE_REFERENCE::m_Unit, and SYMBOL_INSTANCE_REFERENCE::m_Value.

Referenced by SCH_SEXPR_PLUGIN::Format().

GetUnitsMatchingRef()

std::vector< int > SCH_REFERENCE_LIST::GetUnitsMatchingRef

(

const SCH_REFERENCE &

aRef

)

const

Return all the unit numbers for a given reference, comparing library reference, value, reference number and reference prefix.

Parameters

aRef	is the index of a symbol to use for reference prefix and number filtering.

Definition at line 222 of file component_references_lister.cpp.

{
 std::vector<int> unitsList;
 
 // Always add this reference to the list
 unitsList.push_back( aRef.m_unit );
 
 for( SCH_REFERENCE ref : flatList )
 {
 if( ref.CompareValue( aRef ) != 0 )
 continue;
 
 if( ref.CompareLibName( aRef ) != 0 )
 continue;
 
 // Split if needed before comparing ref and number
 if( ref.IsSplitNeeded() )
 ref.Split();
 
 if( ref.CompareRef( aRef ) != 0 )
 continue;
 
 if( ref.m_numRef != aRef.m_numRef )
 continue;
 
 unitsList.push_back( ref.m_unit );
 }
 
 std::sort( unitsList.begin(), unitsList.end() );
 
 // Ensure each reference number appears only once. If there are symbols with
 // multiple parts per package the same number will be stored for each part.
 alg::remove_duplicates( unitsList );
 
 return unitsList;
}

References flatList, SCH_REFERENCE::m_numRef, SCH_REFERENCE::m_unit, and alg::remove_duplicates().

Referenced by Annotate().

operator[]() [1/2]

SCH_REFERENCE & SCH_REFERENCE_LIST::operator[] ( int  aIndex )

inline

Definition at line 252 of file sch_reference_list.h.

 {
 return flatList[ aIndex ];
 }

References flatList.

operator[]() [2/2]

const SCH_REFERENCE & SCH_REFERENCE_LIST::operator[] ( int  aIndex ) const

inline

Definition at line 257 of file sch_reference_list.h.

 {
 return flatList[ aIndex ];
 }

References flatList.

ReannotateByOptions()

void SCH_REFERENCE_LIST::ReannotateByOptions	(	ANNOTATE_ORDER_T	aSortOption,
		ANNOTATE_ALGO_T	aAlgoOption,
		int	aStartNumber,
		const SCH_REFERENCE_LIST &	aAdditionalRefs,
		bool	aStartAtCurrent,
		SCH_SHEET_LIST *	aHierarchy
	)

Forces reannotation of the provided references.

Will also reannotate associated multi-unit symbols.

Parameters

aSortOption	Define the annotation order. See ANNOTATE_ORDER_T.
aAlgoOption	Define the annotation style. See ANNOTATE_ALGO_T.
aStartNumber	The start number for non-sheet-based annotation styles.
aAdditionalReferences	Additional references to check for duplicates
aStartAtCurrent	Use m_numRef for each reference as the start number (overrides aStartNumber)
aHierarchy	Optional sheet path hierarchy for resetting the references' sheet numbers based on their sheet's place in the hierarchy. Set nullptr if not desired.

Definition at line 379 of file component_references_lister.cpp.

{
 SplitReferences();
 
 // All multi-unit symbols always locked to ensure consistent re-annotation
 SCH_MULTI_UNIT_REFERENCE_MAP lockedSymbols;
 
 for( size_t i = 0; i < GetCount(); i++ )
 {
 SCH_REFERENCE& ref = flatList[i];
 wxString refstr = ref.GetSymbol()->GetRef( &ref.GetSheetPath() );
 
 // Update sheet numbers based on the reference's sheet's position within the full
 // hierarchy; we do this now before we annotate so annotation by sheet number * X
 // works correctly.
 if( aHierarchy )
 {
 SCH_SHEET_PATH* path = aHierarchy->FindSheetForPath( &ref.GetSheetPath() );
 wxASSERT_MSG( path, wxT( "Attempting to annotate item on sheet not part of the hierarchy?" ) );
 
 ref.SetSheetNumber( path->GetVirtualPageNumber() );
 }
 
 // Never lock unassigned references
 if( refstr[refstr.Len() - 1] == '?' )
 continue;
 
 ref.m_isNew = true; // We want to reannotate all references
 
 lockedSymbols[refstr].AddItem( ref );
 }
 
 AnnotateByOptions( aSortOption, aAlgoOption, aStartNumber, lockedSymbols, aAdditionalRefs,
 aStartAtCurrent );
}

References AnnotateByOptions(), SCH_SHEET_LIST::FindSheetForPath(), flatList, GetCount(), SCH_SYMBOL::GetRef(), SCH_REFERENCE::GetSheetPath(), SCH_REFERENCE::GetSymbol(), SCH_REFERENCE::m_isNew, path, SCH_REFERENCE::SetSheetNumber(), and SplitReferences().

Referenced by SCH_DRAWING_TOOLS::PlaceSymbol(), and ReannotateDuplicates().

ReannotateDuplicates()

void SCH_REFERENCE_LIST::ReannotateDuplicates

(

const SCH_REFERENCE_LIST &

aAdditionalReferences

)

Convenience function for the Paste Unique functionality.

Do not use as a general reannotation method.

Replaces any duplicate reference designators with the next available number after the present number regardless of configured annotation options.

Multi-unit symbols are reannotated together.

Definition at line 421 of file component_references_lister.cpp.

{
 ReannotateByOptions( UNSORTED, INCREMENTAL_BY_REF, 0, aAdditionalReferences, true, nullptr );
}

References INCREMENTAL_BY_REF, ReannotateByOptions(), and UNSORTED.

RemoveAnnotation()

void SCH_REFERENCE_LIST::RemoveAnnotation ( bool  aIncludePowerSymbols )

inline

Treat all symbols in this list as non-annotated.

Does not update annotation state of the symbols.

See also

SCH_REFERENCE_LIST::UpdateAnnotation

Definition at line 315 of file sch_reference_list.h.

 {
 for( unsigned ii = 0; ii < GetCount(); ii++ )
 {
 if( !flatList[ii].m_libPart->IsPower() || aIncludePowerSymbols )
 flatList[ii].m_isNew = true;
 }
 }

References flatList, and GetCount().

Referenced by SCH_EDIT_FRAME::AnnotateSymbols().

RemoveItem()

void SCH_REFERENCE_LIST::RemoveItem

(

unsigned int

aIndex

)

Remove an item from the list of references.

Parameters

aIndex

is the index of the item to be removed.

Definition at line 45 of file component_references_lister.cpp.

{
 if( aIndex < flatList.size() )
 flatList.erase( flatList.begin() + aIndex );
}

References flatList.

Referenced by Annotate().

Shorthand()

wxString SCH_REFERENCE_LIST::Shorthand ( std::vector< SCH_REFERENCE >  aList )

static

Return a shorthand string representing all the references in the list.

For instance, "R1, R2, R4 - R7, U1"

Definition at line 919 of file component_references_lister.cpp.

{
 wxString retVal;
 size_t i = 0;
 
 while( i < aList.size() )
 {
 wxString ref = aList[ i ].GetRef();
 int numRef = aList[ i ].m_numRef;
 
 size_t range = 1;
 
 while( i + range < aList.size()
 && aList[ i + range ].GetRef() == ref
 && aList[ i + range ].m_numRef == int( numRef + range ) )
 {
 range++;
 }
 
 if( !retVal.IsEmpty() )
 retVal << wxT( ", " );
 
 if( range == 1 )
 {
 retVal << ref << aList[ i ].GetRefNumber();
 }
 else if( range == 2 )
 {
 retVal << ref << aList[ i ].GetRefNumber();
 retVal << wxT( ", " );
 retVal << ref << aList[ i + 1 ].GetRefNumber();
 }
 else
 {
 retVal << ref << aList[ i ].GetRefNumber();
 retVal << wxT( "-" );
 retVal << ref << aList[ i + ( range - 1 ) ].GetRefNumber();
 }
 
 i+= range;
 }
 
 return retVal;
}

Referenced by FIELDS_EDITOR_GRID_DATA_MODEL::GetValue().

SortByRefAndValue()

void SCH_REFERENCE_LIST::SortByRefAndValue ( )

inline

Sort the list of references by value.

Symbols are sorted in the following order:

• Numeric value of reference designator.
• Value of symbol.
• Unit number when symbol has multiple parts.
• Sheet number.
• X coordinate position.
• Y coordinate position.

Definition at line 483 of file sch_reference_list.h.

 {
 sort( flatList.begin(), flatList.end(), sortByRefAndValue );
 }

References flatList, and sortByRefAndValue().

Referenced by CheckAnnotation().

sortByRefAndValue()

bool SCH_REFERENCE_LIST::sortByRefAndValue ( const SCH_REFERENCE &  item1, const SCH_REFERENCE &  item2  )

staticprivate

Definition at line 104 of file component_references_lister.cpp.

{
 int ii = item1.CompareRef( item2 );
 
 if( ii == 0 )
 ii = item1.CompareValue( item2 );
 
 if( ii == 0 )
 ii = item1.m_unit - item2.m_unit;
 
 if( ii == 0 )
 ii = item1.m_sheetNum - item2.m_sheetNum;
 
 if( ii == 0 )
 ii = item1.m_symbolPos.x - item2.m_symbolPos.x;
 
 if( ii == 0 )
 ii = item1.m_symbolPos.y - item2.m_symbolPos.y;
 
 if( ii == 0 )
 return item1.m_symbolUuid < item2.m_symbolUuid; // ensure a deterministic sort
 else
 return ii < 0;
}

References SCH_REFERENCE::CompareRef(), SCH_REFERENCE::CompareValue(), SCH_REFERENCE::m_sheetNum, SCH_REFERENCE::m_symbolPos, SCH_REFERENCE::m_symbolUuid, SCH_REFERENCE::m_unit, VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by SortByRefAndValue().

SortByReferenceOnly()

void SCH_REFERENCE_LIST::SortByReferenceOnly ( )

inline

Sort the list of references by reference.

Symbols are sorted in the following order:

• Numeric value of reference designator.
• Unit number when symbol has multiple parts.

Definition at line 495 of file sch_reference_list.h.

 {
 sort( flatList.begin(), flatList.end(), sortByReferenceOnly );
 }

References flatList, and sortByReferenceOnly().

Referenced by SCH_SEXPR_PLUGIN::Format(), SCH_EDITOR_CONTROL::Paste(), and SCH_DRAWING_TOOLS::PlaceSymbol().

sortByReferenceOnly()

bool SCH_REFERENCE_LIST::sortByReferenceOnly ( const SCH_REFERENCE &  item1, const SCH_REFERENCE &  item2  )

staticprivate

Definition at line 131 of file component_references_lister.cpp.

{
 int ii = StrNumCmp( item1.GetRef(), item2.GetRef(), false );
 
 if( ii == 0 )
 ii = item1.m_unit - item2.m_unit;
 
 if( ii == 0 )
 return item1.m_symbolUuid < item2.m_symbolUuid; // ensure a deterministic sort
 else
 return ii < 0;
}

References SCH_REFERENCE::GetRef(), SCH_REFERENCE::m_symbolUuid, SCH_REFERENCE::m_unit, and StrNumCmp().

Referenced by SortByReferenceOnly().

SortByTimeStamp()

void SCH_REFERENCE_LIST::SortByTimeStamp ( )

inline

Sort the flat list by Time Stamp (sheet path + timestamp).

Useful to detect duplicate Time Stamps

Definition at line 467 of file sch_reference_list.h.

 {
 sort( flatList.begin(), flatList.end(), sortByTimeStamp );
 }

References flatList, and sortByTimeStamp().

Referenced by BACK_ANNOTATE::checkForUnusedSymbols().

sortByTimeStamp()

bool SCH_REFERENCE_LIST::sortByTimeStamp ( const SCH_REFERENCE &  item1, const SCH_REFERENCE &  item2  )

staticprivate

Definition at line 146 of file component_references_lister.cpp.

{
 int ii = item1.m_sheetPath.Cmp( item2.m_sheetPath );
 
 if( ii == 0 )
 return item1.m_symbolUuid < item2.m_symbolUuid; // ensure a deterministic sort
 else
 return ii < 0;
}

References SCH_SHEET_PATH::Cmp(), SCH_REFERENCE::m_sheetPath, and SCH_REFERENCE::m_symbolUuid.

Referenced by SortByTimeStamp().

SortByXCoordinate()

void SCH_REFERENCE_LIST::SortByXCoordinate ( )

inline

Sort the list of references by X position.

Symbols are sorted as follows:

• Numeric value of reference designator.
• Sheet number.
• X coordinate position.
• Y coordinate position.
• Time stamp.

Definition at line 442 of file sch_reference_list.h.

 {
 sort( flatList.begin(), flatList.end(), sortByXPosition );
 }

References flatList, and sortByXPosition().

Referenced by AnnotateByOptions().

sortByXPosition()

bool SCH_REFERENCE_LIST::sortByXPosition ( const SCH_REFERENCE &  item1, const SCH_REFERENCE &  item2  )

staticprivate

Definition at line 64 of file component_references_lister.cpp.

{
 int ii = item1.CompareRef( item2 );
 
 if( ii == 0 )
 ii = item1.m_sheetNum - item2.m_sheetNum;
 
 if( ii == 0 )
 ii = item1.m_symbolPos.x - item2.m_symbolPos.x;
 
 if( ii == 0 )
 ii = item1.m_symbolPos.y - item2.m_symbolPos.y;
 
 if( ii == 0 )
 return item1.m_symbolUuid < item2.m_symbolUuid; // ensure a deterministic sort
 else
 return ii < 0;
}

References SCH_REFERENCE::CompareRef(), SCH_REFERENCE::m_sheetNum, SCH_REFERENCE::m_symbolPos, SCH_REFERENCE::m_symbolUuid, VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by SortByXCoordinate().

SortByYCoordinate()

void SCH_REFERENCE_LIST::SortByYCoordinate ( )

inline

Sort the list of references by Y position.

Symbols are sorted as follows:

• Numeric value of reference designator.
• Sheet number.
• Y coordinate position.
• X coordinate position.
• Time stamp.

Definition at line 457 of file sch_reference_list.h.

 {
 sort( flatList.begin(), flatList.end(), sortByYPosition );
 }

References flatList, and sortByYPosition().

Referenced by AnnotateByOptions().

sortByYPosition()

bool SCH_REFERENCE_LIST::sortByYPosition ( const SCH_REFERENCE &  item1, const SCH_REFERENCE &  item2  )

staticprivate

Definition at line 84 of file component_references_lister.cpp.

{
 int ii = item1.CompareRef( item2 );
 
 if( ii == 0 )
 ii = item1.m_sheetNum - item2.m_sheetNum;
 
 if( ii == 0 )
 ii = item1.m_symbolPos.y - item2.m_symbolPos.y;
 
 if( ii == 0 )
 ii = item1.m_symbolPos.x - item2.m_symbolPos.x;
 
 if( ii == 0 )
 return item1.m_symbolUuid < item2.m_symbolUuid; // ensure a deterministic sort
 else
 return ii < 0;
}

References SCH_REFERENCE::CompareRef(), SCH_REFERENCE::m_sheetNum, SCH_REFERENCE::m_symbolPos, SCH_REFERENCE::m_symbolUuid, VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by SortByYCoordinate().

SplitReferences()

void SCH_REFERENCE_LIST::SplitReferences ( )

inline

Attempt to split all reference designators into a name (U) and number (1).

If the last character is '?' or not a digit, the reference is tagged as not annotated. For symbols with multiple parts, keeps the unit number intact

See also

SCH_REFERENCE::Split()

Definition at line 304 of file sch_reference_list.h.

 {
 for( unsigned ii = 0; ii < GetCount(); ii++ )
 flatList[ii].Split();
 }

References flatList, and GetCount().

Referenced by SCH_SHEET_LIST::AnnotatePowerSymbols(), SCH_EDIT_FRAME::AnnotateSymbols(), CheckAnnotation(), FIELDS_EDITOR_GRID_DATA_MODEL::FIELDS_EDITOR_GRID_DATA_MODEL(), and ReannotateByOptions().

UpdateAnnotation()

void SCH_REFERENCE_LIST::UpdateAnnotation ( )

inline

Update the symbol references for the schematic project (or the current sheet).

Note

This function does not calculate the reference numbers stored in m_numRef so it must be called after calculation of new reference numbers.

See also

SCH_REFERENCE::Annotate()

Definition at line 332 of file sch_reference_list.h.

 {
 /* update the reference numbers */
 for( unsigned ii = 0; ii < GetCount(); ii++ )
 flatList[ii].Annotate();
 }

References Annotate(), flatList, and GetCount().

Referenced by SCH_SHEET_LIST::AnnotatePowerSymbols(), and SCH_DRAWING_TOOLS::PlaceSymbol().

Friends And Related Function Documentation

BACK_ANNOTATE

friend class BACK_ANNOTATE

friend

Definition at line 607 of file sch_reference_list.h.

BACK_ANNOTATION

friend class BACK_ANNOTATION

friend

Definition at line 579 of file sch_reference_list.h.

Member Data Documentation

flatList

std::vector<SCH_REFERENCE> SCH_REFERENCE_LIST::flatList

private

Definition at line 245 of file sch_reference_list.h.

Referenced by AddItem(), Annotate(), CheckAnnotation(), Clear(), Contains(), FindFirstUnusedReference(), FindRef(), FindRefByPath(), FindUnit(), GetCount(), GetItem(), GetRefsInUse(), GetSymbolInstances(), GetUnitsMatchingRef(), operator[](), ReannotateByOptions(), RemoveAnnotation(), RemoveItem(), SortByRefAndValue(), SortByReferenceOnly(), SortByTimeStamp(), SortByXCoordinate(), SortByYCoordinate(), SplitReferences(), and UpdateAnnotation().

---

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

• sch_reference_list.h
• component_references_lister.cpp