SCH_SHEET_LIST Class Reference

A container for handling SCH_SHEET_PATH objects in a flattened hierarchy. More...

#include <sch_sheet_path.h>

Inheritance diagram for SCH_SHEET_LIST:

Public Member Functions
	SCH_SHEET_LIST (SCH_SHEET *aSheet=nullptr, bool aCheckIntegrity=false)
	Construct a flattened list of SCH_SHEET_PATH objects from aSheet. More...
	~SCH_SHEET_LIST ()
bool	IsModified ()
	Check the entire hierarchy for any modifications. More...
void	ClearModifyStatus ()
SCH_ITEM *	GetItem (const KIID &aID, SCH_SHEET_PATH *aPathOut=nullptr)
	Fetch a SCH_ITEM by ID. More...
void	FillItemMap (std::map< KIID, EDA_ITEM * > &aMap)
	Fill an item cache for temporary use when many items need to be fetched. More...
void	AnnotatePowerSymbols ()
	Silently annotate the not yet annotated power symbols of the entire hierarchy of the sheet path list. More...
void	GetSymbols (SCH_REFERENCE_LIST &aReferences, bool aIncludePowerSymbols=true, bool aForceIncludeOrphanComponents=false) const
	Add a SCH_REFERENCE object to aReferences for each component in the list of sheets. More...
void	GetMultiUnitSymbols (SCH_MULTI_UNIT_REFERENCE_MAP &aRefList, bool aIncludePowerSymbols=true) const
	Add a SCH_REFERENCE_LIST object to aRefList for each same-reference set of multi-unit parts in the list of sheets. More...
bool	TestForRecursion (const SCH_SHEET_LIST &aSrcSheetHierarchy, const wxString &aDestFileName)
	Test every SCH_SHEET_PATH in this SCH_SHEET_LIST to verify if adding the sheets stored in aSrcSheetHierarchy to the sheet stored in aDestFileName will cause recursion. More...
SCH_SHEET_PATH *	FindSheetForScreen (SCH_SCREEN *aScreen)
	Return a pointer to the first SCH_SHEET_PATH object (not necessarily the only one) using a particular screen. More...
void	BuildSheetList (SCH_SHEET *aSheet, bool aCheckIntegrity)
	Build the list of sheets and their sheet path from aSheet. More...
bool	NameExists (const wxString &aSheetName)
void	UpdateSymbolInstances (const std::vector< SYMBOL_INSTANCE_REFERENCE > &aSymbolInstances)
	Update all of the symbol instance information using aSymbolInstances. More...
void	UpdateSheetInstances (const std::vector< SCH_SHEET_INSTANCE > &aSheetInstances)
	Update all of the sheet instance information using aSheetInstances. More...
std::vector< KIID_PATH >	GetPaths () const
void	ReplaceLegacySheetPaths (const std::vector< KIID_PATH > &aOldSheetPaths)
	Update all of the symbol sheet paths to the sheet paths defined in aOldSheetPaths. More...
bool	AllSheetPageNumbersEmpty () const
	Check all of the sheet instance for empty page numbers. More...
void	SetInitialPageNumbers ()
	Set initial sheet page numbers. More...

Private Attributes
SCH_SHEET_PATH	m_currentSheetPath

Detailed Description

A container for handling SCH_SHEET_PATH objects in a flattened hierarchy.

SCH_SHEET objects are not unique, there can be many sheets with the same filename and that share the same SCH_SCREEN reference. Each The schematic file (SCH_SCREEN) may be shared between these sheets and component references are specific to a sheet path. When a sheet is entered, component references and sheet page number are updated.

Definition at line 348 of file sch_sheet_path.h.

Constructor & Destructor Documentation

SCH_SHEET_LIST()

SCH_SHEET_LIST::SCH_SHEET_LIST	(	SCH_SHEET *	aSheet = nullptr,
		bool	aCheckIntegrity = false
	)

Construct a flattened list of SCH_SHEET_PATH objects from aSheet.

If aSheet == NULL, then this is an empty hierarchy which the user can populate.

Definition at line 426 of file sch_sheet_path.cpp.

{
    if( aSheet != NULL )
        BuildSheetList( aSheet, aCheckIntegrity );
}

References BuildSheetList(), and NULL.

~SCH_SHEET_LIST()

SCH_SHEET_LIST::~SCH_SHEET_LIST ( )

