SYMBOL_LIBRARY_MANAGER Class Reference

Class to handle modifications to the symbol libraries. More...

#include <symbol_library_manager.h>

Classes
class	LIB_BUFFER
class	PART_BUFFER
	Store a working copy of a library. More...

Public Member Functions
	SYMBOL_LIBRARY_MANAGER (SYMBOL_EDIT_FRAME &aFrame)
void	Sync (const wxString &aForceRefresh, std::function< void(int, int, const wxString &)> aProgressCallback)
	Updates the SYMBOL_LIBRARY_MANAGER data to synchronize with Symbol Library Table. More...
void	Preload (PROGRESS_REPORTER &aReporter)
	Preloads all symbol libraries in the symbol library table using SYMBOL_ASYNC_LOADER. More...
int	GetHash () const
bool	HasModifications () const
int	GetLibraryHash (const wxString &aLibrary) const
	Return a library hash value to determine if it has changed. More...
wxArrayString	GetLibraryNames () const
	Return the array of library names. More...
SYMBOL_LIB_TABLE_ROW *	GetLibrary (const wxString &aLibrary) const
	Find a single library within the (aggregate) library table. More...
std::list< LIB_PART * >	GetAliases (const wxString &aLibrary) const
bool	CreateLibrary (const wxString &aFilePath, SYMBOL_LIB_TABLE *aTable)
	Create an empty library and adds it to the library table. More...
bool	AddLibrary (const wxString &aFilePath, SYMBOL_LIB_TABLE *aTable)
	Add an existing library. More...
bool	UpdatePart (LIB_PART *aPart, const wxString &aLibrary)
	Update the part buffer with a new version of the part. More...
bool	UpdatePartAfterRename (LIB_PART *aPart, const wxString &oldAlias, const wxString &aLibrary)
	Update the part buffer with a new version of the part when the name has changed. More...
bool	RemovePart (const wxString &aName, const wxString &aLibrary)
	Remove the part from the part buffer. More...
LIB_PART *	GetAlias (const wxString &aAlias, const wxString &aLibrary) const
	Return either an alias of a working LIB_PART copy, or alias of the original part if there is no working copy. More...
LIB_PART *	GetBufferedPart (const wxString &aAlias, const wxString &aLibrary)
	Return the part copy from the buffer. More...
SCH_SCREEN *	GetScreen (const wxString &aAlias, const wxString &aLibrary)
	Return the screen used to edit a specific part. More...
bool	PartExists (const wxString &aAlias, const wxString &aLibrary) const
	Return true if part with a specific alias exists in library (either original one or buffered). More...
bool	LibraryExists (const wxString &aLibrary, bool aCheckEnabled=false) const
	Return true if library exists. More...
bool	IsLibraryLoaded (const wxString &aLibrary) const
	Return true if the library was successfully loaded. More...
bool	IsLibraryModified (const wxString &aLibrary) const
	Return true if library has unsaved modifications. More...
bool	IsPartModified (const wxString &aAlias, const wxString &aLibrary) const
	Return true if part has unsaved modifications. More...
bool	ClearLibraryModified (const wxString &aLibrary) const
	Clear the modified flag for all parts in a library. More...
bool	ClearPartModified (const wxString &aAlias, const wxString &aLibrary) const
	Clear the modified flag for a part. More...
bool	IsLibraryReadOnly (const wxString &aLibrary) const
	Return true if the library is stored in a read-only file. More...
bool	FlushPart (const wxString &aAlias, const wxString &aLibrary)
	Save part changes to the library copy used by the schematic editor. More...
bool	SaveLibrary (const wxString &aLibrary, const wxString &aFileName, SCH_IO_MGR::SCH_FILE_T aFileType=SCH_IO_MGR::SCH_FILE_T::SCH_LEGACY)
	Save library to a file, including unsaved changes. More...
LIB_ID	RevertPart (const wxString &aAlias, const wxString &aLibrary)
	Revert unsaved changes for a particular part. More...
bool	RevertLibrary (const wxString &aLibrary)
	Revert unsaved changes for a particular library. More...
bool	RevertAll ()
	Revert all pending changes. More...
wxString	GetUniqueLibraryName () const
	Return a library name that is not currently in use. More...
wxObjectDataPtr< LIB_TREE_MODEL_ADAPTER > &	GetAdapter ()
	Return the adapter object that provides the stored data. More...
void	GetRootSymbolNames (const wxString &aLibName, wxArrayString &aRootSymbolNames)
bool	HasDerivedSymbols (const wxString &aSymbolName, const wxString &aLibraryName)
	Check if symbol aSymbolName in library aLibraryName is a root symbol that has derived symbols. More...
size_t	GetLibraryCount () const

Private Member Functions
bool	addLibrary (const wxString &aFilePath, bool aCreate, SYMBOL_LIB_TABLE *aTable)
	Return the current Symbol Library Table. More...
SYMBOL_LIB_TABLE *	symTable () const
SYMBOL_TREE_SYNCHRONIZING_ADAPTER *	getAdapter ()
	Class to store a working copy of a LIB_PART object and editor context. More...
std::set< LIB_PART * >	getOriginalParts (const wxString &aLibrary)
	Return a set of LIB_PART objects belonging to the original library. More...
LIB_BUFFER &	getLibraryBuffer (const wxString &aLibrary)
	Return an existing library buffer or creates one to using Symbol Library Table to get the original data. More...

Static Private Member Functions
static wxString	getLibraryName (const wxString &aFilePath)
	< Extract library name basing on the file name. More...

Private Attributes
std::map< wxString, LIB_BUFFER >	m_libs
SYMBOL_EDIT_FRAME &	m_frame
	Parent frame. More...
LIB_LOGGER	m_logger
int	m_syncHash
	Symbol lib table hash value from last synchronization. More...
wxObjectDataPtr< LIB_TREE_MODEL_ADAPTER >	m_adapter

Detailed Description

Class to handle modifications to the symbol libraries.

Definition at line 101 of file symbol_library_manager.h.

Constructor & Destructor Documentation

SYMBOL_LIBRARY_MANAGER()

SYMBOL_LIBRARY_MANAGER::SYMBOL_LIBRARY_MANAGER

(

SYMBOL_EDIT_FRAME &

aFrame

)

Definition at line 43 of file symbol_library_manager.cpp.

                                                                          :
        m_frame( aFrame ),
        m_syncHash( 0 )
{
    m_adapter = SYMBOL_TREE_SYNCHRONIZING_ADAPTER::Create( &m_frame, this );
    m_adapter->ShowUnits( false );
}

