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)
	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	UpdateAnnotation ()
	Update the symbol references for the schematic project (or the current sheet). More...
void	ReannotateDuplicates (const SCH_REFERENCE_LIST &aAdditionalReferences)
	Replace any duplicate reference designators with the next available number after the present number. 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) 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...
int	GetLastReference (int aIndex, int aMinValue) const
	Return the last used (greatest) reference number in the reference list for the prefix used by the symbol pointed to by aIndex. 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...

Private Member Functions
int	CreateFirstFreeRefId (std::vector< int > &aIdList, int aFirstValue)
	Search for the first free reference number in aListId of reference numbers in use. 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)

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 203 of file sch_reference_list.h.

Constructor & Destructor Documentation

SCH_REFERENCE_LIST()

SCH_REFERENCE_LIST::SCH_REFERENCE_LIST ( )

inline

Definition at line 210 of file sch_reference_list.h.

    {
    }

Member Function Documentation

AddItem()

void SCH_REFERENCE_LIST::AddItem ( const SCH_REFERENCE &  aItem )

inline

Definition at line 234 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(), and SCH_EDITOR_CONTROL::Paste().

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 339 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;
    int NumberOfUnits, Unit;

    /* 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;

    // This is the list of all Id already in use for a given reference prefix.
    // Will be refilled for each new reference prefix.
    std::vector<int>idList;
    GetRefsInUse( first, idList, minRefId );

    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;

            GetRefsInUse( first, idList, minRefId );
        }

        // Find references greater than current reference (unless not annotated)
        if( aStartAtCurrent && ref_unit.m_numRef > 0 )
        {
            minRefId = ref_unit.m_numRef;
            GetRefsInUse( first, idList, minRefId );
        }

        // Annotation of one part per package symbols (trivial case).
        if( ref_unit.GetLibPart()->GetUnitCount() <= 1 )
        {
            if( ref_unit.m_isNew )
            {
                LastReferenceNumber = CreateFirstFreeRefId( idList, minRefId );
                ref_unit.m_numRef = LastReferenceNumber;
            }

            ref_unit.m_flag  = 1;
            ref_unit.m_isNew = false;
            continue;
        }

        // Annotation of multi-unit parts ( n units per part ) (complex case)
        NumberOfUnits = ref_unit.GetLibPart()->GetUnitCount();

        if( ref_unit.m_isNew )
        {
            LastReferenceNumber = CreateFirstFreeRefId( idList, minRefId );
            ref_unit.m_numRef = LastReferenceNumber;

            ref_unit.m_flag = 1;
        }

        // If this symbol is in aLockedUnitMap, copy the annotation to all
        // symbols that are not it
        if( lockedList != nullptr )
        {
            unsigned n_refs = lockedList->GetCount();

            for( unsigned thisRefI = 0; thisRefI < n_refs; ++thisRefI )
            {
                SCH_REFERENCE &thisRef = (*lockedList)[thisRefI];

                if( thisRef.IsSameInstance( ref_unit ) )
                {
                    // This is the symbol we're currently annotating. Hold the unit!
                    ref_unit.m_unit = thisRef.m_unit;
                    // lock this new full reference
                    inUseRefs.insert( buildFullReference( ref_unit ) );
                }

                if( thisRef.CompareValue( ref_unit ) != 0 )
                    continue;

                if( thisRef.CompareLibName( ref_unit ) != 0 )
                    continue;

                // Find the matching symbol
                for( unsigned jj = ii + 1; jj < flatList.size(); jj++ )
                {
                    if( ! thisRef.IsSameInstance( flatList[jj] ) )
                        continue;

                    wxString ref_candidate = buildFullReference( ref_unit, thisRef.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
        {
            /* search for others units of this symbol.
            * we search for others parts that have the same value and the same
            * reference prefix (ref without ref number)
            */
            for( Unit = 1; Unit <= NumberOfUnits; Unit++ )
            {
                if( ref_unit.m_unit == Unit )
                    continue;

                int found = FindUnit( ii, Unit );

                if( found >= 0 )
                    continue; // this unit exists for this reference (unit already annotated)

                // Search a symbol to annotate ( same prefix, same value, not annotated)
                for( unsigned jj = ii + 1; jj < flatList.size(); jj++ )
                {
                    auto& cmp_unit = flatList[jj];

                    if( cmp_unit.m_flag )    // already tested
                        continue;

                    if( cmp_unit.CompareRef( ref_unit ) != 0 )
                        continue;

                    if( cmp_unit.CompareValue( ref_unit ) != 0 )
                        continue;

                    if( cmp_unit.CompareLibName( ref_unit ) != 0 )
                        continue;

                    if( aUseSheetNum &&
                            cmp_unit.GetSheetPath().Cmp( ref_unit.GetSheetPath() ) != 0 )
                        continue;

                    if( !cmp_unit.m_isNew )
                        continue;

                    // Symbol without reference number found, annotate it if possible.
                    if( cmp_unit.m_unit == Unit )
                    {
                        cmp_unit.m_numRef = ref_unit.m_numRef;
                        cmp_unit.m_flag   = 1;
                        cmp_unit.m_isNew  = false;
                        break;
                    }
                }
            }
        }
    }

    // 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(), FindUnit(), flatList, GetCount(), GetRefsInUse(), SCH_REFERENCE::IsSameInstance(), SCH_REFERENCE::m_isNew, SCH_REFERENCE::m_unit, RemoveItem(), and SCH_REFERENCE::Split().