inline

Definition at line 362 of file sch_sheet_path.h.

{}

Member Function Documentation

AllSheetPageNumbersEmpty()

bool SCH_SHEET_LIST::AllSheetPageNumbersEmpty

(

)

const

Check all of the sheet instance for empty page numbers.

Note

This should only return true when loading a legacy schematic or an s-expression schematic before version 20201005.

Returns

true if all sheet instance page numbers are not defined. Otherwise false.

Definition at line 839 of file sch_sheet_path.cpp.

{
    for( const SCH_SHEET_PATH& instance : *this )
    {
        const SCH_SHEET* sheet = instance.Last();

        wxCHECK2( sheet, continue );

        if( !sheet->GetPageNumber( instance ).IsEmpty() )
            return false;
    }

    return true;
}

References SCH_SHEET::GetPageNumber(), and SCH_SHEET_PATH::Last().

Referenced by BOOST_AUTO_TEST_CASE(), SCH_EDIT_FRAME::OpenProjectFiles(), and SetInitialPageNumbers().

AnnotatePowerSymbols()

void SCH_SHEET_LIST::AnnotatePowerSymbols

(

)

Silently annotate the not yet annotated power symbols of the entire hierarchy of the sheet path list.

It is called before creating a netlist, to annotate power symbols, without prompting the user about not annotated or duplicate for these symbols, if only these symbols need annotation ( a very frequent case ).

Definition at line 574 of file sch_sheet_path.cpp.

{
    // List of reference for power symbols
    SCH_REFERENCE_LIST references;

    // Map of locked components (not used, but needed by Annotate()
    SCH_MULTI_UNIT_REFERENCE_MAP lockedComponents;

    // Build the list of power components:
    for( SCH_SHEET_PATH& sheet : *this )
    {
        for( auto item : sheet.LastScreen()->Items().OfType( SCH_COMPONENT_T ) )
        {
            auto      component = static_cast<SCH_COMPONENT*>( item );
            LIB_PART* part = component->GetPartRef().get();

            if( !part || !part->IsPower() )
                continue;

            if( part )
            {
                SCH_REFERENCE schReference( component, part, sheet );
                references.AddItem( schReference );
            }
        }
    }

    // Find duplicate, and silently clear annotation of duplicate
    std::map<wxString, int> ref_list;   // stores the existing references

    for( unsigned ii = 0; ii< references.GetCount(); ++ii )
    {
        wxString curr_ref = references[ii].GetRef();

        if( ref_list.find( curr_ref ) == ref_list.end() )
        {
            ref_list[curr_ref] = ii;
            continue;
        }

        // Possible duplicate, if the ref ends by a number:
        if( curr_ref.Last() < '0' && curr_ref.Last() > '9' )
            continue;   // not annotated

        // Duplicate: clear annotation by removing the number ending the ref
        while( curr_ref.Last() >= '0' && curr_ref.Last() <= '9' )
            curr_ref.RemoveLast();

        references[ii].SetRef( curr_ref );
    }


    // Break full components reference in name (prefix) and number:
    // example: IC1 become IC, and 1
    references.SplitReferences();

    // Ensure all power symbols have the reference starting by '#'
    // (No sure this is really useful)
    for( unsigned ii = 0; ii< references.GetCount(); ++ii )
    {
        if( references[ii].GetRef()[0] != '#' )
        {
            wxString new_ref = "#" + references[ii].GetRef();
            references[ii].SetRef( new_ref );
        }
    }

    // Recalculate and update reference numbers in schematic
    references.Annotate( false, 0, 100, lockedComponents );
    references.UpdateAnnotation();
}

References SCH_REFERENCE_LIST::AddItem(), SCH_REFERENCE_LIST::Annotate(), SCH_REFERENCE_LIST::GetCount(), LIB_PART::IsPower(), SCH_SCREEN::Items(), SCH_SHEET_PATH::LastScreen(), EE_RTREE::OfType(), SCH_COMPONENT_T, SCH_REFERENCE_LIST::SplitReferences(), and SCH_REFERENCE_LIST::UpdateAnnotation().