References SYMBOL_TREE_SYNCHRONIZING_ADAPTER::Create(), m_adapter, and m_frame.

Member Function Documentation

AddLibrary()

bool SYMBOL_LIBRARY_MANAGER::AddLibrary ( const wxString &  aFilePath, SYMBOL_LIB_TABLE *  aTable  )

inline

Add an existing library.

The library is added to the library table as well.

Definition at line 155 of file symbol_library_manager.h.

    {
        return addLibrary( aFilePath, false, aTable );
    }

References addLibrary().

Referenced by SYMBOL_EDIT_FRAME::AddLibraryFile(), and SYMBOL_EDIT_FRAME::ExportPart().

addLibrary()

bool SYMBOL_LIBRARY_MANAGER::addLibrary ( const wxString &  aFilePath, bool  aCreate, SYMBOL_LIB_TABLE *  aTable  )

private

Return the current Symbol Library Table.

Definition at line 700 of file symbol_library_manager.cpp.

{
    wxCHECK( aTable, false );
    wxString libName = getLibraryName( aFilePath );
    wxCHECK( !LibraryExists( libName ), false );  // either create or add an existing one

    // try to use path normalized to an environmental variable or project path
    wxString relPath = NormalizePath( aFilePath, &Pgm().GetLocalEnvVariables(), &m_frame.Prj() );

    if( relPath.IsEmpty() )
        relPath = aFilePath;

    SCH_IO_MGR::SCH_FILE_T schFileType = SCH_IO_MGR::GuessPluginTypeFromLibPath( aFilePath );
    wxString typeName = SCH_IO_MGR::ShowType( schFileType );
    SYMBOL_LIB_TABLE_ROW* libRow = new SYMBOL_LIB_TABLE_ROW( libName, relPath, typeName );
    aTable->InsertRow( libRow );

    if( aCreate )
    {
        wxCHECK( schFileType != SCH_IO_MGR::SCH_FILE_T::SCH_LEGACY, false );

        try
        {
            aTable->CreateSymbolLib( libName );
        }
        catch( const IO_ERROR& )
        {
            aTable->RemoveRow( libRow );
            return false;
        }
    }

    m_frame.SyncLibraries( false );

    return true;
}

References SYMBOL_LIB_TABLE::CreateSymbolLib(), getLibraryName(), SCH_IO_MGR::GuessPluginTypeFromLibPath(), LIB_TABLE::InsertRow(), LibraryExists(), m_frame, NormalizePath(), Pgm(), KIWAY_HOLDER::Prj(), LIB_TABLE::RemoveRow(), SCH_IO_MGR::ShowType(), and SYMBOL_EDIT_FRAME::SyncLibraries().

Referenced by AddLibrary(), and CreateLibrary().

ClearLibraryModified()

bool SYMBOL_LIBRARY_MANAGER::ClearLibraryModified

(

const wxString &

aLibrary

)

const

Clear the modified flag for all parts in a library.

Definition at line 289 of file symbol_library_manager.cpp.

{
    auto libIt = m_libs.find( aLibrary );

    if( libIt == m_libs.end() )
        return false;

    for( auto& partBuf : libIt->second.GetBuffers() )
    {
        SCH_SCREEN* screen = partBuf->GetScreen();

        if( screen )
            screen->ClrModify();
    }

    return true;
}

References BASE_SCREEN::ClrModify(), and m_libs.

Referenced by SYMBOL_EDIT_FRAME::saveLibrary().

ClearPartModified()

bool SYMBOL_LIBRARY_MANAGER::ClearPartModified	(	const wxString &	aAlias,
		const wxString &	aLibrary
	)		const

Clear the modified flag for a part.

Definition at line 308 of file symbol_library_manager.cpp.

{
    auto libI = m_libs.find( aLibrary );

    if( libI == m_libs.end() )
        return false;

    auto partBuf = libI->second.GetBuffer( aAlias );
    wxCHECK( partBuf, false );

    partBuf->GetScreen()->ClrModify();
    return true;
}

References m_libs.

Referenced by SYMBOL_EDIT_FRAME::Revert(), and SYMBOL_EDIT_FRAME::saveCurrentPart().

CreateLibrary()

bool SYMBOL_LIBRARY_MANAGER::CreateLibrary ( const wxString &  aFilePath, SYMBOL_LIB_TABLE *  aTable  )

inline

Create an empty library and adds it to the library table.

The library file is created.

Definition at line 147 of file symbol_library_manager.h.

    {
        return addLibrary( aFilePath, true, aTable );
    }

References addLibrary().

Referenced by SYMBOL_EDIT_FRAME::AddLibraryFile().

FlushPart()

bool SYMBOL_LIBRARY_MANAGER::FlushPart	(	const wxString &	aAlias,
		const wxString &	aLibrary
	)

Save part changes to the library copy used by the schematic editor.

Not it is not necessarily saved to the file.

Returns

True on success, false otherwise.

Definition at line 491 of file symbol_library_manager.cpp.

{
    auto it = m_libs.find( aLibrary );

    if( it == m_libs.end() )    // no items to flush
        return true;

    auto partBuf = it->second.GetBuffer( aAlias );
    wxCHECK( partBuf, false );

    return it->second.SaveBuffer( partBuf, symTable() );
}

References m_libs, and symTable().

Referenced by SYMBOL_EDIT_FRAME::saveCurrentPart().

GetAdapter()

wxObjectDataPtr<LIB_TREE_MODEL_ADAPTER>& SYMBOL_LIBRARY_MANAGER::GetAdapter ( )

inline

Return the adapter object that provides the stored data.

Definition at line 291 of file symbol_library_manager.h.

{ return m_adapter; }

References m_adapter.

Referenced by SYMBOL_EDIT_FRAME::FreezeLibraryTree(), SYMBOL_TREE_PANE::SYMBOL_TREE_PANE(), SYMBOL_EDIT_FRAME::SyncLibraries(), and SYMBOL_EDIT_FRAME::ThawLibraryTree().

getAdapter()

SYMBOL_TREE_SYNCHRONIZING_ADAPTER* SYMBOL_LIBRARY_MANAGER::getAdapter ( )

inlineprivate

Class to store a working copy of a LIB_PART object and editor context.

Definition at line 315 of file symbol_library_manager.h.

References m_adapter.

Referenced by Sync().

GetAlias()

