sch_reference_list.h

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright (C) 1992-2011 jean-pierre Charras <[email protected]>
 * Copyright (C) 2011 Wayne Stambaugh <[email protected]>
 * Copyright The KiCad Developers, see AUTHORS.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 _SCH_REFERENCE_LIST_H_
#define _SCH_REFERENCE_LIST_H_
 
#include <map>
 
#include <lib_symbol.h>
#include <macros.h>
#include <sch_sheet_path.h>
#include <sch_symbol.h>
#include <sch_text.h>
#include <erc/erc_settings.h>
 
class REFDES_TRACKER;
 
enum ANNOTATE_SCOPE_T
{
    ANNOTATE_ALL,           
    ANNOTATE_CURRENT_SHEET, 
    ANNOTATE_SELECTION      
};
 
 
enum ANNOTATE_ORDER_T
{
    SORT_BY_X_POSITION, 
    SORT_BY_Y_POSITION, 
    UNSORTED,           
};
 
 
enum ANNOTATE_ALGO_T
{
    INCREMENTAL_BY_REF,  
    SHEET_NUMBER_X_100,  
    SHEET_NUMBER_X_1000, 
};
 
 
class SCH_REFERENCE
{
public:
    SCH_REFERENCE() :
            m_sheetPath()
    {
        m_rootSymbol      = nullptr;
        m_unit            = 0;
        m_isNew           = false;
        m_numRef          = 0;
        m_flag            = 0;
        m_sheetNum        = 0;
    }
 
    SCH_REFERENCE( SCH_SYMBOL* aSymbol, const SCH_SHEET_PATH& aSheetPath );
 
    SCH_SYMBOL* GetSymbol() const           { return m_rootSymbol; }
 
    LIB_SYMBOL* GetLibPart() const          { return m_rootSymbol->GetLibSymbolRef().get(); }
 
    const SCH_SHEET_PATH& GetSheetPath() const { return m_sheetPath; }
 
    SCH_SHEET_PATH& GetSheetPath()             { return m_sheetPath; }
 
    int GetUnit() const                        { return m_unit; }
    void SetUnit( int aUnit )                  { m_unit = aUnit; }
    bool IsMultiUnit() const                   { return GetLibPart()->GetUnitCount() > 1; }
 
    const wxString GetValue() const            { return m_value; }
    void SetValue( const wxString& aValue )    { m_value = aValue; }
 
    const wxString GetFootprint() const        { return m_footprint; }
    void SetFootprint( const wxString& aFP )   { m_footprint = aFP; }
 
    void SetSheetNumber( int aSheetNumber )    { m_sheetNum = aSheetNumber; }
 
    const wxString GetPath() const
    {
        return m_sheetPath.PathAsString();
    }
 
    const wxString GetFullPath() const
    {
        return m_sheetPath.PathAsString() + m_symbolUuid.AsString();
    }
 
    bool operator<( const SCH_REFERENCE& aRef ) const { return GetFullPath() < aRef.GetFullPath(); }
 
    void Annotate();
 
    bool AlwaysAnnotate() const;
 
    void Split();
 
    bool IsSplitNeeded();
 
    void SetRef( const wxString& aReference ) { m_ref = aReference; }
    wxString GetRef() const { return m_ref; }
 
    void SetRefStr( const std::string& aReference ) { m_ref = aReference; }
    const char* GetRefStr() const { return m_ref.c_str(); }
 
    wxString GetFullRef( bool aIncludeUnit = true ) const
    {
        wxString refNum = m_numRefStr;
 
        if( refNum.IsEmpty() )
            refNum << m_numRef;
 
        if( aIncludeUnit && GetSymbol()->GetUnitCount() > 1 )
            return GetRef() + refNum + GetSymbol()->SubReference( GetUnit() );
        else
            return GetRef() + refNum;
    }
 
    wxString GetRefNumber() const
    {
        if( m_numRef < 0 )
            return wxT( "?" );
        else
            return m_numRefStr;
    }
 
    int CompareValue( const SCH_REFERENCE& item ) const
    {
        return m_value.Cmp( item.m_value );
    }
 
    int CompareRef( const SCH_REFERENCE& item ) const
    {
        return m_ref.CmpNoCase( item.m_ref );
    }
 
