netinfo.h

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright (C) 2009 Jean-Pierre Charras, jp.charras at wanadoo.fr
 * 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, see <https://www.gnu.org/licenses/>.
 */
 
/*
 *  Classes to handle info on nets
 */
 
#pragma once
 
#include <netclass.h>
#include <board_item.h>
 
 
class EDA_DRAW_FRAME;
class PAD;
class PCB_TRACK;
class BOARD;
class BOARD_ITEM;
class BOARD_COMMIT;
class MSG_PANEL_ITEM;
class PCB_BASE_FRAME;
class REPORTER;
 
 
#define NO_NET _( "<no net>" )
#define CREATE_NET _( "<create net>" )
 

class NETINFO_ITEM : public BOARD_ITEM
{
public:
 
    NETINFO_ITEM( BOARD* aParent, const wxString& aNetName = wxEmptyString, int aNetCode = -1 );
    ~NETINFO_ITEM();
 
    static inline bool ClassOf( const EDA_ITEM* aItem )
    {
        return aItem && PCB_NETINFO_T == aItem->Type();
    }
 
    wxString GetClass() const override
    {
        return wxT( "NETINFO_ITEM" );
    }
 
    PCB_LAYER_ID GetLayer() const override
    {
        wxFAIL_MSG( wxT( "NETINFO_ITEM::GetLayer() desn't have meaning.  Don't call it." ) );
        return UNDEFINED_LAYER;
    }
 
#if defined(DEBUG)
    void Show( int nestLevel, std::ostream& os ) const override
    {
    }
#endif
 
    const BOX2I GetBoundingBox() const override;
 
    VECTOR2I GetPosition() const override
    {
        static VECTOR2I dummy( 0, 0 );
        return dummy;
    }
 
    void SetPosition( const VECTOR2I& aPos ) override
    {
    }
 
    EDA_ITEM* Clone() const override
    {
        return new NETINFO_ITEM( *this );
    }
 
    void SetNetClass( const std::shared_ptr<NETCLASS>& aNetClass );

    NETCLASS* GetNetClass() { return m_netClass.get(); }
    const NETCLASS* GetNetClass() const { return m_netClass.get(); }
 
    int GetNetCode() const { return m_netCode; }
    void SetNetCode( int aNetCode ) { m_netCode = aNetCode; }

    const wxString& GetNetname() const { return m_netname; }

    const wxString& GetShortNetname() const { return m_shortNetname; }

    const wxString& GetDisplayNetname() const { return m_displayNetname; }
 
    const wxString& GetNetChain() const { return m_netChain; }
    void SetNetChain( const wxString& aNetChain ) { m_netChain = aNetChain; }
 
    PAD* GetTerminalPad( int aIndex ) const { return m_terminalPads[aIndex]; }
    void SetTerminalPad( int aIndex, PAD* aPad ) { m_terminalPads[aIndex] = aPad; }
    void SetTerminalPadUuid( int aIndex, const KIID& aUuid ) { m_terminalPadUuids[aIndex] = aUuid; }
    const KIID& GetTerminalPadUuid( int aIndex ) const { return m_terminalPadUuids[aIndex]; }

    void ClearTerminalPad( int aIndex )
    {
        m_terminalPads[aIndex] = nullptr;
        m_terminalPadUuids[aIndex] = niluuid;
    }

    void SetTerminal( int aIndex, PAD* aPad );
 
    void ResolveTerminalPads( BOARD* aBoard );

    bool HasAutoGeneratedNetname() const;

    void SetNetname( const wxString& aNewName );
 
    bool IsCurrent() const { return m_isCurrent; }
    void SetIsCurrent( bool isCurrent ) { m_isCurrent = isCurrent; }

    void GetMsgPanelInfo( EDA_DRAW_FRAME* aFrame, std::vector<MSG_PANEL_ITEM>& aList ) override;

    void Clear();
 
    void SetParent( BOARD* aParent ) { m_parent = aParent; }
    BOARD* GetParent() const      // Replace EDA_ITEM::GetParent() with a more useful return-type
    {
        return m_parent;
    }
 
