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 <shared_mutex>
#include <project.h>
#include <string_utf8_map.h>
#include <richio.h>
 
class OUTPUTFORMATTER;
class LIB_TABLE_LEXER;
class LIB_ID;
class LIB_TABLE_ROW;
class LIB_TABLE_GRID;
class LIB_TABLE;
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 ),
 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 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; }
 
 LIB_TABLE* GetParent() const { return m_parent; }
 
 void SetParent( LIB_TABLE* aParent ) { m_parent = aParent; }
 
 std::mutex& GetMutex() { return m_loadMutex; }
 
 const STRING_UTF8_MAP* 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<STRING_UTF8_MAP>( *aRow.properties.get() );
 else
 properties.reset();
 }
 
 void operator=( const LIB_TABLE_ROW& aRow );
 
private:
 virtual LIB_TABLE_ROW* do_clone() const = 0;
 
 void setProperties( STRING_UTF8_MAP* 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<STRING_UTF8_MAP> properties;
 
 std::mutex m_loadMutex;
};
 
 
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::shared_mutex> lock( m_nickIndexMutex );
 
 m_rows.clear();
 m_nickIndex.clear();
 }
 
 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 )
 {
 for( auto iter = m_rows.begin(); iter != m_rows.end(); ++iter )
 {
 if( *iter == *aRow )
 {
 m_rows.erase( iter, iter + 1 );
 reindex( true );
 return true;
 }
 }
 return false;
 }
 
 const LIB_TABLE_ROW* FindRowByURI( const wxString& aURI );
 
 void Load( const wxString& aFileName );
 
 void Save( const wxString& aFileName ) const;
 
 static STRING_UTF8_MAP* ParseOptions( const std::string& aOptionsList );
 
 static UTF8 FormatOptions( const STRING_UTF8_MAP* aProperties );
 
 int GetVersion() const
 {
 return m_version;
 }
 
protected:
 LIB_TABLE_ROW* findRow( const wxString& aNickname, bool aCheckIfEnabled = false ) const;
 
 bool migrate();
 
 void reindex( bool aForce )
 {
 std::lock_guard<std::shared_mutex> lock( m_nickIndexMutex );
 
 if( !aForce )
 {
 if( m_nickIndex.size() )
 return;
 }
 
 m_nickIndex.clear();
 
 for( LIB_TABLE_ROWS_ITER it = m_rows.begin(); it != m_rows.end(); ++it )
 m_nickIndex.insert( INDEX_VALUE( it->GetNickName(), it - m_rows.begin() ) );
 }
 
 void ensureIndex()
 {
 // 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( !m_nickIndex.size() )
 reindex( false );
 }
 
private:
 friend class PANEL_FP_LIB_TABLE;
 friend class LIB_TABLE_GRID;
 
protected:
 LIB_TABLE_ROWS m_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 m_nickIndex;
 
 LIB_TABLE* m_fallBack;
 
 mutable int m_version;
 
 mutable std::shared_mutex m_nickIndexMutex;
};
 
#endif // _LIB_TABLE_BASE_H_