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)
void	Clear ()
unsigned	GetCount () const
SCH_REFERENCE &	GetItem (int aIdx)
void	AddItem (SCH_REFERENCE &aItem)
void	RemoveItem (unsigned int aIndex)
	Remove an item from the list of references. 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	Annotate (bool aUseSheetNum, int aSheetIntervalId, int aStartNumber, SCH_MULTI_UNIT_REFERENCE_MAP aLockedUnitMap)
	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)
	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)
	Add all the reference designator numbers greater than aMinRefId to aIdList skipping the reference at aIndex. More...
int	GetLastReference (int aIndex, int aMinValue)
	Return the last used (greatest) reference number in the reference list for the prefix used by the symbol pointed to by aIndex. More...

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

Constructor & Destructor Documentation

SCH_REFERENCE_LIST()

SCH_REFERENCE_LIST::SCH_REFERENCE_LIST ( )

inline

Definition at line 203 of file sch_reference_list.h.

    {
    }

Member Function Documentation

AddItem()

void SCH_REFERENCE_LIST::AddItem ( SCH_REFERENCE &  aItem )

inline

Definition at line 221 of file sch_reference_list.h.

{ flatList.push_back( aItem ); }

References flatList.

Referenced by SCH_SHEET_LIST::AnnotatePowerSymbols(), and SCH_SHEET_PATH::GetSymbols().

Annotate()

void SCH_REFERENCE_LIST::Annotate	(	bool	aUseSheetNum,
		int	aSheetIntervalId,
		int	aStartNumber,
		SCH_MULTI_UNIT_REFERENCE_MAP	aLockedUnitMap
	)

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

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.

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

Definition at line 282 of file component_references_lister.cpp.

