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, 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 <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;
 
 
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() 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;  
 
    std::shared_ptr<NETCLASS> m_netClass;
 
    bool        m_isCurrent;       
 
    BOARD*      m_parent;          
};
 
 
#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_