Referenced by SCH_EDIT_FRAME::KiwayMailIn(), TEST_NETLISTS_FIXTURE::loadSchematic(), TEST_SCH_SHEET_LIST_FIXTURE::loadSchematic(), DIALOG_ERC::OnRunERCClick(), SCH::readSchematicFromFile(), ReadSchematicFromFile(), SCH_EDIT_FRAME::ReadyToNetlist(), DIALOG_ERC::testErc(), and SCH_EDIT_FRAME::WriteNetListFile().

BuildSheetList()

void SCH_SHEET_LIST::BuildSheetList	(	SCH_SHEET *	aSheet,
		bool	aCheckIntegrity
	)

Build the list of sheets and their sheet path from aSheet.

If aSheet is the root sheet, the full sheet path and sheet list are built.

Parameters

aSheet

is the starting sheet from which the list is built, or NULL indicating that g_RootSheet should be used.

Exceptions

std::bad_alloc

if the memory for the sheet path list could not be allocated.

Definition at line 433 of file sch_sheet_path.cpp.

{
    wxCHECK_RET( aSheet != NULL, wxT( "Cannot build sheet list from undefined sheet." ) );

    std::vector<SCH_SHEET*> badSheets;

    m_currentSheetPath.push_back( aSheet );
    m_currentSheetPath.SetVirtualPageNumber( static_cast<int>( size() ) + 1 );
    push_back( m_currentSheetPath );

    if( m_currentSheetPath.LastScreen() )
    {
        wxString               parentFileName = aSheet->GetFileName();
        std::vector<SCH_ITEM*> childSheets;
        m_currentSheetPath.LastScreen()->GetSheets( &childSheets );

        for( SCH_ITEM* item : childSheets )
        {
            SCH_SHEET* sheet = static_cast<SCH_SHEET*>( item );

            if( aCheckIntegrity )
            {
                if( !m_currentSheetPath.TestForRecursion( sheet->GetFileName(), parentFileName ) )
                    BuildSheetList( sheet, true );
                else
                    badSheets.push_back( sheet );
            }
            else
            {
                BuildSheetList( sheet, false );
            }
        }
    }

    if( aCheckIntegrity )
    {
        for( SCH_SHEET* sheet : badSheets )
        {
            m_currentSheetPath.LastScreen()->Remove( sheet );
            m_currentSheetPath.LastScreen()->SetModify();
        }
    }

    m_currentSheetPath.pop_back();
}

References SCH_SHEET::GetFileName(), SCH_SCREEN::GetSheets(), SCH_SHEET_PATH::LastScreen(), m_currentSheetPath, NULL, SCH_SHEET_PATH::pop_back(), SCH_SHEET_PATH::push_back(), SCH_SCREEN::Remove(), BASE_SCREEN::SetModify(), SCH_SHEET_PATH::SetVirtualPageNumber(), and SCH_SHEET_PATH::TestForRecursion().

Referenced by DIALOG_PLOT_SCHEMATIC::CreateDXFFile(), DIALOG_PLOT_SCHEMATIC::createHPGLFile(), DIALOG_PLOT_SCHEMATIC::createPDFFile(), DIALOG_PLOT_SCHEMATIC::createPSFile(), DIALOG_PLOT_SCHEMATIC::createSVGFile(), SCHEMATIC::GetFullHierarchy(), and SCH_SHEET_LIST().

ClearModifyStatus()

void SCH_SHEET_LIST::ClearModifyStatus

(

)

Definition at line 504 of file sch_sheet_path.cpp.

{
    for( const SCH_SHEET_PATH& sheet : *this )
    {
        if( sheet.LastScreen() )
            sheet.LastScreen()->ClrModify();
    }
}

References BASE_SCREEN::ClrModify(), and SCH_SHEET_PATH::LastScreen().

Referenced by SCH_EDIT_FRAME::doCloseWindow().

FillItemMap()

void SCH_SHEET_LIST::FillItemMap

(

std::map< KIID, EDA_ITEM * > &

aMap

)

Fill an item cache for temporary use when many items need to be fetched.

Definition at line 554 of file sch_sheet_path.cpp.

{
    for( const SCH_SHEET_PATH& sheet : *this )
    {
        SCH_SCREEN* screen = sheet.LastScreen();

        for( SCH_ITEM* aItem : screen->Items() )
        {
            aMap[ aItem->m_Uuid ] = aItem;

            aItem->RunOnChildren(
                    [&]( SCH_ITEM* aChild )
                    {
                        aMap[ aChild->m_Uuid ] = aChild;
                    } );
        }
    }
}