LIB_PART * SYMBOL_LIBRARY_MANAGER::GetAlias	(	const wxString &	aAlias,
		const wxString &	aLibrary
	)		const

Return either an alias of a working LIB_PART copy, or alias of the original part if there is no working copy.

Definition at line 585 of file symbol_library_manager.cpp.

{
    // Try the library buffers first
    auto libIt = m_libs.find( aLibrary );

    if( libIt != m_libs.end() )
    {
        LIB_PART* part = libIt->second.GetPart( aAlias );

        if( part )
            return part;
    }

    // Get the original part
    LIB_PART* alias = nullptr;

    try
    {
        alias = symTable()->LoadSymbol( aLibrary, aAlias );
    }
    catch( const IO_ERROR& e )
    {
        wxLogMessage( _( "Cannot load symbol \"%s\" from library \"%s\" (%s)" ),
                      aAlias, aLibrary, e.What() );
    }

    return alias;
}

References _, SYMBOL_LIB_TABLE::LoadSymbol(), m_libs, symTable(), and IO_ERROR::What().

Referenced by SYMBOL_EDIT_FRAME::CreateNewPart(), SYMBOL_EDIT_FRAME::getTargetPart(), and DIALOG_LIB_SYMBOL_PROPERTIES::TransferDataFromWindow().

GetAliases()

std::list< LIB_PART * > SYMBOL_LIBRARY_MANAGER::GetAliases

(

const wxString &

aLibrary

)

const

Definition at line 340 of file symbol_library_manager.cpp.

{
    std::list<LIB_PART*> ret;
    wxCHECK( LibraryExists( aLibrary ), ret );

    auto libIt = m_libs.find( aLibrary );

    if( libIt != m_libs.end() )
    {
        for( auto& partBuf : libIt->second.GetBuffers() )
        {
            ret.push_back( partBuf->GetPart() );
        }
    }
    else
    {
        std::vector<LIB_PART*> aliases;

        try
        {
            symTable()->LoadSymbolLib( aliases, aLibrary );
        }
        catch( const IO_ERROR& e )
        {
            wxLogWarning( e.Problem() );
        }

        std::copy( aliases.begin(), aliases.end(), std::back_inserter( ret ) );
    }

    return ret;
}

References LibraryExists(), SYMBOL_LIB_TABLE::LoadSymbolLib(), m_libs, IO_ERROR::Problem(), and symTable().

Referenced by SYMBOL_TREE_SYNCHRONIZING_ADAPTER::updateLibrary().

GetBufferedPart()

LIB_PART * SYMBOL_LIBRARY_MANAGER::GetBufferedPart	(	const wxString &	aAlias,
		const wxString &	aLibrary
	)

Return the part copy from the buffer.

In case it does not exist yet, the copy is created. SYMBOL_LIBRARY_MANAGER retains the ownership.

Definition at line 374 of file symbol_library_manager.cpp.

{
    wxCHECK( LibraryExists( aLibrary ), nullptr );

    // try the library buffers first
    LIB_BUFFER& libBuf = getLibraryBuffer( aLibrary );
    LIB_PART* bufferedPart = libBuf.GetPart( aAlias );

    if( !bufferedPart ) // no buffer part found
    {
        // create a copy of the part
        try
        {
            LIB_PART* part = symTable()->LoadSymbol( aLibrary, aAlias );

            if( part == nullptr )
                THROW_IO_ERROR( _( "Symbol not found." ) );

            LIB_PART* bufferedParent = nullptr;

            // Create parent symbols on demand so parent symbol can be set.
            if( part->IsAlias() )
            {
                std::shared_ptr< LIB_PART > parent = part->GetParent().lock();
                wxCHECK_MSG( parent, nullptr,
                             wxString::Format( "Derived symbol '%s' found with undefined parent.",
                                               part->GetName() ) );

                // Check if the parent symbol buffer has already be created.
                bufferedParent = libBuf.GetPart( parent->GetName() );

                if( !bufferedParent )
                {
                    bufferedParent = new LIB_PART( *parent.get() );
                    libBuf.CreateBuffer( bufferedParent, new SCH_SCREEN );
                }
            }

            bufferedPart = new LIB_PART( *part );

            if( bufferedParent )
                bufferedPart->SetParent( bufferedParent );

            libBuf.CreateBuffer( bufferedPart, new SCH_SCREEN );
        }
        catch( const IO_ERROR& e )
        {
            wxLogMessage( _( "Error loading symbol \"%s\" from library \"%s\". (%s)" ),
                          aAlias, aLibrary, e.What() );
            bufferedPart = nullptr;
        }
    }

    return bufferedPart;
}

References _, SYMBOL_LIBRARY_MANAGER::LIB_BUFFER::CreateBuffer(), Format(), getLibraryBuffer(), LIB_PART::GetName(), LIB_PART::GetParent(), SYMBOL_LIBRARY_MANAGER::LIB_BUFFER::GetPart(), LIB_PART::IsAlias(), LibraryExists(), SYMBOL_LIB_TABLE::LoadSymbol(), LIB_PART::SetParent(), symTable(), THROW_IO_ERROR, and IO_ERROR::What().

Referenced by SYMBOL_EDIT_FRAME::CopyPartToClipboard(), SYMBOL_EDIT_FRAME::DuplicatePart(), SYMBOL_EDIT_FRAME::isCurrentPart(), SYMBOL_EDIT_FRAME::LoadOneLibraryPartAux(), and SYMBOL_EDIT_FRAME::LoadPart().

GetHash()

int SYMBOL_LIBRARY_MANAGER::GetHash

(

)

const

Definition at line 119 of file symbol_library_manager.cpp.

{
    int hash = symTable()->GetModifyHash();

    for( const auto& lib : m_libs )
        hash += lib.second.GetHash();

    return hash;
}

References SYMBOL_LIB_TABLE::GetModifyHash(), m_libs, and symTable().

Referenced by RevertAll(), and SYMBOL_TREE_SYNCHRONIZING_ADAPTER::Sync().

GetLibrary()

SYMBOL_LIB_TABLE_ROW * SYMBOL_LIBRARY_MANAGER::GetLibrary

(

const wxString &

aLibrary

)

const

Find a single library within the (aggregate) library table.

Definition at line 156 of file symbol_library_manager.cpp.