    int CompareLibName( const SCH_REFERENCE& item ) const
    {
        return m_rootSymbol->GetLibId().GetLibItemName().compare(
            item.m_rootSymbol->GetLibId().GetLibItemName() );
    }
 
    bool IsSameInstance( const SCH_REFERENCE& other ) const
    {
        // Only compare symbol and path.
        // We may have changed the unit number or the designator but
        // can still be referencing the same instance.
        return GetSymbol() == other.GetSymbol()
               && GetSheetPath().Path() == other.GetSheetPath().Path();
    }
 
    bool IsUnitsLocked()
    {
        if( GetLibPart() )
            return GetLibPart()->UnitsLocked();
        else
            return true; // Assume units locked when we don't have a library
    }
 
    void SetRefNum( int aNum )
    {
        m_numRef = aNum;
        m_numRefStr = formatRefStr( aNum );
    }
 
private:
    wxString formatRefStr( int aNumber ) const;
 
private:
    friend class SCH_REFERENCE_LIST;
 
    wxString        m_ref;               // it's private, use the accessors please
    SCH_SYMBOL*     m_rootSymbol;        
    VECTOR2I        m_symbolPos;         
    int             m_unit;              
    wxString        m_value;             
    wxString        m_footprint;         
    SCH_SHEET_PATH  m_sheetPath;         
    bool            m_isNew;             
    int             m_sheetNum;          
    KIID            m_symbolUuid;        
    int             m_numRef;            
    wxString        m_numRefStr;         
    int             m_flag;
};
 
 
typedef std::function<void( ERCE_T aType, const wxString& aMsg, SCH_REFERENCE* aItemA,
                            SCH_REFERENCE* aItemB )> ANNOTATION_ERROR_HANDLER;
 
 
class SCH_REFERENCE_LIST
{
public:
    SCH_REFERENCE_LIST()
    {}
 
    SCH_REFERENCE& operator[]( int aIndex )
    {
        return m_flatList[ aIndex ];
    }
 
    const SCH_REFERENCE& operator[]( int aIndex ) const
    {
        return m_flatList[ aIndex ];
    }
 
    void Clear()
    {
        m_flatList.clear();
    }
 
    size_t GetCount() const { return m_flatList.size(); }
 
    SCH_REFERENCE& GetItem( size_t aIdx ) { return m_flatList[aIdx]; }
    const SCH_REFERENCE& GetItem( size_t aIdx ) const { return m_flatList[aIdx]; }
 
    void AddItem( const SCH_REFERENCE& aItem ) { m_flatList.push_back( aItem ); }
 
    void RemoveItem( unsigned int aIndex );
 
    bool Contains( const SCH_REFERENCE& aItem ) const;
 
    /* Sort functions:
     * Sort functions are used to sort symbols for annotation or BOM generation.  Because
     * sorting depends on what we want to do, there are many sort functions.
     * Note:
     *    When creating BOM, symbols are fully annotated.  References are something like U3,
     *    U5 or R4, R8.  When annotating,  some or all symbols are not annotated, i.e. ref is
     *    only U or R, with no number.
     */
 
    void SplitReferences()
    {
        for( unsigned ii = 0; ii < GetCount(); ii++ )
            m_flatList[ii].Split();
    }
 
    void RemoveAnnotation()
    {
        for( unsigned ii = 0; ii < GetCount(); ii++ )
            m_flatList[ii].m_isNew = true;
    }
 
    void UpdateAnnotation()
    {
        /* update the reference numbers */
        for( unsigned ii = 0; ii < GetCount(); ii++ )
            m_flatList[ii].Annotate();
    }
 
    void ReannotateByOptions( ANNOTATE_ORDER_T             aSortOption,
                              ANNOTATE_ALGO_T              aAlgoOption,
                              int                          aStartNumber,
                              const SCH_REFERENCE_LIST&    aAdditionalRefs,
                              bool                         aStartAtCurrent,
                              SCH_SHEET_LIST*              aHierarchy );
 
    void ReannotateDuplicates( const SCH_REFERENCE_LIST& aAdditionalReferences );
 