Referenced by SCH_SHEET_LIST::AnnotatePowerSymbols(), SCH_EDIT_FRAME::AnnotateSymbols(), ReannotateDuplicates(), and UpdateAnnotation().

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 582 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)\n" ),
                            flatList[ii].GetRef(),
                            tmp,
                            flatList[ii].m_unit );
            }
            else
            {
                msg.Printf( _( "Item not annotated: %s%s\n" ), 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)\n" ),
                        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].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 224 of file sch_reference_list.h.

    {
        flatList.clear();
    }

References flatList.

Contains()

bool SCH_REFERENCE_LIST::Contains

(

const SCH_REFERENCE &

aItem

)

Return true if aItem exists in this list.

Parameters

aItem

Reference to check

Returns

true if aItem exists in this list

Definition at line 51 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().

CreateFirstFreeRefId()

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

private

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 264 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().

FindRef()

int SCH_REFERENCE_LIST::FindRef

(

const wxString &

aPath

)

const

Search the list for a symbol with a given reference.

Definition at line 189 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 177 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
	)		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.

Returns

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

Definition at line 157 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 )
          || ( 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.

Referenced by Annotate().

GetCount()

size_t SCH_REFERENCE_LIST::GetCount ( ) const

inline

Definition at line 229 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(), BACK_ANNOTATE::getChangeList(), FIELDS_EDITOR_GRID_DATA_MODEL::GetDataWidth(), DIALOG_EDIT_SYMBOLS_LIBID::initDlg(), DIALOG_SYMBOL_FIELDS_TABLE::LoadFieldNames(), SCH_EDIT_FRAME::mapExistingAnnotation(), DIALOG_TEXT_AND_LABEL_PROPERTIES::onScintillaCharAdded(), DIALOG_SCH_FIELD_PROPERTIES::onScintillaCharAdded(), SCH_EDITOR_CONTROL::processCmpToFootprintLinkFile(), ReannotateDuplicates(), FIELDS_EDITOR_GRID_DATA_MODEL::RebuildRows(), SplitReferences(), ERC_TESTER::TestMultiunitFootprints(), UpdateAnnotation(), and SCH_SHEET_LIST::UpdateSymbolInstances().

GetItem() [1/2]

SCH_REFERENCE& SCH_REFERENCE_LIST::GetItem ( int  aIdx )

inline

Definition at line 231 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 232 of file sch_reference_list.h.

{ return flatList[aIdx]; }

References flatList.

GetLastReference()

int SCH_REFERENCE_LIST::GetLastReference	(	int	aIndex,
		int	aMinValue
	)		const

Return the last used (greatest) reference number in the reference list for the prefix used by the symbol pointed to by aIndex.

The symbol list must be sorted.

Parameters

aIndex	The index of the reference item used for the search pattern.
aMinValue	The minimum value for the current search.

Definition at line 225 of file component_references_lister.cpp.

{
    int lastNumber = aMinValue;

    for( const SCH_REFERENCE& ref : flatList )
    {
        // search only for the current reference prefix:
        if( flatList[aIndex].CompareRef( ref ) != 0 )
            continue;

        // update max value for the current reference prefix
        if( lastNumber < ref.m_numRef )
            lastNumber = ref.m_numRef;
    }

    return lastNumber;
}

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 201 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 );
    }

    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.
    std::vector< int >::iterator it = unique( aIdList.begin(), aIdList.end() );

    // Using the C++ unique algorithm only moves the duplicate entries to the end of
    // of the array.  This removes the duplicate entries from the array.
    aIdList.resize( it - aIdList.begin() );
}