    bool Matches( const EDA_SEARCH_DATA& aSearchData, void* aAuxData ) const override;
 
    double Similarity( const BOARD_ITEM& aBoardItem ) const override
    {
        return 0.0;
    }
 
    bool operator==( const BOARD_ITEM& aBoardItem ) const override
    {
        return 0.0;
    }
 
protected:
    // Hide base SetParent method to make the BOARD* method the prefered method for this class
    using EDA_ITEM::SetParent;
 
private:
    friend class NETINFO_LIST;
 
    int         m_netCode;         
    wxString    m_netname;         
    wxString    m_shortNetname;    
 
    wxString    m_displayNetname;  
 
    wxString    m_netChain;
 
    PAD*        m_terminalPads[2];
    KIID        m_terminalPadUuids[2];
 
    std::shared_ptr<NETCLASS> m_netClass;
 
    bool        m_isCurrent;       
 
    BOARD*      m_parent;          
};
 
 
typedef std::map<wxString, NETINFO_ITEM*> NETNAMES_MAP;
typedef std::map<int, NETINFO_ITEM*> NETCODES_MAP;

class NETINFO_LIST
{
    friend class BOARD;
 
public:
    NETINFO_LIST( BOARD* aParent );
    ~NETINFO_LIST();

    NETINFO_ITEM* GetNetItem( int aNetCode ) const;

    NETINFO_ITEM* GetNetItem( const wxString& aNetName ) const;

    unsigned GetNetCount() const { return m_netNames.size(); }

    const NETNAMES_MAP& NetsByName() const      { return  m_netNames; }

    const NETCODES_MAP& NetsByNetcode() const   { return m_netCodes; }
 
    void RebuildDisplayNetnames() const;

    bool RenameNets( const std::map<wxString, wxString>& aNewNames, REPORTER& aReporter );

    static const int UNCONNECTED;

    static const int ORPHANED;

    static NETINFO_ITEM* OrphanedItem()
    {
        static NETINFO_ITEM* g_orphanedItem;
 
        if( !g_orphanedItem )
            g_orphanedItem = new NETINFO_ITEM( nullptr, wxEmptyString, NETINFO_LIST::UNCONNECTED );
 
        return g_orphanedItem;
    }
 
#if defined(DEBUG)
    void Show() const;
#endif

    class iterator
    {
    public:
        iterator( NETNAMES_MAP::const_iterator aIter ) : m_iterator( aIter )
        {
        }

        const iterator& operator++()
        {
            ++m_iterator;
            return *this;
        }

        iterator operator++( int )
        {
            iterator ret = *this;
            ++m_iterator;
            return ret;
        }
 
        NETINFO_ITEM* operator*() const
        {
            return m_iterator->second;
        }
 
        NETINFO_ITEM* operator->() const
        {
            return m_iterator->second;
        }
 
        bool operator!=( const iterator& aOther ) const
        {
            return m_iterator != aOther.m_iterator;
        }
 
        bool operator==( const iterator& aOther ) const
        {
            return m_iterator == aOther.m_iterator;
        }
 
    private:
        NETNAMES_MAP::const_iterator m_iterator;
    };
 
    iterator begin() const
    {
        return iterator( m_netNames.begin() );
    }
 
    iterator end() const
    {
        return iterator( m_netNames.end() );
    }
 
    BOARD* GetParent() const
    {
        return m_parent;
    }
 
protected:  // Access is through the BOARD, which is a friend class
    void AppendNet( NETINFO_ITEM* aNewElement );

    void RemoveNet( NETINFO_ITEM* aNet );
    void RemoveUnusedNets( BOARD_COMMIT* aCommit );
 
private:
    void clear();

    void detachAll();

    void buildListOfNets();

    int getFreeNetCode();
 
public:
    mutable bool m_DisplayNetnamesDirty;
 
private:
    BOARD*       m_parent;
 
    NETNAMES_MAP m_netNames;        
    NETCODES_MAP m_netCodes;        
 
    int          m_newNetCode;      
};