lib_table_base.h

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright (C) 2010-2012 SoftPLC Corporation, Dick Hollenbeck <[email protected]>
 * Copyright (C) 2012 Wayne Stambaugh <[email protected]>
 * Copyright The KiCad Developers, see AUTHORS.txt for contributors.
 *
 * 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 2
 * 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, you may find one here:
 * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
 * or you may search the http://www.gnu.org website for the version 2 license,
 * or you may write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
 */
 
#ifndef _LIB_TABLE_BASE_H_
#define _LIB_TABLE_BASE_H_
 
#include <map>
#include <boost/ptr_container/ptr_vector.hpp>
#include <memory>
#include <mutex>
#include <shared_mutex>
#include <project.h>
#include <richio.h>
#include <kicommon.h>
 
class OUTPUTFORMATTER;
class LIB_TABLE_LEXER;
class LIB_ID;
class LIB_TABLE_ROW;
class LIB_TABLE_GRID;
class LIB_TABLE;
class IO_ERROR;
class wxWindow;
 
 
typedef boost::ptr_vector< LIB_TABLE_ROW > LIB_TABLE_ROWS;
typedef LIB_TABLE_ROWS::iterator           LIB_TABLE_ROWS_ITER;
typedef LIB_TABLE_ROWS::const_iterator     LIB_TABLE_ROWS_CITER;
 
 
KICOMMON_API LIB_TABLE_ROW* new_clone( const LIB_TABLE_ROW& aRow );
 
 
class KICOMMON_API LIB_TABLE_IO
{
public:
    virtual ~LIB_TABLE_IO() = default;
 
    virtual std::unique_ptr<LINE_READER> GetReader( const wxString& aURI ) const = 0;
 
    virtual bool CanSaveToUri( const wxString& aURI ) const = 0;
 
    virtual bool UrisAreEquivalent( const wxString& aURI1, const wxString& aURI2 ) const = 0;
 
    virtual std::unique_ptr<OUTPUTFORMATTER> GetWriter( const wxString& aURI ) const = 0;
};
 
 
class KICOMMON_API FILE_LIB_TABLE_IO : public LIB_TABLE_IO
{
public:
    FILE_LIB_TABLE_IO() = default;
 
    std::unique_ptr<LINE_READER> GetReader( const wxString& aURI ) const override;
 
    bool CanSaveToUri( const wxString& aURI ) const override;
 
    bool UrisAreEquivalent( const wxString& aURI1, const wxString& aURI2 ) const override;
 
    std::unique_ptr<OUTPUTFORMATTER> GetWriter( const wxString& aURI ) const override;
};
 
 
class KICOMMON_API LIB_TABLE_ROW
{
public:
    LIB_TABLE_ROW() :
        enabled( true ),
        visible( true ),
        m_loaded( false ),
        m_parent( nullptr )
    {
    }
 
    virtual ~LIB_TABLE_ROW()
    {
    }
 
    LIB_TABLE_ROW( const wxString& aNick, const wxString& aURI, const wxString& aOptions,
                   const wxString& aDescr = wxEmptyString, LIB_TABLE* aParent = nullptr ) :
        nickName( aNick ),
        description( aDescr ),
        enabled( true ),
        visible( true ),
        m_loaded( false ),
        m_parent( aParent )
    {
        properties.reset();
        SetOptions( aOptions );
        SetFullURI( aURI );
    }
 
    bool operator==( const LIB_TABLE_ROW& r ) const;
 
    bool operator!=( const LIB_TABLE_ROW& r ) const { return !( *this == r ); }
 
    const wxString& GetNickName() const { return nickName; }
 
    void SetNickName( const wxString& aNickName ) { nickName = aNickName; }
 
    bool GetIsLoaded() const { return m_loaded; }
 
    void SetLoaded( bool aLoaded ) { m_loaded = aLoaded; };
 
    bool GetIsEnabled() const { return enabled; }
 
    void SetEnabled( bool aEnabled = true ) { enabled = aEnabled; }
 
    bool GetIsVisible() const { return visible; }
 
    void SetVisible( bool aVisible = true ) { visible = aVisible; }
 
    virtual bool Refresh() { return false; }
 
    virtual const wxString GetType() const = 0;
 
    virtual void SetType( const wxString& aType ) = 0;
 
    virtual bool SupportsSettingsDialog() const { return false; }
 
    virtual void ShowSettingsDialog( wxWindow* aParent ) const {}
 
    const wxString GetFullURI( bool aSubstituted = false ) const;
 
    void SetFullURI( const wxString& aFullURI );
 
    const wxString& GetOptions() const          { return options; }
 
    void SetOptions( const wxString& aOptions );
 
    const wxString& GetDescr() const            { return description; }
 
    void SetDescr( const wxString& aDescr )     { description = aDescr; }
 
    LIB_TABLE* GetParent() const { return m_parent; }
 
    void SetParent( LIB_TABLE* aParent ) { m_parent = aParent; }
 
    std::mutex& GetMutex() { return m_loadMutex; }
 
