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 (C) 1992-2023 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
 */
 
/*
 *  Classes to handle info on nets
 */
 
#ifndef CLASS_NETINFO_
#define CLASS_NETINFO_
 
#include <macros_swig.h>
#include <gr_basic.h>
#include <netclass.h>
#include <board_item.h>
#include <string_utils.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;
 
 
DECL_VEC_FOR_SWIG( PADS_VEC, PAD* )
DECL_VEC_FOR_SWIG( TRACKS_VEC, PCB_TRACK* )
 
 
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" );
    }
 
#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(); }
 
    std::shared_ptr<NETCLASS> GetNetClassSlow() { return m_netClass; }
 
    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; }
 
    bool HasAutoGeneratedNetname()
    {
        return m_shortNetname.StartsWith( wxT( "Net-(" ) )
                    || m_shortNetname.StartsWith( wxT( "unconnected-(" ) );
    }
 
    void SetNetname( const wxString& aNewName )
    {
        m_netname = aNewName;
 
        if( aNewName.Contains( wxT( "/" ) ) )
            m_shortNetname = aNewName.AfterLast( '/' );
        else
            m_shortNetname = aNewName;
 
        m_displayNetname = UnescapeString( m_shortNetname );
    }
 
    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;  
 
    std::shared_ptr<NETCLASS> m_netClass;
 
    bool        m_isCurrent;       
 
    BOARD*      m_parent;          
};
 
 
class NETINFO_MAPPING
{
public:
    NETINFO_MAPPING()
    {
        m_board = nullptr;
    }
 
 
    void SetBoard( const BOARD* aBoard )
    {
        m_board = aBoard;
        Update();
    }
 
    void Update();
 
    int Translate( int aNetCode ) const;
 
    class iterator
    {
    public:
        iterator( std::map<int, int>::const_iterator aIter, const NETINFO_MAPPING* aMapping ) :
            m_iterator( aIter ), m_mapping( aMapping )
        {
        }
 
        const iterator& operator++()
        {
            ++m_iterator;
 
            return *this;
        }
 
        iterator operator++( int )
        {
            iterator ret = *this;
            ++m_iterator;
 
            return ret;
        }
 
        NETINFO_ITEM* operator*() const;
 
        NETINFO_ITEM* operator->() const;
 
        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:
        std::map<int, int>::const_iterator m_iterator;
        const NETINFO_MAPPING*             m_mapping;
    };
 
    iterator begin() const
    {
        return iterator( m_netMapping.begin(), this );
    }
 
    iterator end() const
    {
        return iterator( m_netMapping.end(), this );
    }
 
    int GetSize() const
    {
        return m_netMapping.size();
    }
 
private:
    const BOARD*       m_board;         
    std::map<int, int> m_netMapping;    
};
 
 
#if 0
// waiting for swig to support std::unordered_map, see
// http://www.swig.org/Doc3.0/CPlusPlus11.html
// section 7.3.3
#include <hashtables.h>
DECL_HASH_FOR_SWIG( NETNAMES_MAP, wxString,  NETINFO_ITEM* )
DECL_HASH_FOR_SWIG( NETCODES_MAP, int,       NETINFO_ITEM* )
#else
// use std::map for now
DECL_MAP_FOR_SWIG( NETNAMES_MAP, wxString,  NETINFO_ITEM* )
DECL_MAP_FOR_SWIG( NETCODES_MAP, int,       NETINFO_ITEM* )
#endif
 
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;
 
    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
 
#ifndef SWIG
    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() );
    }
#endif
 
    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 buildListOfNets();
 
    int getFreeNetCode();
 
public:
    mutable bool m_DisplayNetnamesDirty;
 
private:
    BOARD*       m_parent;
 
    NETNAMES_MAP m_netNames;        
    NETCODES_MAP m_netCodes;        
 
    int          m_newNetCode;      
};
 
#endif  // CLASS_NETINFO_