References SCH_SCREEN::Items(), SCH_SHEET_PATH::LastScreen(), and EDA_ITEM::m_Uuid.

Referenced by DIALOG_ERC::writeReport().

FindSheetForScreen()

SCH_SHEET_PATH * SCH_SHEET_LIST::FindSheetForScreen

(

SCH_SCREEN *

aScreen

)

Return a pointer to the first SCH_SHEET_PATH object (not necessarily the only one) using a particular screen.

Definition at line 715 of file sch_sheet_path.cpp.

{
    for( SCH_SHEET_PATH& sheetpath : *this )
    {
        if( sheetpath.LastScreen() == aScreen )
            return &sheetpath;
    }

    return nullptr;
}

References SCH_SHEET_PATH::LastScreen().

Referenced by SCH_EDITOR_CONTROL::FindNext(), and SCH_EDITOR_CONTROL::ReplaceAll().

GetItem()

SCH_ITEM * SCH_SHEET_LIST::GetItem	(	const KIID &	aID,
		SCH_SHEET_PATH *	aPathOut = nullptr
	)

Fetch a SCH_ITEM by ID.

Also returns the sheet the item was found on in aPathOut.

Definition at line 514 of file sch_sheet_path.cpp.

{
    for( const SCH_SHEET_PATH& sheet : *this )
    {
        SCH_SCREEN* screen = sheet.LastScreen();

        for( SCH_ITEM* aItem : screen->Items() )
        {
            if( aItem->m_Uuid == aID )
            {
                if( aPathOut )
                    *aPathOut = sheet;

                return aItem;
            }

            SCH_ITEM* childMatch = nullptr;

            aItem->RunOnChildren(
                    [&]( SCH_ITEM* aChild )
                    {
                        if( aChild->m_Uuid == aID )
                            childMatch = aChild;
                    } );

            if( childMatch )
            {
                if( aPathOut )
                    *aPathOut = sheet;

                return childMatch;
            }
        }
    }

    // Not found; weak reference has been deleted.
    return DELETED_SHEET_ITEM::GetInstance();
}

References DELETED_SHEET_ITEM::GetInstance(), SCH_SCREEN::Items(), SCH_SHEET_PATH::LastScreen(), EDA_ITEM::m_Uuid, and SCH_ITEM::RunOnChildren().

Referenced by SCHEMATIC::ConvertKIIDsToRefs(), SCH_EDIT_FRAME::FocusOnItem(), SCH_EDIT_FRAME::GetItem(), DIALOG_ERC::OnERCItemSelected(), SCHEMATIC::ResolveCrossReference(), and SCH_EDIT_FRAME::ResolveERCExclusions().

GetMultiUnitSymbols()

void SCH_SHEET_LIST::GetMultiUnitSymbols	(	SCH_MULTI_UNIT_REFERENCE_MAP &	aRefList,
		bool	aIncludePowerSymbols = true
	)		const

Add a SCH_REFERENCE_LIST object to aRefList for each same-reference set of multi-unit parts in the list of sheets.

The map key for each element will be the reference designator.

Parameters

aRefList	Map of reference designators to reference lists
aIncludePowerSymbols	Set to false to only get normal components.

Definition at line 655 of file sch_sheet_path.cpp.

{
    for( SCH_SHEET_PATHS::const_iterator it = begin(); it != end(); ++it )
    {
        SCH_MULTI_UNIT_REFERENCE_MAP tempMap;
        (*it).GetMultiUnitComponents( tempMap );

        for( SCH_MULTI_UNIT_REFERENCE_MAP::value_type& pair : tempMap )
        {
            // Merge this list into the main one
            unsigned n_refs = pair.second.GetCount();

            for( unsigned thisRef = 0; thisRef < n_refs; ++thisRef )
            {
                aRefList[pair.first].AddItem( pair.second[thisRef] );
            }
        }
    }
}

Referenced by SCH_EDIT_FRAME::AnnotateComponents(), BACK_ANNOTATE::BackAnnotateSymbols(), and ERC_TESTER::TestMultiunitFootprints().

GetPaths()

std::vector< KIID_PATH > SCH_SHEET_LIST::GetPaths

(

)

const

Definition at line 807 of file sch_sheet_path.cpp.

