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 (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_