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 <dick@softplc.com>
 * Copyright (C) 2012 Wayne Stambaugh <stambaughw@gmail.com>
 * Copyright (C) 2012-2021 KiCad Developers, see change_log.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/noncopyable.hpp>
#include <boost/ptr_container/ptr_vector.hpp>
#include <memory>
#include <mutex>
#include <project.h>
#include <properties.h>
#include <richio.h>


#define FP_LATE_ENVVAR  1           

class OUTPUTFORMATTER;
class LIB_TABLE_LEXER;
class LIB_ID;
class LIB_TABLE_ROW;
class LIB_TABLE_GRID;
class IO_ERROR;


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;


LIB_TABLE_ROW* new_clone( const LIB_TABLE_ROW& aRow );


class LIB_TABLE_ROW : boost::noncopyable
{
public:
    LIB_TABLE_ROW() :
        enabled( true ),
        m_loaded( false )
    {
    }

    virtual ~LIB_TABLE_ROW()
    {
    }

    LIB_TABLE_ROW( const wxString& aNick, const wxString& aURI, const wxString& aOptions,
                   const wxString& aDescr = wxEmptyString ) :
        nickName( aNick ),
        description( aDescr ),
        enabled( true ),
        m_loaded( false )
    {
        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; }

    virtual const wxString GetType() const = 0;

    virtual void SetType( const wxString& aType ) = 0;

    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; }

    const PROPERTIES* 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 ),
#if !FP_LATE_ENVVAR
        uri_expanded( aRow.uri_expanded ),
#endif
        options( aRow.options ),
        description( aRow.description ),
        enabled( aRow.enabled ),
        m_loaded( aRow.m_loaded )
    {
        if( aRow.properties )
            properties = std::make_unique<PROPERTIES>( *aRow.properties.get() );
        else
            properties.reset();
    }

    void operator=( const LIB_TABLE_ROW& aRow );

private:
    virtual LIB_TABLE_ROW* do_clone() const = 0;

    void setProperties( PROPERTIES* aProperties );

    wxString          nickName;
    wxString          uri_user;           

#if !FP_LATE_ENVVAR
    wxString          uri_expanded;       
#endif

    wxString          options;
    wxString          description;

    bool              enabled  = true;    
    bool              m_loaded = false;   

    std::unique_ptr< PROPERTIES > properties;
};


class 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 );

    virtual ~LIB_TABLE();

    void Clear()
    {
        std::lock_guard<std::recursive_mutex> lock( m_nickIndexMutex );

        rows.clear();
        nickIndex.clear();
    }

    bool operator==( const LIB_TABLE& r ) const
    {
        if( rows.size() == r.rows.size() )
        {
            unsigned i;

            for( i = 0; i < rows.size() && rows[i] == r.rows[i];  ++i )
                ;

            if( i == rows.size() )
                return true;
        }

        return false;
    }

    bool operator!=( const LIB_TABLE& r ) const  { return !( *this == r ); }

    unsigned GetCount() const
    {
        return rows.size();
    }

    LIB_TABLE_ROW& At( unsigned aIndex )
    {
        return rows[aIndex];
    }

    const LIB_TABLE_ROW& At( unsigned aIndex ) const
    {
        return rows[aIndex];
    }

    bool IsEmpty( bool aIncludeFallback = true );

    const wxString GetDescription( const wxString& aNickname );

    bool HasLibrary( const wxString& aNickname, bool aCheckEnabled = false ) 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( LIB_TABLE_ROW* aRow )
    {
        for( auto iter = rows.begin(); iter != rows.end(); ++iter )
        {
            if( *iter == *aRow )
            {
                rows.erase( iter, iter + 1 );
                return true;
            }
        }
        return false;
    }

    const LIB_TABLE_ROW* FindRowByURI( const wxString& aURI );

    void Load( const wxString& aFileName );

    void Save( const wxString& aFileName ) const;

    static PROPERTIES* ParseOptions( const std::string& aOptionsList );

    static UTF8 FormatOptions( const PROPERTIES* aProperties );

protected:
    LIB_TABLE_ROW* findRow( const wxString& aNickname, bool aCheckIfEnabled = false ) const;

    void reindex()
    {
        std::lock_guard<std::recursive_mutex> lock( m_nickIndexMutex );

        nickIndex.clear();

        for( LIB_TABLE_ROWS_ITER it = rows.begin(); it != rows.end(); ++it )
            nickIndex.insert( INDEX_VALUE( it->GetNickName(), it - rows.begin() ) );
    }

    void ensureIndex()
    {
        std::lock_guard<std::recursive_mutex> lock( m_nickIndexMutex );

        // The dialog lib table editor may not maintain the nickIndex.
        // Lazy indexing may be required.  To handle lazy indexing, we must enforce
        // that "nickIndex" is either empty or accurate, but never inaccurate.
        if( !nickIndex.size() )
            reindex();
    }

private:
    friend class PANEL_FP_LIB_TABLE;
    friend class LIB_TABLE_GRID;

protected:
    LIB_TABLE_ROWS rows;

    typedef std::map<wxString,int>      INDEX;              // "int" is std::vector array index
    typedef INDEX::iterator             INDEX_ITER;
    typedef INDEX::const_iterator       INDEX_CITER;
    typedef INDEX::value_type           INDEX_VALUE;

    INDEX nickIndex;

    LIB_TABLE* fallBack;

    mutable std::recursive_mutex m_nickIndexMutex;
};

#endif  // _LIB_TABLE_BASE_H_