{
    SYMBOL_LIB_TABLE_ROW* row = nullptr;

    try
    {
        row = symTable()->FindRow( aLibrary, true );
    }
    catch( const IO_ERROR& e )
    {
        wxLogMessage( _( "Cannot find library \"%s\" in the Symbol Library Table (%s)" ),
                      aLibrary, e.What() );
    }

    return row;
}

References _, SYMBOL_LIB_TABLE::FindRow(), symTable(), and IO_ERROR::What().

Referenced by GetLibraryHash(), SYMBOL_TREE_SYNCHRONIZING_ADAPTER::GetValue(), SYMBOL_EDIT_FRAME::IsSymbolFromLegacyLibrary(), SaveLibrary(), and SYMBOL_TREE_SYNCHRONIZING_ADAPTER::Sync().

getLibraryBuffer()

SYMBOL_LIBRARY_MANAGER::LIB_BUFFER & SYMBOL_LIBRARY_MANAGER::getLibraryBuffer ( const wxString &  aLibrary )

private

Return an existing library buffer or creates one to using Symbol Library Table to get the original data.

The library buffers

Definition at line 770 of file symbol_library_manager.cpp.

{
    auto it = m_libs.find( aLibrary );

    if( it != m_libs.end() )
        return it->second;

    // The requested buffer does not exist yet, so create one
    auto ret = m_libs.emplace( aLibrary, LIB_BUFFER( aLibrary ) );
    LIB_BUFFER& buf = ret.first->second;

    for( auto part : getOriginalParts( aLibrary ) )
    {
        LIB_PART* newSymbol;

        if( part->IsAlias() )
        {
            std::shared_ptr< LIB_PART > oldParent = part->GetParent().lock();

            wxCHECK_MSG( oldParent, buf,
                         wxString::Format( "Derived symbol '%s' found with undefined parent.",
                                           part->GetName() ) );

            LIB_PART* libParent = buf.GetPart( oldParent->GetName() );

            if( !libParent )
            {
                libParent = new LIB_PART( *oldParent.get() );
                buf.CreateBuffer( libParent, new SCH_SCREEN );
            }

            newSymbol = new LIB_PART( *part );
            newSymbol->SetParent( libParent );
            buf.CreateBuffer( newSymbol, new SCH_SCREEN );
        }
        else if( !buf.GetPart( part->GetName() ) )
        {
            buf.CreateBuffer( new LIB_PART( *part ), new SCH_SCREEN );
        }
    }

    return buf;
}

References SYMBOL_LIBRARY_MANAGER::LIB_BUFFER::CreateBuffer(), Format(), getOriginalParts(), LIB_PART::GetParent(), SYMBOL_LIBRARY_MANAGER::LIB_BUFFER::GetPart(), m_libs, and LIB_PART::SetParent().

Referenced by GetBufferedPart(), GetRootSymbolNames(), HasDerivedSymbols(), RemovePart(), UpdatePart(), and UpdatePartAfterRename().

GetLibraryCount()

size_t SYMBOL_LIBRARY_MANAGER::GetLibraryCount

(

)

const

Definition at line 687 of file symbol_library_manager.cpp.

{
    return symTable()->GetLogicalLibs().size();
}

References LIB_TABLE::GetLogicalLibs(), and symTable().

GetLibraryHash()

int SYMBOL_LIBRARY_MANAGER::GetLibraryHash

(

const wxString &

aLibrary

)

const

Return a library hash value to determine if it has changed.

For buffered libraries, it returns a number corresponding to the number of modifications. For original libraries, hash is computed basing on the library URI. Returns -1 when the requested library does not exist.

Definition at line 130 of file symbol_library_manager.cpp.

{
    const auto libBufIt = m_libs.find( aLibrary );

    if( libBufIt != m_libs.end() )
        return libBufIt->second.GetHash();

    auto row = GetLibrary( aLibrary );

    // return -1 if library does not exist or 0 if not modified
    return row ? std::hash<std::string>{}( aLibrary.ToStdString() +
                                           row->GetFullURI( true ).ToStdString() ) : -1;
}

References GetLibrary(), and m_libs.

Referenced by SYMBOL_TREE_SYNCHRONIZING_ADAPTER::updateLibrary().

getLibraryName()

wxString SYMBOL_LIBRARY_MANAGER::getLibraryName ( const wxString &  aFilePath )

staticprivate

< Extract library name basing on the file name.

Helper function to add either existing or create new library

Definition at line 693 of file symbol_library_manager.cpp.

{
    wxFileName fn( aFilePath );
    return fn.GetName();
}

Referenced by addLibrary().

GetLibraryNames()

wxArrayString SYMBOL_LIBRARY_MANAGER::GetLibraryNames

(

)

const

Return the array of library names.

Definition at line 145 of file symbol_library_manager.cpp.

{
    wxArrayString res;

    for( const auto& libName : symTable()->GetLogicalLibs() )
        res.Add( libName );

    return res;
}

References symTable().

Referenced by SYMBOL_TREE_SYNCHRONIZING_ADAPTER::GetLibrariesCount(), SYMBOL_EDIT_FRAME::IsContentModified(), SYMBOL_EDIT_FRAME::saveAllLibraries(), and SYMBOL_TREE_SYNCHRONIZING_ADAPTER::Sync().

getOriginalParts()

std::set< LIB_PART * > SYMBOL_LIBRARY_MANAGER::getOriginalParts ( const wxString &  aLibrary )

private

Return a set of LIB_PART objects belonging to the original library.

Definition at line 745 of file symbol_library_manager.cpp.

{
    std::set<LIB_PART*> parts;
    wxCHECK( LibraryExists( aLibrary ), parts );

    try
    {
        wxArrayString aliases;
        symTable()->EnumerateSymbolLib( aLibrary, aliases );

        for( const auto& aliasName : aliases )
        {
            LIB_PART* alias = symTable()->LoadSymbol( aLibrary, aliasName );
            parts.insert( alias );
        }
    }
    catch( const IO_ERROR& e )
    {
        wxLogMessage( _( "Cannot enumerate library \"%s\" (%s)" ), aLibrary, e.What() );
    }

    return parts;
}

References _, SYMBOL_LIB_TABLE::EnumerateSymbolLib(), LibraryExists(), SYMBOL_LIB_TABLE::LoadSymbol(), symTable(), and IO_ERROR::What().

Referenced by getLibraryBuffer(), and SaveLibrary().

GetRootSymbolNames()

void SYMBOL_LIBRARY_MANAGER::GetRootSymbolNames	(	const wxString &	aLibName,
		wxArrayString &	aRootSymbolNames
	)

