21#ifndef LIBRARY_MANAGER_H
22#define LIBRARY_MANAGER_H
28#include <shared_mutex>
55 std::optional<LIBRARY_ERROR>
error = std::nullopt;
118 bool HasLibrary(
const wxString& aNickname,
bool aCheckEnabled =
false )
const;
127 bool aIncludeInvalid =
false )
const;
130 std::optional<LIBRARY_TABLE_ROW*>
GetRow(
const wxString& aNickname,
134 std::optional<LIBRARY_TABLE_ROW*>
FindRowByURI(
const wxString& aUri,
149 void ProjectTablesChanged( std::initializer_list<LIBRARY_TABLE_TYPE> aChangedTables = {} );
155 void ProjectTablesReloaded( std::initializer_list<LIBRARY_TABLE_TYPE> aChangedTables = {} );
157 void CheckTableRow( LIBRARY_TABLE_ROW& aRow );
175 std::optional<float> AsyncLoadProgress()
const;
177 void BlockUntilLoaded();
192 void AbortAsyncLoad(
bool aCancelPlugins =
false );
196 void RestartAsyncLoad();
201 void LeakCachesAtExit();
203 bool IsLibraryLoaded(
const wxString& aNickname );
206 std::optional<LIB_STATUS> GetLibraryStatus(
const wxString& aNickname )
const;
209 std::vector<std::pair<wxString, LIB_STATUS>> GetLibraryStatuses()
const;
212 std::vector<KI_ERROR> GetLibraryLoadErrors()
const;
215 void ReloadLibraryEntry(
const wxString& aNickname,
220 std::optional<LIB_STATUS> LoadLibraryEntry(
const wxString& aNickname );
223 virtual bool IsWritable(
const wxString& aNickname )
const;
226 bool CreateLibrary(
const wxString& aNickname );
244 virtual std::optional<LIBRARY_ERROR> LibraryError(
const wxString& aNickname )
const;
248 virtual std::map<wxString, LIB_DATA>&
globalLibs()
const = 0;
262 std::optional<const LIB_DATA*>
fetchIfLoaded(
const wxString& aNickname )
const;
264 std::optional<LIB_DATA*>
fetchIfLoaded(
const wxString& aNickname );
271 std::map<wxString, LIB_DATA>& aTarget,
272 std::shared_mutex& aMutex );
289 void stopRefreshThreads( std::map<wxString, LIB_DATA>& aLibs, std::shared_mutex& aMutex,
290 const std::function<
bool(
const wxString& aNickname,
const LIB_DATA& aLib )>&
296 void abortLoad(
bool aCancelPlugins =
false );
306 void resetProjectCache(
bool aCancelPlugins =
false );
320 static std::recursive_mutex&
pluginMutex(
const wxString& aNickname );
440 void LoadGlobalTables( std::initializer_list<LIBRARY_TABLE_TYPE> aTablesToLoad = {} );
443 void LoadProjectTables( std::initializer_list<LIBRARY_TABLE_TYPE> aTablesToLoad = {} );
445 void ReloadTables(
LIBRARY_TABLE_SCOPE aScope, std::initializer_list<LIBRARY_TABLE_TYPE> aTablesToLoad = {} );
455 void AbortAsyncLoads(
bool aCancelPlugins =
false );
458 void RestartAsyncLoads();
462 void LeakCachesAtExit();
465 std::unique_ptr<LIBRARY_MANAGER_ADAPTER>&& aAdapter );
493 bool aIncludeInvalid =
false )
const;
502 std::optional<LIBRARY_TABLE_ROW*> GetRow(
LIBRARY_TABLE_TYPE aType,
const wxString &aNickname,
505 std::optional<LIBRARY_TABLE_ROW*> FindRowByURI(
LIBRARY_TABLE_TYPE aType,
const wxString &aUri,
515 const wxString& aNickname );
517 void LoadProjectTables(
const wxString& aProjectPath,
518 std::initializer_list<LIBRARY_TABLE_TYPE> aTablesToLoad = {} );
529 std::optional<wxString> GetFullURI(
LIBRARY_TABLE_TYPE aType,
const wxString& aNickname,
530 bool aSubstituted =
false );
532 static wxString GetFullURI(
const LIBRARY_TABLE_ROW* aRow,
bool aSubstituted =
false,
533 const PROJECT* aProject =
nullptr );
535 static wxString ExpandURI(
const wxString& aShortURI,
const PROJECT& aProject );
537 static bool UrisAreEquivalent(
const wxString& aURI1,
const wxString& aURI2 );
550 static bool IsPcmManagedRow(
const LIBRARY_TABLE_ROW& aRow );
555 void ApplyLibOverrides( LIBRARY_TABLE& aTable );
565 void SetLibOverride(
const wxString& aTablePath,
const wxString& aNickname,
566 bool aDisabled,
bool aHidden );
569 void ClearLibOverride(
const wxString& aTablePath,
const wxString& aNickname );
573 std::vector<LIBRARY_TABLE_TYPE> aTablesToLoad = {} );
575 void loadNestedTables( LIBRARY_TABLE& aTable );
578 void applyLibOverrides( LIBRARY_TABLE& aTable );
585 std::map<LIBRARY_TABLE_TYPE, std::unique_ptr<LIBRARY_TABLE>>
m_tables;
593 std::map<LIBRARY_TABLE_TYPE, std::unique_ptr<LIBRARY_MANAGER_ADAPTER>>
m_adapters;
597 typedef std::tuple<LIBRARY_TABLE_TYPE, LIBRARY_TABLE_SCOPE, wxString>
ROW_CACHE_KEY;
The interface used by the classes that actually can load IO plugins for the different parts of KiCad ...
virtual std::optional< LIB_STATUS > LoadOne(LIB_DATA *aLib)=0
bool loadQueuedRow(const LOAD_WORK &aWork)
Loads one queued library on a worker thread.
std::atomic_bool m_cancelling
Set with m_abort by an abort that cancels, so only such an abort turns a failed load into INVALID.
virtual std::shared_mutex & globalLibsMutex() const =0
void stopRefreshThreads(std::map< wxString, LIB_DATA > &aLibs, std::shared_mutex &aMutex, const std::function< bool(const wxString &aNickname, const LIB_DATA &aLib)> &aRetiring={})
Stops the refresh threads of the plugins in aLibs that aRetiring selects, or of all of them when it i...
std::pair< wxString, LIBRARY_TABLE_SCOPE > LOADING_KEY
std::optional< LIBRARY_TABLE * > ProjectTable() const
Retrieves the project library table for this adapter type, or nullopt if one doesn't exist.
virtual void enumerateLibrary(LIB_DATA *aLib, const wxString &aUri)=0
Override in derived class to perform library-specific enumeration.
LIBRARY_TABLE * GlobalTable() const
Retrieves the global library table for this adapter type.
virtual std::shared_mutex & globalLibsMutex()=0
std::atomic< unsigned > m_abortGeneration
Counts cancelling aborts, so a load can tell one that began after it started from one that already en...
void evictOwnedGlobalEntries()
Erases this adapter's own entries (LIB_DATA::global_owner == this) from the process-wide globalLibs()...
LIBRARY_MANAGER_ADAPTER(LIBRARY_MANAGER &aManager)
Constructs a type-specific adapter into the library manager.
std::vector< LIBRARY_TABLE_ROW * > Rows(LIBRARY_TABLE_SCOPE aScope=LIBRARY_TABLE_SCOPE::BOTH, bool aIncludeInvalid=false) const
Like LIBRARY_MANAGER::Rows but filtered to the LIBRARY_TABLE_TYPE of this adapter.
std::optional< LIBRARY_TABLE_ROW * > FindRowByURI(const wxString &aUri, LIBRARY_TABLE_SCOPE aScope=LIBRARY_TABLE_SCOPE::BOTH) const
Like LIBRARY_MANAGER::FindRowByURI but filtered to the LIBRARY_TABLE_TYPE of this adapter.
wxString getUri(const LIBRARY_TABLE_ROW *aRow) const
virtual std::map< wxString, LIB_DATA > & globalLibs()=0
void cancelLoadingPlugins(const std::vector< LOADING_KEY > &aSnapshot)
Asks the plugins in aSnapshot to end their load early, so abortLoad() does not wait out their waits.
virtual LIBRARY_TABLE_TYPE Type() const =0
The type of library table this adapter works with.
void retireAllLibraries()
For derived destructors, while globalLibs() is still resolvable and plugin worker threads can still c...
bool DeleteLibrary(const wxString &aNickname)
Deletes the given library from disk if it exists; returns true if deleted.
void asyncLoadLocked()
The body of AsyncLoad(), run with m_loadMutex already held by the caller.
LIBRARY_RESULT< LIB_DATA * > loadIfNeeded(const wxString &aNickname)
Fetches a loaded library, triggering a load of that library if it isn't loaded yet.
std::optional< wxString > FindLibraryByURI(const wxString &aURI) const
std::mutex m_loadingMutex
Libraries an async worker is enumerating, so a cancel reaches exactly those plugins.
virtual bool SupportsConfigurationDialog(const LIBRARY_TABLE_ROW &aRow) const
Configuration works from the row itself, so libraries that failed to load or are not yet committed to...
std::vector< LOADING_KEY > loadingSnapshot()
The libraries an async worker is enumerating right now.
LIB_DATA & queuedRowEntry(const LOAD_WORK &aWork)
The cache entry of a queued library, created and owned by this adapter when it is missing,...
std::shared_mutex m_librariesMutex
std::set< LOADING_KEY > m_loading
LIBRARY_MANAGER & Manager() const
std::optional< wxString > GetLibraryDescription(const wxString &aNickname) const
virtual LIBRARY_RESULT< IO_BASE * > createPlugin(const LIBRARY_TABLE_ROW *row)=0
Creates a concrete plugin for the given row.
void GlobalTablesChanged(std::initializer_list< LIBRARY_TABLE_TYPE > aChangedTables={})
Notify the adapter that the global library tables have changed.
bool HasLibrary(const wxString &aNickname, bool aCheckEnabled=false) const
Test for the existence of aNickname in the library tables.
std::optional< LIBRARY_TABLE_ROW * > GetRow(const wxString &aNickname, LIBRARY_TABLE_SCOPE aScope=LIBRARY_TABLE_SCOPE::BOTH) const
Like LIBRARY_MANAGER::GetRow but filtered to the LIBRARY_TABLE_TYPE of this adapter.
std::map< wxString, LIB_DATA > m_libraries
virtual IO_BASE * plugin(const LIB_DATA *aRow)=0
std::vector< wxString > GetLibraryNames() const
Returns a list of library nicknames that are available (skips any that failed to load)
LIBRARY_RESULT< LIB_DATA * > loadFromScope(const wxString &aNickname, LIBRARY_TABLE_SCOPE aScope, std::map< wxString, LIB_DATA > &aTarget, std::shared_mutex &aMutex)
virtual std::optional< LIB_STATUS > CheckLibrary(LIB_DATA *aLib)
Validates that a library is loadable. May not necessarily load the library!
std::vector< std::future< void > > m_futures
void withPlugin(const LOADING_KEY &aKey, const std::function< void(IO_BASE &)> &aAction)
Runs aAction on the plugin of a library when it is still in the map.
static std::recursive_mutex & pluginMutex(const wxString &aNickname)
Serializes access to a library's shared plugin instance so its single mutable cache is not raced by c...
std::shared_mutex & scopeMutex(LIBRARY_TABLE_SCOPE aScope)
virtual int ShowConfigurationDialog(const LIBRARY_TABLE_ROW &aRow, LIBRARY_TABLE_SCOPE aScope, wxWindow *aParent)
Shows the plugin's configuration dialog for a library table row.
void resumeLoadingPlugins(const std::vector< LOADING_KEY > &aCancelled)
Tells the plugins cancelLoadingPlugins() reached that the loads they were asked to end have ended.
std::atomic< size_t > m_loadTotal
virtual std::map< wxString, LIB_DATA > & globalLibs() const =0
std::atomic< size_t > m_loadCount
LIBRARY_MANAGER & m_manager
bool m_rearmPending
Set when a cancelling abort cut a worker short, and cleared only by an AsyncLoad() that starts.
std::optional< const LIB_DATA * > fetchIfLoaded(const wxString &aNickname) const
static wxString StockTableTokenizedURI(LIBRARY_TABLE_TYPE aType)
const PROJECT *const m_project
std::mutex m_rowCacheMutex
std::map< wxString, std::unique_ptr< LIBRARY_TABLE > > m_childTables
Map of full URI to table object for tables that are referenced by global or project tables.
std::map< ROW_CACHE_KEY, LIBRARY_TABLE_ROW * > m_rowCache
const PROJECT & Project() const
std::mutex m_adaptersMutex
static wxString DefaultGlobalTablePath(LIBRARY_TABLE_TYPE aType)
static std::vector< LIBRARY_TABLE_TYPE > InvalidGlobalTables()
static bool GlobalTablesValid()
std::map< LIBRARY_TABLE_TYPE, std::unique_ptr< LIBRARY_TABLE > > m_projectTables
LIBRARY_MANAGER(const LIBRARY_MANAGER &)=delete
bool IsProjectScoped() const
static bool CreateGlobalTable(LIBRARY_TABLE_TYPE aType, bool aPopulateDefaultLibraries)
void LoadGlobalTables(std::initializer_list< LIBRARY_TABLE_TYPE > aTablesToLoad={})
(Re)loads the global library tables in the given list, or all tables if no list is given
std::map< LIBRARY_TABLE_TYPE, std::unique_ptr< LIBRARY_TABLE > > m_tables
LIBRARY_MANAGER & operator=(const LIBRARY_MANAGER &)=delete
std::tuple< LIBRARY_TABLE_TYPE, LIBRARY_TABLE_SCOPE, wxString > ROW_CACHE_KEY
static wxString StockTableReferenceURI(LIBRARY_TABLE_TYPE aType)
static wxString StockTablePath(LIBRARY_TABLE_TYPE aType)
static bool IsTableValid(const wxString &aPath)
LIBRARY_MANAGER(const PROJECT *aProject=nullptr)
An explicit project is borrowed until this manager and its adapters are destroyed.
std::map< LIBRARY_TABLE_TYPE, std::unique_ptr< LIBRARY_MANAGER_ADAPTER > > m_adapters
A progress reporter interface for use in multi-threaded environments.
Container for project specific data.
void ProjectChanged() override
LOAD_STATUS
Status of a library load managed by a library adapter.
tl::expected< ResultType, LIBRARY_ERROR > LIBRARY_RESULT
A library queued by AsyncLoad(), with its URI resolved on the calling thread.
LIBRARY_TABLE_SCOPE scope
Storage for an actual loaded library (including library content owned by the plugin)
std::vector< wxString > available_fields_cache
std::unique_ptr< IO_BASE > plugin
Never destroyed while holding the map's mutex; a plugin's worker thread may be blocked on it.
const LIBRARY_MANAGER_ADAPTER * global_owner
const LIBRARY_TABLE_ROW * row
The overall status of a loaded or loading library.
std::optional< LIBRARY_ERROR > error