{
    std::vector<KIID_PATH> paths;

    for( const SCH_SHEET_PATH& sheetPath : *this )
        paths.emplace_back( sheetPath.Path() );

    return paths;
}

References SCH_SHEET_PATH::Path().

GetSymbols()

void SCH_SHEET_LIST::GetSymbols	(	SCH_REFERENCE_LIST &	aReferences,
		bool	aIncludePowerSymbols = true,
		bool	aForceIncludeOrphanComponents = false
	)		const

Add a SCH_REFERENCE object to aReferences for each component in the list of sheets.

Parameters

aReferences	List of references to populate.
aIncludePowerSymbols	Set to false to only get normal components.
aForceIncludeOrphanComponents	: true to include components having no symbol found in lib. ( orphan components) The normal option is false, and set to true only to build the full list of components.

Definition at line 647 of file sch_sheet_path.cpp.

{
    for( const SCH_SHEET_PATH& sheet : *this )
        sheet.GetSymbols( aReferences, aIncludePowerSymbols, aForceIncludeOrphanComponents );
}

References SCH_SHEET_PATH::GetSymbols().

Referenced by SCH_EDIT_FRAME::AnnotateComponents(), SCH_EDITOR_CONTROL::AssignFootprints(), BACK_ANNOTATE::BackAnnotateSymbols(), SCH_EDIT_FRAME::CheckAnnotate(), SCHEMATIC::ConvertRefsToKIIDs(), DIALOG_FIELDS_EDITOR_GLOBAL::DIALOG_FIELDS_EDITOR_GLOBAL(), SCH_EDITOR_CONTROL::doCopy(), DIALOG_EDIT_COMPONENTS_LIBID::initDlg(), SCH_EDIT_FRAME::mapExistingAnnotation(), DIALOG_LABEL_EDITOR::onScintillaCharAdded(), DIALOG_SCH_EDIT_ONE_FIELD::onScintillaCharAdded(), SCH_EDITOR_CONTROL::processCmpToFootprintLinkFile(), and UpdateSymbolInstances().

IsModified()

bool SCH_SHEET_LIST::IsModified

(

)

Check the entire hierarchy for any modifications.

Returns

True if the hierarchy is modified otherwise false.

Definition at line 492 of file sch_sheet_path.cpp.

{
    for( const SCH_SHEET_PATH& sheet : *this )
    {
        if( sheet.LastScreen() && sheet.LastScreen()->IsModify() )
            return true;
    }

    return false;
}

References BASE_SCREEN::IsModify(), and SCH_SHEET_PATH::LastScreen().

Referenced by SCH_EDIT_FRAME::canCloseWindow(), SCH_EDIT_FRAME::IsContentModified(), and SCH_EDIT_FRAME::OpenProjectFiles().

NameExists()

bool SCH_SHEET_LIST::NameExists

(

const wxString &

aSheetName

)

Definition at line 480 of file sch_sheet_path.cpp.

{
    for( const SCH_SHEET_PATH& sheet : *this )
    {
        if( sheet.Last()->GetName() == aSheetName )
            return true;
    }

    return false;
}

References SCH_SHEET::GetName(), and SCH_SHEET_PATH::Last().

Referenced by SCH_EDIT_TOOL::Duplicate(), and SCH_EDITOR_CONTROL::Paste().

ReplaceLegacySheetPaths()

void SCH_SHEET_LIST::ReplaceLegacySheetPaths

(

const std::vector< KIID_PATH > &

aOldSheetPaths

)

Update all of the symbol sheet paths to the sheet paths defined in aOldSheetPaths.

Note

The list of old sheet paths must be the exact same size and order as the existing sheet paths. This should not be an issue if no new sheets where added between the creation of this sheet list and aOldSheetPaths. This should only be called when updating legacy schematics to the new schematic file format. Once this happens, the schematic cannot be save to the legacy file format because the time stamp part of UUIDs are no longer guaranteed to be unique.

Parameters

aOldSheetPaths

is the #SHEET_PATH_LIST to update from.

Definition at line 818 of file sch_sheet_path.cpp.