Definition at line 669 of file symbol_library_manager.cpp.

{
    LIB_BUFFER& libBuf = getLibraryBuffer( aLibraryName );

    libBuf.GetRootSymbolNames( aRootSymbolNames );
}

References getLibraryBuffer(), and SYMBOL_LIBRARY_MANAGER::LIB_BUFFER::GetRootSymbolNames().

Referenced by SYMBOL_EDIT_FRAME::CreateNewPart(), and DIALOG_LIB_SYMBOL_PROPERTIES::TransferDataToWindow().

GetScreen()

SCH_SCREEN * SYMBOL_LIBRARY_MANAGER::GetScreen	(	const wxString &	aAlias,
		const wxString &	aLibrary
	)

Return the screen used to edit a specific part.

SYMBOL_LIBRARY_MANAGER retains the ownership.

Definition at line 432 of file symbol_library_manager.cpp.

{
    wxCHECK( LibraryExists( aLibrary ), nullptr );
    wxCHECK( !aAlias.IsEmpty(), nullptr );
    auto it = m_libs.find( aLibrary );
    wxCHECK( it != m_libs.end(), nullptr );

    LIB_BUFFER& buf = it->second;
    auto partBuf = buf.GetBuffer( aAlias );
    return partBuf ? partBuf->GetScreen() : nullptr;
}

References SYMBOL_LIBRARY_MANAGER::LIB_BUFFER::GetBuffer(), LibraryExists(), and m_libs.

Referenced by SYMBOL_EDIT_FRAME::LoadOneLibraryPartAux().

GetUniqueLibraryName()

wxString SYMBOL_LIBRARY_MANAGER::GetUniqueLibraryName

(

)

const

Return a library name that is not currently in use.

Used for generating names for new libraries.

Definition at line 649 of file symbol_library_manager.cpp.

{
    wxString name = "New_Library";

    if( !LibraryExists( name ) )
        return name;

    name += "_";

    for( unsigned int i = 0; i < std::numeric_limits<unsigned int>::max(); ++i )
    {
        if( !LibraryExists( name + wxString::Format( "%u", i ) ) )
            return name + wxString::Format( "%u", i );
    }

    wxFAIL;
    return wxEmptyString;
}

References Format(), LibraryExists(), and name.

Referenced by SYMBOL_EDIT_FRAME::AddLibraryFile().

HasDerivedSymbols()

bool SYMBOL_LIBRARY_MANAGER::HasDerivedSymbols	(	const wxString &	aSymbolName,
		const wxString &	aLibraryName
	)

Check if symbol aSymbolName in library aLibraryName is a root symbol that has derived symbols.

Returns

true if \aSymbolName in aLibraryName has derived symbols.

Definition at line 678 of file symbol_library_manager.cpp.

{
    LIB_BUFFER& libBuf = getLibraryBuffer( aLibraryName );

    return libBuf.HasDerivedSymbols( aSymbolName );
}

References getLibraryBuffer(), and SYMBOL_LIBRARY_MANAGER::LIB_BUFFER::HasDerivedSymbols().

Referenced by SYMBOL_LIBRARY_MANAGER::LIB_BUFFER::DeleteBuffer(), and SYMBOL_EDIT_FRAME::DeletePartFromLibrary().

HasModifications()

bool SYMBOL_LIBRARY_MANAGER::HasModifications

(

)

const

Definition at line 107 of file symbol_library_manager.cpp.

{
    for( const auto& lib : m_libs )
    {
        if( lib.second.IsModified() )
            return true;
    }

    return false;
}

References m_libs.

Referenced by SYMBOL_EDIT_FRAME::HasLibModifications(), and SYMBOL_EDIT_FRAME::setupUIConditions().

IsLibraryLoaded()

bool SYMBOL_LIBRARY_MANAGER::IsLibraryLoaded

(

const wxString &

aLibrary

)

const

Return true if the library was successfully loaded.

Definition at line 332 of file symbol_library_manager.cpp.

{
    wxCHECK( LibraryExists( aLibrary ), false );

    return symTable()->IsSymbolLibLoaded( aLibrary );
}

References SYMBOL_LIB_TABLE::IsSymbolLibLoaded(), LibraryExists(), and symTable().

Referenced by SYMBOL_TREE_SYNCHRONIZING_ADAPTER::GetAttr(), and SYMBOL_TREE_SYNCHRONIZING_ADAPTER::GetValue().

IsLibraryModified()

bool SYMBOL_LIBRARY_MANAGER::IsLibraryModified

(

const wxString &

aLibrary

)

const

Return true if library has unsaved modifications.

Definition at line 268 of file symbol_library_manager.cpp.

{
    auto it = m_libs.find( aLibrary );
    return it != m_libs.end() ? it->second.IsModified() : false;
}

References m_libs.

Referenced by SYMBOL_TREE_SYNCHRONIZING_ADAPTER::GetAttr(), SYMBOL_TREE_SYNCHRONIZING_ADAPTER::GetValue(), SYMBOL_EDIT_FRAME::IsContentModified(), and SYMBOL_EDIT_FRAME::saveAllLibraries().

IsLibraryReadOnly()

bool SYMBOL_LIBRARY_MANAGER::IsLibraryReadOnly

(

const wxString &

aLibrary

)

const

Return true if the library is stored in a read-only file.

Returns

True on success, false otherwise.

Definition at line 324 of file symbol_library_manager.cpp.

{
    wxCHECK( LibraryExists( aLibrary ), true );

    return !symTable()->IsSymbolLibWritable( aLibrary );
}

References SYMBOL_LIB_TABLE::IsSymbolLibWritable(), LibraryExists(), and symTable().

Referenced by SYMBOL_EDITOR_CONTROL::AddSymbol(), SYMBOL_EDITOR_CONTROL::CutCopyDelete(), SYMBOL_EDITOR_CONTROL::DuplicateSymbol(), SYMBOL_EDIT_FRAME::IsContentModified(), SYMBOL_EDIT_FRAME::Save(), SYMBOL_EDIT_FRAME::saveAllLibraries(), SYMBOL_EDIT_FRAME::saveLibrary(), SYMBOL_EDIT_FRAME::SelectLibraryFromList(), and SYMBOL_EDIT_FRAME::updateTitle().

IsPartModified()

bool SYMBOL_LIBRARY_MANAGER::IsPartModified	(	const wxString &	aAlias,
		const wxString &	aLibrary
	)		const

Return true if part has unsaved modifications.

