/* * This program source code file is part of KiCad, a free EDA CAD application. * * Copyright (C) 2010-12 SoftPLC Corporation, Dick Hollenbeck * Copyright (C) 2012 Wayne Stambaugh * Copyright (C) 2012 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 FP_LIB_TABLE_H_ #define FP_LIB_TABLE_H_ #include #include #include //#include #include class OUTPUTFORMATTER; class MODULE; class FP_LIB_TABLE_LEXER; /** * Class FP_LIB_TABLE * holds FP_LIB_TABLE::ROW records (rows), and can be searched based on library nickName. *

* This class owns the footprint library table, which is like fstab in concept and maps * logical library name to the library URI, type, and options. It is heavily based on the SWEET * parser work done by Dick Hollenbeck and can be seen in new/sch_lib_table.h. A footprint * library table had the following columns: *

    *
  • Logical Library Name (Nickname) *
  • Library Type, used to determine which plugin to load to access the library. *
  • Library URI. The full URI to the library source, form dependent on Type. *
  • Options, used for as yet to be defined information such as user names or passwords *
*

* The Library Type can be one of: *

    *
  • "file" *
  • "ftp" *
  • "http" *
*

* For now, the Library URI types needed to support the various types can be one of those * shown below, which are typical of each type: *

    *
  • "file://C:/mylibdir" *
  • "ftp://kicad.org/partlib/trunk" *
  • "http://kicad.org/partlib" *
*

* The footprint library table is built up from several additive entries (table fragments), * and the final table is a (conceptual) merging of the table fragments. Two * anticipated sources of the entries are a personal table saved in the KiCad configuration * and a project resident table that resides in project file. The project footprint table * entries are considered a higher priority in the final dynamically assembled library table. * An row in the project file contribution to the library table takes precedence over the * personal table if there is a collision of logical library names. Otherwise, the entries * simply combine without issue to make up the applicable library table. * * @author Wayne Stambaugh */ class FP_LIB_TABLE { friend class DIALOG_FP_LIB_TABLE; public: /** * Class ROW * holds a record identifying a footprint library accessed by the appropriate #PLUGIN * object in the #FP_LIB_TABLE. */ class ROW { friend class FP_LIB_TABLE; friend class DIALOG_FP_LIB_TABLE; public: typedef IO_MGR::PCB_FILE_T LIB_T; ROW() : type( IO_MGR::KICAD ) { } ROW( const wxString& aNick, const wxString& aURI, const wxString& aType, const wxString& aOptions, const wxString& aDescr = wxEmptyString ) : nickName( aNick ), uri( aURI ), options( aOptions ), description( aDescr ) { SetType( aType ); } bool operator==( const ROW& r ) const { return nickName==r.nickName && uri==r.uri && type==r.type && options==r.options; } bool operator!=( const ROW& r ) const { return !( *this == r ); } //----------------------------------------------------------- /** * Function GetNickName * returns the short name of this library table row. */ const wxString& GetNickName() const { return nickName; } /** * Function SetNickName * changes the logical name of this library, useful for an editor. */ void SetNickName( const wxString& aNickName ) { nickName = aNickName; } /** * Function GetType * returns the type of LIB represented by this row. */ const wxString GetType() const { return IO_MGR::ShowType( type ); } /** * Function SetType * changes the type represented by this row. */ void SetType( const wxString& aType ) { type = IO_MGR::EnumFromStr( aType ); } /** * Function GetFullURI * returns the full location specifying URI for the LIB. */ const wxString& GetFullURI() const { return uri; } /** * Function SetFullURI * changes the full URI for the library. */ void SetFullURI( const wxString& aFullURI ) { uri = aFullURI; } /** * Function GetOptions * returns the options string, which may hold a password or anything else needed to * instantiate the underlying LIB_SOURCE. */ const wxString& GetOptions() const { return options; } /** * Function SetOptions */ void SetOptions( const wxString& aOptions ) { options = aOptions; } /** * Function GetDescr * returns the description of the library referenced by this row. */ const wxString& GetDescr() const { return description; } /** * Function SetDescr * changes the description of the library referenced by this row. */ void SetDescr( const wxString& aDescr ) { description = aDescr; } //---------------------------------------------------------- /** * Function Format * serializes this object as utf8 text to an OUTPUTFORMATTER, and tries to * make it look good using multiple lines and indentation. * @param out is an #OUTPUTFORMATTER * @param nestLevel is the indentation level to base all lines of the output. * Actual indentation will be 2 spaces for each nestLevel. */ void Format( OUTPUTFORMATTER* out, int nestLevel ) const throw( IO_ERROR ); private: wxString nickName; wxString uri; LIB_T type; wxString options; wxString description; }; /** * Constructor FP_LIB_TABLE * builds a library table by pre-pending this table fragment in front of * @a aFallBackTable. Loading of this table fragment is done by using Parse(). * * @param aFallBackTable is another FP_LIB_TABLE which is searched only when * a row is not found in this table. No ownership is * taken of aFallBackTable. */ FP_LIB_TABLE( FP_LIB_TABLE* aFallBackTable = NULL ); bool operator==( const FP_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 FP_LIB_TABLE& r ) const { return !( *this == r ); } /** * Function Parse * fills this table fragment from information in the input stream \a aParser, which * is a DSNLEXER customized for the grammar needed to describe instances of this object. * The entire textual element spec is
* * 

     * (fp_lib_table
     *   (lib (name LOGICAL)(descr DESCRIPTION)(uri FULL_URI)(type TYPE)(options OPTIONS))
     *   (lib (name LOGICAL)(descr DESCRIPTION)(uri FULL_URI)(type TYPE)(options OPTIONS))
     *   (lib (name LOGICAL)(descr DESCRIPTION)(uri FULL_URI)(type TYPE)(options OPTIONS))
     *  )
     *
* * When this function is called, the input token stream given by \a aParser * is assumed to be positioned at the '^' in the following example, i.e. just * after the identifying keyword and before the content specifying stuff. *
* (lib_table ^ (....) ) * * @param aParser is the input token stream of keywords and symbols. */ void Parse( FP_LIB_TABLE_LEXER* aParser ) throw( IO_ERROR, PARSE_ERROR ); /** * Function Format * serializes this object as utf8 text to an #OUTPUTFORMATTER, and tries to * make it look good using multiple lines and indentation. * * @param out is an #OUTPUTFORMATTER * @param nestLevel is the indentation level to base all lines of the output. * Actual indentation will be 2 spaces for each nestLevel. */ void Format( OUTPUTFORMATTER* out, int nestLevel ) const throw( IO_ERROR ); /** * Function GetLogicalLibs * returns the logical library names, all of them that are pertinent to * a lookup done on this FP_LIB_TABLE. */ std::vector GetLogicalLibs(); //-------------------------------------------------------- // the returning of a const wxString* tells if not found, but might be too // promiscuous? #if 0 /** * Function GetURI * returns the full library path from a logical library name. * @param aLogicalLibraryName is the short name for the library of interest. * @return const wxString* - or NULL if not found. */ const wxString* GetURI( const wxString& aLogicalLibraryName ) const { const ROW* row = FindRow( aLogicalLibraryName ); return row ? &row->uri : 0; } /** * Function GetType * returns the type of a logical library. * @param aLogicalLibraryName is the short name for the library of interest. * @return const wxString* - or NULL if not found. */ const wxString* GetType( const wxString& aLogicalLibraryName ) const { const ROW* row = FindRow( aLogicalLibraryName ); return row ? &row->type : 0; } /** * Function GetLibOptions * returns the options string for \a aLogicalLibraryName. * @param aLogicalLibraryName is the short name for the library of interest. * @return const wxString* - or NULL if not found. */ const wxString* GetLibOptions( const wxString& aLogicalLibraryName ) const { const ROW* row = FindRow( aLogicalLibraryName ); return row ? &row->options : 0; } #endif //------------------------------------------------------- #if 1 || defined(DEBUG) /// implement the tests in here so we can honor the privilege levels of the /// accessors, something difficult to do from int main(int, char**) void Test(); #endif /** * Function InsertRow * adds aRow if it does not already exist or if doReplace is true. If doReplace * is not true and the key for aRow already exists, the function fails and returns false. * The key for the table is the nickName, and all in this table must be unique. * @param aRow is the new row to insert, or to forcibly add if doReplace is true. * @param doReplace if true, means insert regardless of whether aRow's key already * exists. If false, then fail if the key already exists. * @return bool - true if the operation succeeded. */ bool InsertRow( const ROW& aRow, bool doReplace = false ); /** * Function PluginFind * returns a PLUGIN*. Caller should wrap that in a PLUGIN::RELEASER() * so when it goes out of scope, IO_MGR::PluginRelease() is called. */ PLUGIN* PluginFind( const wxString& aLibraryNickName ) throw( IO_ERROR ); /** * Function FindRow * returns a ROW if aNickName is found in this table or in any chained * fallBack table fragment, else NULL. */ const ROW* FindRow( const wxString& aNickName ) throw( IO_ERROR ); /** * Function IsEmpty * @return true if the footprint library table is empty. */ bool IsEmpty() const; /** * Function ExpandEnvSubsitutions * replaces any environment variable references with their values and is * here to fully embellish the ROW::uri in a platform independent way. * This enables (fp_lib_table)s to have platform dependent environment * variables in them, allowing for a uniform table across platforms. */ static const wxString ExpandSubstitutions( const wxString aString ); /** * Function LoadGlobalTable * loads the global footprint library table into \a aTable. * * This probably should be move into the application object when KiCad is changed * to a single process application. This is the least painful solution for the * time being. * * @param aTable the #FP_LIB_TABLE object to load. */ static void LoadGlobalTable( FP_LIB_TABLE& aTable ) throw (IO_ERROR, PARSE_ERROR ); /** * Function GetGlobalTableFileName * @return the platform specific global footprint library path and file name. */ static wxString GetGlobalTableFileName(); /** * Function GetFootprintTableFileName * @return the footprint library file name. */ static wxString GetFileName(); protected: /** * Function findRow * returns a ROW if aNickName is found in this table or in any chained * fallBack table fragment, else NULL. */ const ROW* findRow( const wxString& aNickName ); void reindex() { nickIndex.clear(); for( ROWS_CITER it = rows.begin(); it != rows.end(); ++it ) nickIndex.insert( INDEX_VALUE( it->nickName, it - 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( !nickIndex.size() ) reindex(); } typedef std::vector ROWS; typedef ROWS::iterator ROWS_ITER; typedef ROWS::const_iterator ROWS_CITER; ROWS rows; /// this is a non-owning index into the ROWS table typedef std::map INDEX; // "int" is std::vector array index typedef INDEX::iterator INDEX_ITER; typedef INDEX::const_iterator INDEX_CITER; typedef INDEX::value_type INDEX_VALUE; /// this particular key is the nickName within each row. INDEX nickIndex; FP_LIB_TABLE* fallBack; }; #if 0 // I don't think this is going to be needed. /** * Function LookupPart * finds and loads a MODULE, and parses it. As long as the part is * accessible in any LIB_SOURCE, opened or not opened, this function * will find it and load it into its containing LIB, even if that means * having to open a LIB in this table that was not previously opened. * * @param aFootprintId The fully qualified name of the footprint to look up. * * @return MODULE* - this will never be NULL, and no ownership is transferred because * all MODULEs live in LIBs. You only get to point to them in some LIB. If the MODULE * cannot be found, then an exception is thrown. * * @throw IO_ERROR if any problem occurs or if the footprint cannot be found. */ MODULE* LookupFootprint( const FP_LIB_ID& aFootprintId ) throw( IO_ERROR ); #endif #endif // FP_LIB_TABLE_H_