{
    wxCHECK( size() == aOldSheetPaths.size(), /* void */ );

    for( size_t i = 0;  i < size(); i++ )
    {
        const KIID_PATH oldSheetPath = aOldSheetPaths.at( i );
        const KIID_PATH newSheetPath = at( i ).Path();
        SCH_SCREEN* screen = at(i).LastScreen();

        wxCHECK( screen, /* void */ );

        for( SCH_ITEM* symbol : screen->Items().OfType( SCH_COMPONENT_T ) )
        {
            static_cast<SCH_COMPONENT*>( symbol )->ReplaceInstanceSheetPath( oldSheetPath,
                                                                             newSheetPath );
        }
    }
}

References SCH_SCREEN::Items(), EE_RTREE::OfType(), and SCH_COMPONENT_T.

SetInitialPageNumbers()

void SCH_SHEET_LIST::SetInitialPageNumbers

(

)

Set initial sheet page numbers.

The number scheme is base on the old psuedo sheet numbering algorithm prior to the implementation of user defineable sheet page numbers.

Definition at line 855 of file sch_sheet_path.cpp.

{
    // Don't accidently renumber existing sheets.
    wxCHECK( AllSheetPageNumbersEmpty(), /* void */ );

    wxString tmp;
    int pageNumber = 1;

    for( const SCH_SHEET_PATH& instance : *this )
    {
        SCH_SHEET* sheet = instance.Last();

        wxCHECK2( sheet, continue );

        sheet->AddInstance( instance.Path() );
        tmp.Printf( "%d", pageNumber );
        sheet->SetPageNumber( instance, tmp );
        pageNumber += 1;
    }
}

References SCH_SHEET::AddInstance(), AllSheetPageNumbersEmpty(), SCH_SHEET_PATH::Last(), SCH_SHEET_PATH::Path(), and SCH_SHEET::SetPageNumber().

Referenced by BOOST_AUTO_TEST_CASE(), and SCH_EDIT_FRAME::OpenProjectFiles().

TestForRecursion()

bool SCH_SHEET_LIST::TestForRecursion	(	const SCH_SHEET_LIST &	aSrcSheetHierarchy,
		const wxString &	aDestFileName
	)

Test every SCH_SHEET_PATH in this SCH_SHEET_LIST to verify if adding the sheets stored in aSrcSheetHierarchy to the sheet stored in aDestFileName will cause recursion.

Parameters

aSrcSheetHierarchy	is the SCH_SHEET_LIST of the source sheet add to aDestFileName.
aDestFileName	is the file name of the destination sheet for aSrcFileName.

Returns

true if aFileName will cause recursion in the sheet path. Otherwise false.

Definition at line 677 of file sch_sheet_path.cpp.

{
    if( empty() )
        return false;

    SCHEMATIC* sch = at( 0 ).LastScreen()->Schematic();

    wxCHECK_MSG( sch, false, "No SCHEMATIC found in SCH_SHEET_LIST::TestForRecursion!" );

    wxFileName rootFn = sch->GetFileName();
    wxFileName destFn = aDestFileName;

    if( destFn.IsRelative() )
        destFn.MakeAbsolute( rootFn.GetPath() );

    // Test each SCH_SHEET_PATH in this SCH_SHEET_LIST for potential recursion.
    for( unsigned i = 0; i < size(); i++ )
    {
        // Test each SCH_SHEET_PATH in the source sheet.
        for( unsigned j = 0; j < aSrcSheetHierarchy.size(); j++ )
        {
            const SCH_SHEET_PATH* sheetPath = &aSrcSheetHierarchy[j];

            for( unsigned k = 0; k < sheetPath->size(); k++ )
            {
                if( at( i ).TestForRecursion( sheetPath->GetSheet( k )->GetFileName(),
                                              aDestFileName ) )
                    return true;
            }
        }
    }

    // The source sheet file can safely be added to the destination sheet file.
    return false;
}

References empty(), SCHEMATIC::GetFileName(), SCH_SHEET::GetFileName(), SCH_SHEET_PATH::GetSheet(), and SCH_SHEET_PATH::size().

Referenced by SCH_EDIT_FRAME::CheckSheetForRecursion(), and SCH_EDITOR_CONTROL::Paste().

UpdateSheetInstances()

void SCH_SHEET_LIST::UpdateSheetInstances

(

const std::vector< SCH_SHEET_INSTANCE > &

aSheetInstances

)

Update all of the sheet instance information using aSheetInstances.

Warning

Do not call this on anything other than the full hierarchy.

Parameters

aSymbolInstances

is the symbol path information loaded from the root schematic.