Definition at line 275 of file symbol_library_manager.cpp.

{
    auto libIt = m_libs.find( aLibrary );

    if( libIt == m_libs.end() )
        return false;

    const LIB_BUFFER& buf = libIt->second;
    auto partBuf = buf.GetBuffer( aAlias );
    return partBuf ? partBuf->IsModified() : false;
}

References SYMBOL_LIBRARY_MANAGER::LIB_BUFFER::GetBuffer(), and m_libs.

Referenced by SYMBOL_EDIT_FRAME::DeletePartFromLibrary(), SYMBOL_TREE_SYNCHRONIZING_ADAPTER::GetAttr(), and SYMBOL_TREE_SYNCHRONIZING_ADAPTER::GetValue().

LibraryExists()

bool SYMBOL_LIBRARY_MANAGER::LibraryExists	(	const wxString &	aLibrary,
		bool	aCheckEnabled = false
	)		const

Return true if library exists.

If aCheckEnabled is set, then the library must also be enabled in the library table.

Definition at line 637 of file symbol_library_manager.cpp.

{
    if( aLibrary.IsEmpty() )
        return false;

    if( m_libs.count( aLibrary ) > 0 )
        return true;

    return symTable()->HasLibrary( aLibrary, aCheckEnabled );
}

References LIB_TABLE::HasLibrary(), m_libs, and symTable().

Referenced by addLibrary(), SYMBOL_EDIT_FRAME::AddLibraryFile(), SYMBOL_EDIT_FRAME::CreateNewPart(), SYMBOL_EDIT_FRAME::DuplicatePart(), GetAliases(), GetBufferedPart(), getOriginalParts(), GetScreen(), GetUniqueLibraryName(), SYMBOL_EDIT_FRAME::ImportPart(), IsLibraryLoaded(), IsLibraryReadOnly(), SaveLibrary(), SYMBOL_TREE_SYNCHRONIZING_ADAPTER::Sync(), and UpdatePart().

PartExists()

bool SYMBOL_LIBRARY_MANAGER::PartExists	(	const wxString &	aAlias,
		const wxString &	aLibrary
	)		const

Return true if part with a specific alias exists in library (either original one or buffered).

Definition at line 616 of file symbol_library_manager.cpp.

{
    auto libBufIt = m_libs.find( aLibrary );
    LIB_PART* alias = nullptr;

    if( libBufIt != m_libs.end() )
        return !!libBufIt->second.GetBuffer( aAlias );

    try
    {
        alias = symTable()->LoadSymbol( aLibrary, aAlias );
    }
    catch( IO_ERROR& )
    {
        // checking if certain symbol exists, so its absence is perfectly fine
    }

    return alias != nullptr;
}

References SYMBOL_LIB_TABLE::LoadSymbol(), m_libs, and symTable().

Referenced by SYMBOL_EDIT_FRAME::CreateNewPart(), SYMBOL_EDIT_FRAME::ensureUniqueName(), SYMBOL_EDIT_FRAME::ImportPart(), SYMBOL_EDIT_FRAME::Revert(), SYMBOL_EDIT_FRAME::savePartAs(), DIALOG_LIB_SYMBOL_PROPERTIES::TransferDataFromWindow(), and SYMBOL_EDIT_FRAME::UpdateAfterSymbolProperties().

Preload()

void SYMBOL_LIBRARY_MANAGER::Preload

(

PROGRESS_REPORTER &

aReporter

)

Preloads all symbol libraries in the symbol library table using SYMBOL_ASYNC_LOADER.

Call before the first call to Sync() to get better performance.

Parameters

aReporter

is used to report progress of the load

Definition at line 65 of file symbol_library_manager.cpp.

{
    const int progressIntervalMillis = 60;

    SYMBOL_ASYNC_LOADER loader( symTable()->GetLogicalLibs(), symTable(), false, nullptr,
                                &aReporter );

    LOCALE_IO toggle;

    loader.Start();

    while( !loader.Done() )
    {
        aReporter.KeepRefreshing();

        wxMilliSleep( progressIntervalMillis );
    }

    if( aReporter.IsCancelled() )
    {
        loader.Abort();
    }
    else
    {
        loader.Join();
    }

    if( !loader.GetErrors().IsEmpty() )
    {
        HTML_MESSAGE_BOX dlg( &m_frame, _( "Load Error" ) );

        dlg.MessageSet( _( "Errors were encountered loading symbols:" ) );

        wxString msg = loader.GetErrors();
        msg.Replace( "\n", "<BR>" );

        dlg.AddHTML_Text( msg );
        dlg.ShowModal();
    }
}

References _, SYMBOL_ASYNC_LOADER::Abort(), HTML_MESSAGE_BOX::AddHTML_Text(), SYMBOL_ASYNC_LOADER::Done(), SYMBOL_ASYNC_LOADER::GetErrors(), PROGRESS_REPORTER::IsCancelled(), SYMBOL_ASYNC_LOADER::Join(), PROGRESS_REPORTER::KeepRefreshing(), m_frame, HTML_MESSAGE_BOX::MessageSet(), SYMBOL_ASYNC_LOADER::Start(), and symTable().

RemovePart()

bool SYMBOL_LIBRARY_MANAGER::RemovePart	(	const wxString &	aName,
		const wxString &	aLibrary
	)

Remove the part from the part buffer.

It is required to save the library to have the part removed in the schematic editor.

Definition at line 570 of file symbol_library_manager.cpp.

{
    LIB_BUFFER& libBuf = getLibraryBuffer( aLibrary );
    auto partBuf = libBuf.GetBuffer( aAlias );
    wxCHECK( partBuf, false );

    bool retv = true;

    retv &= libBuf.DeleteBuffer( partBuf );
    m_frame.SyncLibraries( false );

    return retv;
}

References SYMBOL_LIBRARY_MANAGER::LIB_BUFFER::DeleteBuffer(), SYMBOL_LIBRARY_MANAGER::LIB_BUFFER::GetBuffer(), getLibraryBuffer(), m_frame, and SYMBOL_EDIT_FRAME::SyncLibraries().

Referenced by SYMBOL_EDIT_FRAME::DeletePartFromLibrary().

RevertAll()

bool SYMBOL_LIBRARY_MANAGER::RevertAll

(

)

Revert all pending changes.

Returns

True if all changes successfully reverted.

Definition at line 544 of file symbol_library_manager.cpp.

