symbol_library_adapter.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 <https://www.gnu.org/licenses/>.
 */
 
 
#ifndef SYMBOL_LIBRARY_MANAGER_ADAPTER_H
#define SYMBOL_LIBRARY_MANAGER_ADAPTER_H
 
#include <future>
#include <memory>
#include <optional>
#include <lib_id.h>
#include <core/leak_at_exit.h>
#include <libraries/library_manager.h>
#include <sch_io/sch_io.h>
 
class LIB_SYMBOL;
class PROJECT;
 

struct SUB_LIBRARY
{
    wxString nickname;
    wxString description;
};
 

class SYMBOL_LIBRARY_ADAPTER : public LIBRARY_MANAGER_ADAPTER
{
public:
    static const char* PropPowerSymsOnly;
    static const char* PropNonPowerSymsOnly;
 
public:
    SYMBOL_LIBRARY_ADAPTER( LIBRARY_MANAGER& aManager );
 
    ~SYMBOL_LIBRARY_ADAPTER() override;
 
    LIBRARY_TABLE_TYPE Type() const override { return LIBRARY_TABLE_TYPE::SYMBOL; }
 
    static wxString GlobalPathEnvVariableName();

    std::optional<LIB_STATUS> LoadOne( LIB_DATA* aLib ) override;
 
    std::optional<LIB_STATUS> CheckLibrary( LIB_DATA* aLib ) override;

    std::optional<LIB_STATUS> LoadOne( const wxString& aNickname );

    std::vector<wxString> GetAvailableExtraFields( const wxString& aNickname );
 
    bool SupportsSubLibraries( const wxString& aNickname ) const;
 
    std::vector<SUB_LIBRARY> GetSubLibraries( const wxString& aNickname ) const;
 
    bool SupportsConfigurationDialog( const wxString& aNickname ) const override;
 
    int ShowConfigurationDialog( const wxString& aNickname, wxWindow* aParent ) const override;
 
    enum class SYMBOL_TYPE
    {
        ALL_SYMBOLS,
        POWER_ONLY
    };
 
    std::vector<LIB_SYMBOL*> GetSymbols( const wxString& aNickname,
                                         SYMBOL_TYPE aType = SYMBOL_TYPE::ALL_SYMBOLS );
 
    std::vector<wxString> GetSymbolNames( const wxString& aNickname,
                                          SYMBOL_TYPE aType = SYMBOL_TYPE::ALL_SYMBOLS );

    LIB_SYMBOL* LoadSymbol( const wxString& aNickname, const wxString& aName );
 
    LIB_SYMBOL* LoadSymbol( const LIB_ID& aLibId )
    {
        return LoadSymbol( aLibId.GetLibNickname(), aLibId.GetLibItemName() );
    }

    enum SAVE_T
    {
        SAVE_OK,
        SAVE_SKIPPED,
    };

    SAVE_T SaveSymbol( const wxString& aNickname, std::unique_ptr<LIB_SYMBOL> aSymbol,
                       bool aOverwrite = true );

    void DeleteSymbol( const wxString& aNickname, const wxString& aSymbolName );

    bool IsSymbolLibWritable( const wxString& aNickname );
 
    int GetModifyHash() const;

    std::optional<int> GetLibraryModifyHash( const wxString& aNickname ) const;
 
protected:
    std::map<wxString, LIB_DATA>& globalLibs() override
    {
        return m_manager.IsProjectScoped() ? m_scopedGlobalLibraries : GlobalLibraries.Get();
    }
 
    std::map<wxString, LIB_DATA>& globalLibs() const override
    {
        return m_manager.IsProjectScoped() ? m_scopedGlobalLibraries : GlobalLibraries.Get();
    }
 
    std::shared_mutex& globalLibsMutex() override
    {
        return m_manager.IsProjectScoped() ? m_scopedGlobalLibraryMutex : GlobalLibraryMutex.Get();
    }
 
    std::shared_mutex& globalLibsMutex() const override
    {
        return m_manager.IsProjectScoped() ? m_scopedGlobalLibraryMutex : GlobalLibraryMutex.Get();
    }
 
    void enumerateLibrary( LIB_DATA* aLib, const wxString& aUri ) override;
 
    LIBRARY_RESULT<IO_BASE*> createPlugin( const LIBRARY_TABLE_ROW* row ) override;
 
    IO_BASE* plugin( const LIB_DATA* aRow ) override { return schplugin( aRow ); }
 
private:
    static SCH_IO* schplugin( const LIB_DATA* aRow );
 
    // Global rows can contain project variables, so passive loads cannot share their plugins.
    mutable std::map<wxString, LIB_DATA> m_scopedGlobalLibraries;
    mutable std::shared_mutex m_scopedGlobalLibraryMutex;
 
    static LEAK_AT_EXIT<std::map<wxString, LIB_DATA>> GlobalLibraries;
 
    // Leaked like GlobalLibraries so adapter destructors can still lock it to evict their entries
    // even when they run during static teardown.
    static LEAK_AT_EXIT<std::shared_mutex> GlobalLibraryMutex;
};
 
#endif //SYMBOL_LIBRARY_MANAGER_ADAPTER_H