{
    if ( flatList.size() == 0 )
        return;

    int LastReferenceNumber = 0;
    int NumberOfUnits, Unit;

    /* calculate index of the first component with the same reference prefix
     * than the current component.  All components 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 multi units components, when "keep order of multi unit" option is selected,
    // store the list of already used full references.
    // The algorithm try to allocate the new reference to components 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 anotation 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;

    // 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 component is in aLockedUnitMap.
        SCH_REFERENCE_LIST* lockedList = NULL;
        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 != NULL ) 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 );
        }

        // Annotation of one part per package components (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_unit  = 1;
            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;

            if( !ref_unit.IsUnitsLocked() )
                ref_unit.m_unit = 1;

            ref_unit.m_flag = 1;
        }

        // If this component is in aLockedUnitMap, copy the annotation to all
        // components that are not it
        if( lockedList != NULL )
        {
            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 component 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 component
                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" component,
                    // if this new full reference is not already used (can happens when initial
                    // multiunits components have duplicate references)
                    if( inUseRefs.find( ref_candidate ) == inUseRefs.end() )
                    {
                        flatList[jj].m_numRef = ref_unit.m_numRef;
                        flatList[jj].m_unit = thisRef.m_unit;
                        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 component.
            * 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 component 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;

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

References buildFullReference(), SCH_REFERENCE::CompareLibName(), SCH_REFERENCE::CompareValue(), CreateFirstFreeRefId(), FindUnit(), flatList, GetCount(), GetRefsInUse(), SCH_REFERENCE::IsSameInstance(), SCH_REFERENCE::m_unit, and NULL.

Referenced by SCH_EDIT_FRAME::AnnotateComponents(), SCH_SHEET_LIST::AnnotatePowerSymbols(), 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 498 of file component_references_lister.cpp.

{
    int            error = 0;
    wxString       tmp;
    wxString       msg;

    SortByRefAndValue();

    // Spiit 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 component).  This can happen if a component 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_PART::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_PART::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_PART::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_PART::SubReference( flatList[ii].m_unit ),
                        flatList[ii].m_value,
                        flatList[next].GetRef(),
                        flatList[next].m_numRef,
                        LIB_PART::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_PART::SubReference().

Referenced by SCH_EDIT_FRAME::CheckAnnotate().

Clear()

void SCH_REFERENCE_LIST::Clear ( )

inline

Definition at line 212 of file sch_reference_list.h.

    {
        flatList.clear();
    }

References flatList.

Referenced by SCH_EDITOR_CONTROL::doCopy().

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 232 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 179 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

path to search

Returns

index in aSymbolsList if found or -1 if not found

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

FindUnit()

int SCH_REFERENCE_LIST::FindUnit	(	size_t	aIndex,
		int	aUnit
	)

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	= index in aSymbolsList for of given SCH_REFERENCE item to test.
aUnit	= the given unit number to search

Returns

index in aSymbolsList if found or -1 if not found

Definition at line 145 of file component_references_lister.cpp.

{
    int NumRef;

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

unsigned SCH_REFERENCE_LIST::GetCount ( ) const

inline

Definition at line 217 of file sch_reference_list.h.

{ return flatList.size(); }

References flatList.

Referenced by FIELDS_EDITOR_GRID_DATA_MODEL::AddColumn(), Annotate(), SCH_EDIT_FRAME::AnnotateComponents(), SCH_SHEET_LIST::AnnotatePowerSymbols(), FIELDS_EDITOR_GRID_DATA_MODEL::ApplyData(), SCH_EDITOR_CONTROL::AssignFootprints(), SCH_EDIT_FRAME::CheckAnnotate(), BACK_ANNOTATE::checkForUnusedSymbols(), CollectOtherUnits(), SCHEMATIC::ConvertRefsToKIIDs(), SCH_SEXPR_PLUGIN::Format(), BACK_ANNOTATE::getChangeList(), FIELDS_EDITOR_GRID_DATA_MODEL::GetDataWidth(), DIALOG_EDIT_COMPONENTS_LIBID::initDlg(), DIALOG_FIELDS_EDITOR_GLOBAL::LoadFieldNames(), SCH_EDIT_FRAME::mapExistingAnnotation(), DIALOG_LABEL_EDITOR::onScintillaCharAdded(), DIALOG_SCH_EDIT_ONE_FIELD::onScintillaCharAdded(), SCH_EDITOR_CONTROL::processCmpToFootprintLinkFile(), FIELDS_EDITOR_GRID_DATA_MODEL::RebuildRows(), SplitReferences(), ERC_TESTER::TestMultiunitFootprints(), UpdateAnnotation(), and SCH_SHEET_LIST::UpdateSymbolInstances().

GetItem()

SCH_REFERENCE& SCH_REFERENCE_LIST::GetItem ( int  aIdx )

inline

Definition at line 219 of file sch_reference_list.h.

{ return flatList[aIdx]; }

References flatList.

Referenced by ERC_TESTER::TestMultiunitFootprints().

GetLastReference()

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

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 213 of file component_references_lister.cpp.

{
    int lastNumber = aMinValue;

    for( 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
	)

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

Parameters

aIndex	= the current symbol's index to use for reference prefix filtering.
aIdList	= the buffer to fill
aMinRefId	= the min id value to store. all values < aMinRefId are ignored

Definition at line 191 of file component_references_lister.cpp.

{
    aIdList.clear();

    for( SCH_REFERENCE& ref : flatList )
    {
        if( flatList[aIndex].CompareRef( ref ) == 0 && ref.m_numRef >= aMinRefId )
            aIdList.push_back( ref.m_numRef );
    }

    sort( aIdList.begin(), aIdList.end() );

    // Ensure each reference number appears only once.  If there are components 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().

operator[]()

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

inline

Definition at line 207 of file sch_reference_list.h.

    {
        return flatList[ aIndex ];
    }

References flatList.

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.

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 756 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 363 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 91 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 378 of file sch_reference_list.h.

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

References flatList, and sortByReferenceOnly().

Referenced by SCH_SEXPR_PLUGIN::Format().

sortByReferenceOnly()

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

staticprivate

Definition at line 118 of file component_references_lister.cpp.

{
    int ii = UTIL::RefDesStringCompare( item1.GetRef(), item2.GetRef() );

    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 UTIL::RefDesStringCompare().

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 344 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 133 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 316 of file sch_reference_list.h.

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

References flatList, and sortByXPosition().

Referenced by SCH_EDIT_FRAME::AnnotateComponents().

sortByXPosition()

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

staticprivate

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

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

References flatList, and sortByYPosition().

Referenced by SCH_EDIT_FRAME::AnnotateComponents().

sortByYPosition()

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

staticprivate

Definition at line 71 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 per package that are not already annotated, set m_unit to a max value (0x7FFFFFFF).

See also

SCH_REFERENCE::Split()

Definition at line 246 of file sch_reference_list.h.

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

References flatList, and GetCount().

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

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

BACK_ANNOTATION

friend class BACK_ANNOTATION

friend

Definition at line 449 of file sch_reference_list.h.

Member Data Documentation

flatList

std::vector<SCH_REFERENCE> SCH_REFERENCE_LIST::flatList

private

Definition at line 200 of file sch_reference_list.h.

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