{
    bool retv = true;

    // Nothing to revert.
    if( GetHash() == 0 )
        return true;

    for( const auto& lib : m_libs )
    {
        if( !lib.second.IsModified() )
            continue;

        for( const auto& buffer : lib.second.GetBuffers() )
        {
            if( !buffer->IsModified() )
                continue;

            RevertPart( lib.first, buffer->GetOriginal()->GetName() );
        }
    }

    return retv;
}

References GetHash(), m_libs, and RevertPart().

Referenced by SYMBOL_EDIT_FRAME::RevertAll().

RevertLibrary()

bool SYMBOL_LIBRARY_MANAGER::RevertLibrary

(

const wxString &

aLibrary

)

Revert unsaved changes for a particular library.

Returns

True on success, false otherwise.

Definition at line 530 of file symbol_library_manager.cpp.

{
    auto it = m_libs.find( aLibrary );

    if( it == m_libs.end() )    // nothing to reverse
        return false;

    m_libs.erase( it );
    m_frame.SyncLibraries( false );

    return true;
}

References m_frame, m_libs, and SYMBOL_EDIT_FRAME::SyncLibraries().

Referenced by SYMBOL_EDIT_FRAME::Revert().

RevertPart()

LIB_ID SYMBOL_LIBRARY_MANAGER::RevertPart	(	const wxString &	aAlias,
		const wxString &	aLibrary
	)

Revert unsaved changes for a particular part.

Returns

The LIB_ID of the reverted part (which may be different in the case of a rename)

Definition at line 505 of file symbol_library_manager.cpp.

{
    auto it = m_libs.find( aLibrary );

    if( it == m_libs.end() )    // no items to flush
        return LIB_ID( aLibrary, aAlias );

    auto partBuf = it->second.GetBuffer( aAlias );
    wxCHECK( partBuf, LIB_ID( aLibrary, aAlias ) );
    LIB_PART original( *partBuf->GetOriginal() );

    if( original.GetName() != aAlias )
    {
        UpdatePartAfterRename( &original, aAlias, aLibrary );
    }
    else
    {
        partBuf->SetPart( new LIB_PART( original ) );
        m_frame.SyncLibraries( false );
    }

    return LIB_ID( aLibrary, original.GetName() );
}

References m_frame, m_libs, SYMBOL_EDIT_FRAME::SyncLibraries(), and UpdatePartAfterRename().

Referenced by SYMBOL_EDIT_FRAME::Revert(), and RevertAll().

SaveLibrary()

bool SYMBOL_LIBRARY_MANAGER::SaveLibrary	(	const wxString &	aLibrary,
		const wxString &	aFileName,
		SCH_IO_MGR::SCH_FILE_T	aFileType = SCH_IO_MGR::SCH_FILE_T::SCH_LEGACY
	)

Save library to a file, including unsaved changes.

Parameters

aLibrary	is the library name.
aFileName	is the target file name.

Returns

True on success, false otherwise.

Definition at line 174 of file symbol_library_manager.cpp.

{
    wxCHECK( aFileType != SCH_IO_MGR::SCH_FILE_T::SCH_LEGACY && LibraryExists( aLibrary ), false );
    wxFileName fn( aFileName );
    wxCHECK( !fn.FileExists() || fn.IsFileWritable(), false );
    SCH_PLUGIN::SCH_PLUGIN_RELEASER pi( SCH_IO_MGR::FindPlugin( aFileType ) );
    bool res = true;    // assume all libraries are successfully saved

    PROPERTIES properties;
    properties.emplace( SCH_LEGACY_PLUGIN::PropBuffering, "" );

    auto it = m_libs.find( aLibrary );

    if( it != m_libs.end() )
    {
        // Handle buffered library
        LIB_BUFFER& libBuf = it->second;

        const auto& partBuffers = libBuf.GetBuffers();

        for( const auto& partBuf : partBuffers )
        {
            if( !libBuf.SaveBuffer( partBuf, aFileName, &*pi, true ) )
            {
                // Something went wrong, but try to save other libraries
                res = false;
            }
        }

        // clear the deleted parts buffer only if data is saved to the original file
        wxFileName original, destination( aFileName );
        auto row = GetLibrary( aLibrary );

        if( row )
        {
            original = row->GetFullURI( true );
            original.Normalize();
        }

        destination.Normalize();

        if( res && original == destination )
            libBuf.ClearDeletedBuffer();
    }
    else
    {
        // Handle original library
        for( LIB_PART* part : getOriginalParts( aLibrary ) )
        {
            LIB_PART* newSymbol;

            if( part->IsAlias() )
            {
                std::shared_ptr< LIB_PART > oldParent = part->GetParent().lock();

                wxCHECK_MSG( oldParent, false,
                             wxString::Format( "Derived symbol '%s' found with undefined parent.",
                                               part->GetName() ) );

                LIB_PART* libParent = pi->LoadSymbol( aLibrary, oldParent->GetName(), &properties );

                if( !libParent )
                {
                    libParent = new LIB_PART( *oldParent.get() );
                    pi->SaveSymbol( aLibrary, libParent, &properties );
                }

                newSymbol = new LIB_PART( *part );
                newSymbol->SetParent( libParent );
                pi->SaveSymbol( aLibrary, newSymbol, &properties );
            }
            else if( !pi->LoadSymbol( aLibrary, part->GetName(), &properties ) )
            {
                pi->SaveSymbol( aLibrary, new LIB_PART( *part ), &properties );
            }
        }
    }

    try
    {
        pi->SaveLibrary( aFileName );
    }
    catch( ... )
    {
        // return false because something happens.
        // The library is not successfully saved
        res = false;
    }

    return res;
}

References SYMBOL_LIBRARY_MANAGER::LIB_BUFFER::ClearDeletedBuffer(), Format(), SYMBOL_LIBRARY_MANAGER::LIB_BUFFER::GetBuffers(), GetLibrary(), getOriginalParts(), LIB_PART::GetParent(), LibraryExists(), m_libs, SCH_LEGACY_PLUGIN::PropBuffering, SYMBOL_LIBRARY_MANAGER::LIB_BUFFER::SaveBuffer(), and LIB_PART::SetParent().

Referenced by SYMBOL_EDIT_FRAME::saveLibrary().

symTable()

SYMBOL_LIB_TABLE * SYMBOL_LIBRARY_MANAGER::symTable ( ) const

private

Definition at line 739 of file symbol_library_manager.cpp.

{
    return m_frame.Prj().SchSymbolLibTable();
}