References flatList.

Referenced by Annotate().

GetSymbolInstances()

std::vector< SYMBOL_INSTANCE_REFERENCE > SCH_REFERENCE_LIST::GetSymbolInstances

(

)

const

Definition at line 244 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.GetPath();
        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().

operator[]() [1/2]

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

inline

Definition at line 214 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 219 of file sch_reference_list.h.

    {
        return flatList[ aIndex ];
    }

References flatList.

ReannotateDuplicates()

void SCH_REFERENCE_LIST::ReannotateDuplicates

(

const SCH_REFERENCE_LIST &

aAdditionalReferences

)

Replace any duplicate reference designators with the next available number after the present number.

Multi-unit symbols are reannotated together.

Parameters

aAdditionalReferences

Additional references to check for duplicates

Definition at line 314 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() );

        // Never lock unassigned references
        if( refstr[refstr.Len() - 1] == '?' )
            continue;

        lockedSymbols[refstr].AddItem( ref );

        ref.m_isNew = true; // We want to reannotate all references
    }

    Annotate( false, 0, 0, lockedSymbols, aAdditionalReferences, true );
}

References Annotate(), flatList, GetCount(), SCH_SYMBOL::GetRef(), SCH_REFERENCE::GetSheetPath(), SCH_REFERENCE::GetSymbol(), SCH_REFERENCE::m_isNew, and SplitReferences().

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 44 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 827 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 385 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 103 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, and SCH_REFERENCE::m_unit.

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 397 of file sch_reference_list.h.

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

References flatList, and sortByReferenceOnly().

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

sortByReferenceOnly()

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

staticprivate

Definition at line 130 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 369 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 145 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 BACK_ANNOTATE::checkForUnusedSymbols(), and 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 344 of file sch_reference_list.h.

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

References flatList, and sortByXPosition().

Referenced by SCH_EDIT_FRAME::AnnotateSymbols().

sortByXPosition()

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

staticprivate

Definition at line 63 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, and SCH_REFERENCE::m_symbolUuid.

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 359 of file sch_reference_list.h.

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

References flatList, and sortByYPosition().

Referenced by SCH_EDIT_FRAME::AnnotateSymbols().

sortByYPosition()

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

staticprivate

Definition at line 83 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, and SCH_REFERENCE::m_symbolUuid.

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 266 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 ReannotateDuplicates().

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 280 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().

Friends And Related Function Documentation

BACK_ANNOTATE

friend class BACK_ANNOTATE

friend

Definition at line 498 of file sch_reference_list.h.

BACK_ANNOTATION

friend class BACK_ANNOTATION

friend

Definition at line 470 of file sch_reference_list.h.

Member Data Documentation

flatList

std::vector<SCH_REFERENCE> SCH_REFERENCE_LIST::flatList

private

Definition at line 207 of file sch_reference_list.h.

Referenced by AddItem(), Annotate(), CheckAnnotation(), Clear(), Contains(), FindRef(), FindRefByPath(), FindUnit(), GetCount(), GetItem(), GetLastReference(), GetRefsInUse(), GetSymbolInstances(), operator[](), ReannotateDuplicates(), 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