Definition at line 779 of file sch_sheet_path.cpp.

{

    for( const SCH_SHEET_PATH& instance : *this )
    {
        auto it = std::find_if( aSheetInstances.begin(), aSheetInstances.end(),
                                [ instance ]( const SCH_SHEET_INSTANCE& r ) -> bool
                                {
                                    return instance.PathWithoutRootUuid() == r.m_Path;
                                } );

        if( it == aSheetInstances.end() )
        {
            wxLogTrace( traceSchSheetPaths, "No sheet instance found for path \"%s\"",
                        instance.PathWithoutRootUuid().AsString() );
            continue;
        }

        SCH_SHEET* sheet = instance.Last();

        wxCHECK2( sheet, continue );

        sheet->AddInstance( instance.Path() );
        sheet->SetPageNumber( instance, it->m_PageNumber );
    }
}

References SCH_SHEET::AddInstance(), KIID_PATH::AsString(), SCH_SHEET_PATH::Last(), SCH_SHEET_PATH::Path(), SCH_SHEET_PATH::PathWithoutRootUuid(), SCH_SHEET::SetPageNumber(), and traceSchSheetPaths.

Referenced by SCH_EDIT_FRAME::OpenProjectFiles().

UpdateSymbolInstances()

void SCH_SHEET_LIST::UpdateSymbolInstances

(

const std::vector< SYMBOL_INSTANCE_REFERENCE > &

aSymbolInstances

)

Update all of the symbol instance information using aSymbolInstances.

WARNING: Do not call this on anything other than the full hierarchy.

Parameters

aSymbolInstances

is the symbol path information loaded from the root schematic.

Definition at line 727 of file sch_sheet_path.cpp.

{
    SCH_REFERENCE_LIST symbolInstances;

    GetSymbols( symbolInstances, true, true );

    std::map<KIID_PATH, wxString> pathNameCache;

    // Calculating the name of a path is somewhat expensive; on large designs with many components
    // this can blow up to a serious amount of time when loading the schematic
    auto getName = [&pathNameCache]( const KIID_PATH& aPath ) -> const wxString&
                   {
                       if( pathNameCache.count( aPath ) )
                           return pathNameCache.at( aPath );

                       pathNameCache[aPath] = aPath.AsString();
                       return pathNameCache[aPath];
                   };

    for( size_t i = 0; i < symbolInstances.GetCount(); i++ )
    {
        // The instance paths are stored in the file sans root path so the comparison
        // should not include the root path.
        wxString path = symbolInstances[i].GetPath();

        auto it = std::find_if( aSymbolInstances.begin(), aSymbolInstances.end(),
                                [ path, &getName ]( const SYMBOL_INSTANCE_REFERENCE& r ) -> bool
                                {
                                    return path == getName( r.m_Path );
                                } );

        if( it == aSymbolInstances.end() )
        {
            wxLogTrace( traceSchSheetPaths, "No symbol instance found for path \"%s\"", path );
            continue;
        }

        SCH_COMPONENT* symbol = symbolInstances[ i ].GetSymbol();

        wxCHECK2( symbol, continue );

        // Symbol instance paths are stored and looked up in memory with the root path so use
        // the full path here.
        symbol->AddHierarchicalReference( symbolInstances[i].GetSheetPath().Path(),
                                          it->m_Reference, it->m_Unit, it->m_Value,
                                          it->m_Footprint );
        symbol->GetField( REFERENCE_FIELD )->SetText( it->m_Reference );
    }
}

References SCH_COMPONENT::AddHierarchicalReference(), SCH_REFERENCE_LIST::GetCount(), SCH_COMPONENT::GetField(), GetSymbols(), REFERENCE_FIELD, EDA_TEXT::SetText(), and traceSchSheetPaths.

Referenced by TEST_NETLISTS_FIXTURE::loadSchematic(), TEST_SCH_SHEET_LIST_FIXTURE::loadSchematic(), SCH_EDIT_FRAME::OpenProjectFiles(), SCH::readSchematicFromFile(), and ReadSchematicFromFile().

Member Data Documentation

m_currentSheetPath

SCH_SHEET_PATH SCH_SHEET_LIST::m_currentSheetPath

private

Definition at line 351 of file sch_sheet_path.h.

Referenced by BuildSheetList().

---

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

• sch_sheet_path.h
• sch_sheet_path.cpp