References m_frame, and KIWAY_HOLDER::Prj().

Referenced by FlushPart(), GetAlias(), GetAliases(), GetBufferedPart(), GetHash(), GetLibrary(), GetLibraryCount(), GetLibraryNames(), getOriginalParts(), IsLibraryLoaded(), IsLibraryReadOnly(), LibraryExists(), PartExists(), Preload(), and Sync().

Sync()

void SYMBOL_LIBRARY_MANAGER::Sync	(	const wxString &	aForceRefresh,
		std::function< void(int, int, const wxString &)>	aProgressCallback
	)

Updates the SYMBOL_LIBRARY_MANAGER data to synchronize with Symbol Library Table.

Definition at line 52 of file symbol_library_manager.cpp.

{
    m_logger.Activate();
    {
        getAdapter()->Sync( aForceRefresh, aProgressCallback );
        m_syncHash = symTable()->GetModifyHash();
    }
    m_logger.Deactivate();
}

References LIB_LOGGER::Activate(), LIB_LOGGER::Deactivate(), getAdapter(), SYMBOL_LIB_TABLE::GetModifyHash(), m_logger, m_syncHash, symTable(), and SYMBOL_TREE_SYNCHRONIZING_ADAPTER::Sync().

Referenced by SYMBOL_EDIT_FRAME::SyncLibraries().

UpdatePart()

bool SYMBOL_LIBRARY_MANAGER::UpdatePart	(	LIB_PART *	aPart,
		const wxString &	aLibrary
	)

Update the part buffer with a new version of the part.

The library buffer creates a copy of the part. It is required to save the library to use the updated part in the schematic editor.

Definition at line 445 of file symbol_library_manager.cpp.

{
    wxCHECK( LibraryExists( aLibrary ), false );
    wxCHECK( aPart, false );
    LIB_BUFFER& libBuf = getLibraryBuffer( aLibrary );
    auto partBuf = libBuf.GetBuffer( aPart->GetName() );

    if( partBuf )     // Existing symbol.
    {
        LIB_PART* bufferedPart = const_cast< LIB_PART* >( partBuf->GetPart() );

        wxCHECK( bufferedPart, false );

        *bufferedPart = *aPart;
        partBuf->GetScreen()->SetModify();
    }
    else              // New symbol
    {
        LIB_PART* partCopy = new LIB_PART( *aPart, nullptr );

        partCopy->SetLibId( LIB_ID( aLibrary, aPart->GetLibId().GetLibItemName() ) );

        SCH_SCREEN* screen = new SCH_SCREEN;
        libBuf.CreateBuffer( partCopy, screen );
        screen->SetModify();
    }

    return true;
}

References SYMBOL_LIBRARY_MANAGER::LIB_BUFFER::CreateBuffer(), SYMBOL_LIBRARY_MANAGER::LIB_BUFFER::GetBuffer(), LIB_PART::GetLibId(), LIB_ID::GetLibItemName(), getLibraryBuffer(), LIB_PART::GetName(), LibraryExists(), LIB_PART::SetLibId(), and BASE_SCREEN::SetModify().

Referenced by SYMBOL_EDIT_FRAME::CreateNewPart(), SYMBOL_EDIT_FRAME::DuplicatePart(), SYMBOL_EDIT_FRAME::ImportPart(), SYMBOL_EDIT_FRAME::savePartAs(), and SYMBOL_EDIT_FRAME::storeCurrentPart().

UpdatePartAfterRename()

bool SYMBOL_LIBRARY_MANAGER::UpdatePartAfterRename	(	LIB_PART *	aPart,
		const wxString &	oldAlias,
		const wxString &	aLibrary
	)

Update the part buffer with a new version of the part when the name has changed.

The old library buffer will be deleted and a new one created with the new name.

Definition at line 476 of file symbol_library_manager.cpp.

{
    LIB_BUFFER& libBuf = getLibraryBuffer( aLibrary );
    auto partBuf = libBuf.GetBuffer( aOldName );

    wxCHECK( partBuf, false );

    libBuf.UpdateBuffer( partBuf, aPart );
    m_frame.SyncLibraries( false );

    return true;
}

References SYMBOL_LIBRARY_MANAGER::LIB_BUFFER::GetBuffer(), getLibraryBuffer(), m_frame, SYMBOL_EDIT_FRAME::SyncLibraries(), and SYMBOL_LIBRARY_MANAGER::LIB_BUFFER::UpdateBuffer().

Referenced by SYMBOL_EDIT_FRAME::GetSymbolFromRedoList(), SYMBOL_EDIT_FRAME::GetSymbolFromUndoList(), RevertPart(), and SYMBOL_EDIT_FRAME::UpdateAfterSymbolProperties().

Member Data Documentation

m_adapter

wxObjectDataPtr<LIB_TREE_MODEL_ADAPTER> SYMBOL_LIBRARY_MANAGER::m_adapter

private

Definition at line 475 of file symbol_library_manager.h.

Referenced by GetAdapter(), getAdapter(), and SYMBOL_LIBRARY_MANAGER().

m_frame

SYMBOL_EDIT_FRAME& SYMBOL_LIBRARY_MANAGER::m_frame

private

Parent frame.

Definition at line 471 of file symbol_library_manager.h.

Referenced by addLibrary(), Preload(), RemovePart(), RevertLibrary(), RevertPart(), SYMBOL_LIBRARY_MANAGER(), symTable(), and UpdatePartAfterRename().

m_libs

std::map<wxString, LIB_BUFFER> SYMBOL_LIBRARY_MANAGER::m_libs

private

Definition at line 469 of file symbol_library_manager.h.

Referenced by ClearLibraryModified(), ClearPartModified(), FlushPart(), GetAlias(), GetAliases(), GetHash(), getLibraryBuffer(), GetLibraryHash(), GetScreen(), HasModifications(), IsLibraryModified(), IsPartModified(), LibraryExists(), PartExists(), RevertAll(), RevertLibrary(), RevertPart(), and SaveLibrary().

m_logger

LIB_LOGGER SYMBOL_LIBRARY_MANAGER::m_logger

private

Definition at line 472 of file symbol_library_manager.h.

Referenced by Sync().

m_syncHash

int SYMBOL_LIBRARY_MANAGER::m_syncHash

private

Symbol lib table hash value from last synchronization.

Definition at line 473 of file symbol_library_manager.h.

Referenced by Sync().

---

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

• symbol_library_manager.h
• symbol_library_manager.cpp