library_manager.h

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright The KiCad Developers, see AUTHORS.txt for contributors.
 * @author Jon Evans <[email protected]>
 *
 * This program is free software: you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation, either version 3 of the License, or (at your
 * option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
#ifndef LIBRARY_MANAGER_H
#define LIBRARY_MANAGER_H
 
#include <future>
#include <memory>
#include <tl/expected.hpp>
 
#include <kicommon.h>
#include <libraries/library_table.h>
#include <io/io_base.h>
 
 
struct KICOMMON_API LIBRARY_ERROR
{
    LIBRARY_ERROR( const wxString& aMessage ) :
        message( aMessage )
    {};
 
    wxString message;
};
 
 
template<typename ResultType>
using LIBRARY_RESULT = tl::expected<ResultType, LIBRARY_ERROR>;
 
class LIBRARY_MANAGER;
class PROJECT;
 

enum class LOAD_STATUS
{
    INVALID,
    LOADING,
    LOADED,
    LOAD_ERROR
};

struct KICOMMON_API LIB_STATUS
{
    LOAD_STATUS                  load_status = LOAD_STATUS::INVALID;
    std::optional<LIBRARY_ERROR> error;
};
 

struct KICOMMON_API LIB_DATA
{
    std::unique_ptr<IO_BASE> plugin;
    const LIBRARY_TABLE_ROW* row = nullptr;
    std::mutex               mutex;
    LIB_STATUS               status;
 
    int                   modify_hash;
    std::vector<wxString> available_fields_cache;
};
 

class KICOMMON_API LIBRARY_MANAGER_ADAPTER
{
public:
    LIBRARY_MANAGER_ADAPTER( LIBRARY_MANAGER& aManager );
 
    virtual ~LIBRARY_MANAGER_ADAPTER();
 
    LIBRARY_MANAGER& Manager() const;

    virtual LIBRARY_TABLE_TYPE Type() const = 0;

    LIBRARY_TABLE* GlobalTable() const;

    std::optional<LIBRARY_TABLE*> ProjectTable() const;
 
    std::optional<wxString> FindLibraryByURI( const wxString& aURI ) const;

    std::vector<wxString> GetLibraryNames() const;

    bool HasLibrary( const wxString& aNickname, bool aCheckEnabled = false ) const;

    bool DeleteLibrary( const wxString& aNickname );
 
    std::optional<wxString> GetLibraryDescription( const wxString& aNickname ) const;

    std::vector<LIBRARY_TABLE_ROW*> Rows( LIBRARY_TABLE_SCOPE aScope = LIBRARY_TABLE_SCOPE::BOTH,
                                          bool                aIncludeInvalid = false ) const;

    std::optional<LIBRARY_TABLE_ROW*> GetRow( const wxString&     aNickname,
                                              LIBRARY_TABLE_SCOPE aScope = LIBRARY_TABLE_SCOPE::BOTH ) const;

    std::optional<LIBRARY_TABLE_ROW*> FindRowByURI( const wxString&     aUri,
                                                    LIBRARY_TABLE_SCOPE aScope = LIBRARY_TABLE_SCOPE::BOTH ) const;

    virtual void ProjectChanged();

    void GlobalTablesChanged( std::initializer_list<LIBRARY_TABLE_TYPE> aChangedTables = {} );

    virtual void AsyncLoad() = 0;

    std::optional<float> AsyncLoadProgress() const;
 
    void BlockUntilLoaded();
 
    bool IsLibraryLoaded( const wxString& aNickname );

    virtual bool IsWritable( const wxString& aNickname ) const { return false; }
 
    virtual bool SupportsConfigurationDialog( const wxString& aNickname ) const { return false; }
 
    virtual void ShowConfigurationDialog( const wxString& aNickname, wxWindow* aParent ) const {};
 
protected:
    virtual std::map<wxString, LIB_DATA>& globalLibs() = 0;
    virtual std::map<wxString, LIB_DATA>& globalLibs() const = 0;
    virtual std::mutex&                   globalLibsMutex() = 0;
 
    static wxString getUri( const LIBRARY_TABLE_ROW* aRow );
 
    std::optional<const LIB_DATA*> fetchIfLoaded( const wxString& aNickname ) const;
 
    std::optional<LIB_DATA*> fetchIfLoaded( const wxString& aNickname );

    LIBRARY_RESULT<LIB_DATA*> loadIfNeeded( const wxString& aNickname );

    void abortLoad();

    virtual LIBRARY_RESULT<IO_BASE*> createPlugin( const LIBRARY_TABLE_ROW* row ) = 0;
 
    LIBRARY_MANAGER& m_manager;
 
    // The actual library content is held in an associated IO plugin
    // TODO(JE) should this be an expected<LIB_ROW> so we can store the
    // error result if a lib can't be loaded instead of retrying the load every time
    // content is requested?
    std::map<wxString, LIB_DATA> m_libraries;
 
    std::mutex m_libraries_mutex;
 
    std::atomic_bool               m_abort;
    std::vector<std::future<void>> m_futures;
 
    std::atomic<size_t> m_loadCount;
    size_t              m_loadTotal;
};
 
 
class KICOMMON_API LIBRARY_MANAGER
{
public:
    LIBRARY_MANAGER();
 
    ~LIBRARY_MANAGER();
 
    LIBRARY_MANAGER( const LIBRARY_MANAGER& ) = delete;
    LIBRARY_MANAGER& operator=( const LIBRARY_MANAGER& ) = delete;
 
    static wxString DefaultGlobalTablePath( LIBRARY_TABLE_TYPE aType );
 
    static bool IsTableValid( const wxString& aPath );

    static bool GlobalTablesValid();

    static std::vector<LIBRARY_TABLE_TYPE> InvalidGlobalTables();
 
    static bool CreateGlobalTable( LIBRARY_TABLE_TYPE aType, bool aPopulateDefaultLibraries );

    void LoadGlobalTables( std::initializer_list<LIBRARY_TABLE_TYPE> aTablesToLoad = {} );

    void ProjectChanged();
 
    void RegisterAdapter( LIBRARY_TABLE_TYPE aType,
                          std::unique_ptr<LIBRARY_MANAGER_ADAPTER>&& aAdapter );
 
    std::optional<LIBRARY_MANAGER_ADAPTER*> Adapter( LIBRARY_TABLE_TYPE aType ) const;

    std::optional<LIBRARY_TABLE*> Table( LIBRARY_TABLE_TYPE aType,
                                         LIBRARY_TABLE_SCOPE aScope );

    std::vector<LIBRARY_TABLE_ROW*> Rows( LIBRARY_TABLE_TYPE aType,
                                          LIBRARY_TABLE_SCOPE aScope = LIBRARY_TABLE_SCOPE::BOTH,
                                          bool aIncludeInvalid = false ) const;

    std::optional<LIBRARY_TABLE_ROW*> GetRow( LIBRARY_TABLE_TYPE aType,
                                               const wxString &aNickname,
                                               LIBRARY_TABLE_SCOPE aScope =
                                                       LIBRARY_TABLE_SCOPE::BOTH ) const;
 
    std::optional<LIBRARY_TABLE_ROW*> FindRowByURI( LIBRARY_TABLE_TYPE aType,
                                                    const wxString &aUri,
                                                    LIBRARY_TABLE_SCOPE aScope =
                                                            LIBRARY_TABLE_SCOPE::BOTH ) const;
 
    void LoadProjectTables( const wxString& aProjectPath );
 
    LIBRARY_RESULT<void> Save( LIBRARY_TABLE* aTable ) const;

    std::optional<wxString> GetFullURI( LIBRARY_TABLE_TYPE aType, const wxString& aNickname,
                                        bool aSubstituted = false ) const;
 
    static wxString GetFullURI( const LIBRARY_TABLE_ROW* aRow, bool aSubstituted = false );
 
    static wxString ExpandURI( const wxString& aShortURI, const PROJECT& aProject );
 
    static bool UrisAreEquivalent( const wxString& aURI1, const wxString& aURI2 );
 
private:
    void loadTables( const wxString& aTablePath, LIBRARY_TABLE_SCOPE aScope,
                     std::vector<LIBRARY_TABLE_TYPE> aTablesToLoad = {} );
 
    void loadNestedTables( LIBRARY_TABLE& aTable );
 
    static wxString tableFileName( LIBRARY_TABLE_TYPE aType );
 
    void createEmptyTable( LIBRARY_TABLE_TYPE aType, LIBRARY_TABLE_SCOPE aScope );
 
    std::map<LIBRARY_TABLE_TYPE, std::unique_ptr<LIBRARY_TABLE>> m_tables;

    std::map<wxString, std::unique_ptr<LIBRARY_TABLE>> m_childTables;
 
    // TODO: support multiple projects
    std::map<LIBRARY_TABLE_TYPE, std::unique_ptr<LIBRARY_TABLE>> m_projectTables;
 
    std::map<LIBRARY_TABLE_TYPE, std::unique_ptr<LIBRARY_MANAGER_ADAPTER>> m_adapters;
};
 
#endif //LIBRARY_MANAGER_H