    const std::map<std::string, UTF8>* GetProperties() const     { return properties.get(); }
 
    void Format( OUTPUTFORMATTER* out, int nestLevel ) const;
 
    LIB_TABLE_ROW* clone() const
    {
        return do_clone();
    }
 
protected:
    LIB_TABLE_ROW( const LIB_TABLE_ROW& aRow ) :
        nickName( aRow.nickName ),
        uri_user( aRow.uri_user ),
        options( aRow.options ),
        description( aRow.description ),
        enabled( aRow.enabled ),
        visible( aRow.visible ),
        m_loaded( aRow.m_loaded ),
        m_parent( aRow.m_parent )
    {
        if( aRow.properties )
            properties = std::make_unique<std::map<std::string, UTF8>>( *aRow.properties.get() );
        else
            properties.reset();
    }
 
    void operator=( const LIB_TABLE_ROW& aRow );
 
private:
    virtual LIB_TABLE_ROW* do_clone() const = 0;
 
    void setProperties( std::map<std::string, UTF8>* aProperties );
 
    wxString          nickName;
    wxString          uri_user;           
    wxString          options;
    wxString          description;
 
    bool              enabled  = true;    
    bool              visible  = true;    
    bool              m_loaded = false;   
    LIB_TABLE*        m_parent;           
 
    std::unique_ptr<std::map<std::string, UTF8>> properties;
 
    std::mutex        m_loadMutex;
};
 
 
class KICOMMON_API LIB_TABLE : public PROJECT::_ELEM
{
public:
    virtual void Parse( LIB_TABLE_LEXER* aLexer ) = 0;
 
    virtual void Format( OUTPUTFORMATTER* aOutput, int aIndentLevel ) const = 0;
 
    LIB_TABLE( LIB_TABLE*                    aFallBackTable = nullptr,
               std::unique_ptr<LIB_TABLE_IO> aTableIo = nullptr );
 
    virtual ~LIB_TABLE();
 
    bool operator==( const LIB_TABLE& r ) const
    {
        if( m_rows.size() == r.m_rows.size() )
        {
            unsigned i;
 
            for( i = 0; i < m_rows.size() && m_rows[i] == r.m_rows[i];  ++i )
                ;
 
            if( i == m_rows.size() )
                return true;
        }
 
        return false;
    }
 
    bool operator!=( const LIB_TABLE& r ) const  { return !( *this == r ); }
 
    unsigned GetCount() const
    {
        return m_rows.size();
    }
 
    LIB_TABLE_ROW& At( unsigned aIndex )
    {
        return m_rows[aIndex];
    }
 
    const LIB_TABLE_ROW& At( unsigned aIndex ) const
    {
        return m_rows[aIndex];
    }
 
    bool IsEmpty( bool aIncludeFallback = true );
 
    const wxString GetDescription( const wxString& aNickname );
 
    bool HasLibrary( const wxString& aNickname, bool aCheckEnabled = false ) const;
 
    bool HasLibraryWithPath( const wxString& aPath ) const;
 
    std::vector<wxString> GetLogicalLibs();
 
    wxString GetFullURI( const wxString& aLibNickname, bool aExpandEnvVars = true ) const;
 
    bool InsertRow( LIB_TABLE_ROW* aRow, bool doReplace = false );
 
    bool RemoveRow( const LIB_TABLE_ROW* aRow );
 
    bool ReplaceRow( size_t aIndex, LIB_TABLE_ROW* aRow );
 
    bool ChangeRowOrder( size_t aIndex, int aOffset );
 
    void TransferRows( LIB_TABLE_ROWS& aRowsList );
 
    const LIB_TABLE_ROW* FindRowByURI( const wxString& aURI );
 
    void Load( const wxString& aFileName );
 
    void Save( const wxString& aFileName ) const;
 
    static std::map<std::string, UTF8>* ParseOptions( const std::string& aOptionsList );
 
    static UTF8 FormatOptions( const std::map<std::string, UTF8>* aProperties );
 
    int GetVersion() const
    {
        return m_version;
    }
 
protected:
    /*
     * Do not make this public.  It MUST be called with a lock already in place.
     */
    void clear();
 
    LIB_TABLE_ROW* findRow( const wxString& aNickname, bool aCheckIfEnabled = false ) const;
 
    bool doInsertRow( LIB_TABLE_ROW* aRow, bool doReplace = false );
 
    bool migrate();
 
    /*
     * Do not make this public.  It MUST be called with a lock already in place.
     */
    void reindex();
 
protected:
    // Injected I/O interface
    std::unique_ptr<LIB_TABLE_IO> m_io;
 
    LIB_TABLE* m_fallBack;
 
    mutable int m_version;
 
    // TODO: This should really be private; but the lib table grids re-use it
    //       (without using m_rowsMap).
    LIB_TABLE_ROWS m_rows;
 
    std::map<wxString, LIB_TABLE_ROWS_ITER> m_rowsMap;
 
    mutable std::shared_mutex m_mutex;
};
 
#endif  // _LIB_TABLE_BASE_H_