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/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_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 );
 
 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:
 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_