    void AnnotateByOptions( enum ANNOTATE_ORDER_T                   aSortOption,
                            enum ANNOTATE_ALGO_T                    aAlgoOption,
                            int                                     aStartNumber,
                            const SCH_MULTI_UNIT_REFERENCE_MAP&     aLockedUnitMap,
                            const SCH_REFERENCE_LIST&               aAdditionalRefs,
                            bool                                    aStartAtCurrent );
 
    void Annotate( bool aUseSheetNum, int aSheetIntervalId, int aStartNumber,
                   const SCH_MULTI_UNIT_REFERENCE_MAP& aLockedUnitMap,
                   const SCH_REFERENCE_LIST& aAdditionalRefs,
                   bool aStartAtCurrent = false );
 
    int CheckAnnotation( ANNOTATION_ERROR_HANDLER aErrorHandler );
 
    void SortByXCoordinate()
    {
        sort( m_flatList.begin(), m_flatList.end(), sortByXPosition );
    }
 
    void SortByYCoordinate()
    {
        sort( m_flatList.begin(), m_flatList.end(), sortByYPosition );
    }
 
    void SortByTimeStamp()
    {
        sort( m_flatList.begin(), m_flatList.end(), sortByTimeStamp );
    }
 
    void SortByRefAndValue()
    {
        sort( m_flatList.begin(), m_flatList.end(), sortByRefAndValue );
    }
 
    void SortByReferenceOnly()
    {
        sort( m_flatList.begin(), m_flatList.end(), sortByReferenceOnly );
    }
 
    int FindRef( const wxString& aPath ) const;
 
    int FindRefByFullPath( const wxString& aFullPath ) const;
 
    void GetRefsInUse( int aIndex, std::vector<int>& aIdList, int aMinRefId ) const;
 
    std::vector<int> GetUnitsMatchingRef( const SCH_REFERENCE& aRef ) const;
 
    int FindFirstUnusedReference( const SCH_REFERENCE& aRef, int aMinValue,
                                  const std::vector<int>& aRequiredUnits ) const;
 
    std::vector<SCH_SYMBOL_INSTANCE> GetSymbolInstances() const;
 
#if defined(DEBUG)
    void Show( const char* aPrefix = "" );
#endif
 
    static wxString Shorthand( std::vector<SCH_REFERENCE> aList, const wxString& refDelimiter,
                               const wxString& refRangeDelimiter );
 
    std::shared_ptr<REFDES_TRACKER> GetRefDesTracker() const
    {
        return m_refDesTracker;
    }
 
    void SetRefDesTracker( std::shared_ptr<REFDES_TRACKER> aTracker )
    {
        m_refDesTracker = aTracker;
    }
 
    friend class BACK_ANNOTATION;
 
    typedef std::vector<SCH_REFERENCE>::iterator       iterator;
    typedef std::vector<SCH_REFERENCE>::const_iterator const_iterator;
 
    iterator begin() { return m_flatList.begin(); }
 
    iterator end() { return m_flatList.end(); }
 
    const_iterator begin() const { return m_flatList.begin(); }
 
    const_iterator end() const { return m_flatList.end(); }
 
    iterator erase( iterator position ) { return m_flatList.erase( position ); }
 
    iterator erase( iterator first, iterator last ) { return m_flatList.erase( first, last ); }
 
private:
    static bool sortByRefAndValue( const SCH_REFERENCE& item1, const SCH_REFERENCE& item2 );
 
    static bool sortByXPosition( const SCH_REFERENCE& item1, const SCH_REFERENCE& item2 );
 
    static bool sortByYPosition( const SCH_REFERENCE& item1, const SCH_REFERENCE& item2 );
 
    static bool sortByTimeStamp( const SCH_REFERENCE& item1, const SCH_REFERENCE& item2 );
 
    static bool sortByReferenceOnly( const SCH_REFERENCE& item1, const SCH_REFERENCE& item2 );
 
    // Used for sorting static sortByTimeStamp function
    friend class BACK_ANNOTATE;
 
    std::vector<SCH_REFERENCE> m_flatList;
 
    std::shared_ptr<REFDES_TRACKER> m_refDesTracker; 
};
 
#endif    // _SCH_REFERENCE_LIST_H_