diff options
Diffstat (limited to 'pcbnew/class_netclass.h')
| -rw-r--r-- | pcbnew/class_netclass.h | 294 |
1 files changed, 294 insertions, 0 deletions
diff --git a/pcbnew/class_netclass.h b/pcbnew/class_netclass.h new file mode 100644 index 0000000..5b6bbe1 --- /dev/null +++ b/pcbnew/class_netclass.h @@ -0,0 +1,294 @@ +/** + * @file class_netclass.h + */ + +/* + * This program source code file is part of KiCad, a free EDA CAD application. + * + * Copyright (C) 2009 SoftPLC Corporation, Dick Hollenbeck <dick@softplc.com> + * Copyright (C) 2009 Jean-Pierre Charras, jean-pierre.charras@inpg.fr + * Copyright (C) 2009 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 CLASS_NETCLASS_H +#define CLASS_NETCLASS_H + +#include <set> +#include <map> +#include <boost/shared_ptr.hpp> + +#include <wx/string.h> + +#include <richio.h> + + +class LINE_READER; +class BOARD; +class BOARD_DESIGN_SETTINGS; + + +/** + * Class NETCLASS + * handles a collection of nets and the parameters used to route or + * test these nets. + */ + +class NETCLASS +{ +private: + // Default values used to init a NETCLASS + static const int DEFAULT_CLEARANCE; + static const int DEFAULT_VIA_DRILL; + static const int DEFAULT_UVIA_DRILL; + static const int DEFAULT_VIA_DIAMETER; + static const int DEFAULT_UVIA_DIAMETER; + static const int DEFAULT_TRACK_WIDTH; + +protected: + wxString m_Name; ///< Name of the net class + wxString m_Description; ///< what this NETCLASS is for. + + typedef std::set<wxString> STRINGSET; + + STRINGSET m_Members; ///< names of NET members of this class + + /// The units on these parameters is Internal Units (1 nm) + + int m_Clearance; ///< clearance when routing + + int m_TrackWidth; ///< track width used to route NETs in this NETCLASS + int m_ViaDia; ///< via diameter + int m_ViaDrill; ///< via drill hole diameter + + int m_uViaDia; ///< microvia diameter + int m_uViaDrill; ///< microvia drill hole diameter + +public: + + static const wxChar Default[]; ///< the name of the default NETCLASS + + /** + * Constructor + * stuffs a NETCLASS instance with aParent, aName, and optionally the initialParameters + * @param aName = the name of this new netclass + */ + NETCLASS( const wxString& aName ); + + ~NETCLASS(); + + wxString GetClass() const + { + return wxT( "NETCLASS" ); + } + + const wxString& GetName() const + { + return m_Name; + } + + void SetName( const wxString& aName ) { m_Name = aName; } + + /** + * Function GetCount + * returns the number of nets in this NETCLASS, i.e. using these rules. + */ + unsigned GetCount() const + { + return m_Members.size(); + } + + /** + * Function Clear + * empties the collection of members. + */ + void Clear() + { + m_Members.clear(); + } + + /** + * Function Add + * adds \a aNetname to this NETCLASS if it is not already in this NETCLASS. + * It is harmless to try and add a second identical name. + */ + void Add( const wxString& aNetname ) + { + m_Members.insert( aNetname ); + } + + typedef STRINGSET::iterator iterator; + iterator begin() { return m_Members.begin(); } + iterator end() { return m_Members.end(); } + + typedef STRINGSET::const_iterator const_iterator; + const_iterator begin() const { return m_Members.begin(); } + const_iterator end() const { return m_Members.end(); } + + /** + * Function Remove + * will remove NET name \a aName from the collection of members. + */ + void Remove( iterator aName ) + { + m_Members.erase( aName ); + } + + /** + * Function Remove + * will remove NET name \a aName from the collection of members. + */ + void Remove( const wxString& aName ) + { + m_Members.erase( aName ); + } + + const wxString& GetDescription() const { return m_Description; } + void SetDescription( const wxString& aDesc ) { m_Description = aDesc; } + + int GetClearance() const { return m_Clearance; } + void SetClearance( int aClearance ) { m_Clearance = aClearance; } + + int GetTrackWidth() const { return m_TrackWidth; } + void SetTrackWidth( int aWidth ) { m_TrackWidth = aWidth; } + + int GetViaDiameter() const { return m_ViaDia; } + void SetViaDiameter( int aDia ) { m_ViaDia = aDia; } + + int GetViaDrill() const { return m_ViaDrill; } + void SetViaDrill( int aSize ) { m_ViaDrill = aSize; } + + int GetuViaDiameter() const { return m_uViaDia; } + void SetuViaDiameter( int aSize ) { m_uViaDia = aSize; } + + int GetuViaDrill() const { return m_uViaDrill; } + void SetuViaDrill( int aSize ) { m_uViaDrill = aSize; } + + /** + * Function SetParams + * will set all the parameters by copying them from \a defaults. + * Parameters are the values like m_ViaSize, etc, but do not include m_Description. + * @param aDefaults is another NETCLASS object to copy from. + */ + void SetParams( const NETCLASS& aDefaults ); + + /** + * Function Format + * outputs the net class to \a aFormatter in s-expression form. + * + * @param aFormatter The #OUTPUTFORMATTER object to write to. + * @param aNestLevel The indentation next level. + * @param aControlBits The control bit definition for object specific formatting. + * @throw IO_ERROR on write error. + */ + void Format( OUTPUTFORMATTER* aFormatter, int aNestLevel, int aControlBits ) const + throw( IO_ERROR ); + +#if defined(DEBUG) + void Show( int nestLevel, std::ostream& os ) const; // overload +#endif +}; + +typedef boost::shared_ptr<NETCLASS> NETCLASSPTR; + +/** + * Class NETCLASSES + * is a container for NETCLASS instances. It owns all its NETCLASSes + * (=> it will delete them at time of destruction). This container will always have + * a default NETCLASS with the name given by const NETCLASS::Default. + */ +class NETCLASSES +{ +private: + typedef std::map<wxString, NETCLASSPTR> NETCLASSMAP; + + /// all the NETCLASSes except the default one. + NETCLASSMAP m_NetClasses; + + /// the default NETCLASS. + NETCLASSPTR m_Default; + +public: + NETCLASSES(); + ~NETCLASSES(); + + /** + * Function Clear + * destroys any contained NETCLASS instances except the Default one. + */ + void Clear() + { + m_NetClasses.clear(); + } + + typedef NETCLASSMAP::iterator iterator; + iterator begin() { return m_NetClasses.begin(); } + iterator end() { return m_NetClasses.end(); } + + typedef NETCLASSMAP::const_iterator const_iterator; + const_iterator begin() const { return m_NetClasses.begin(); } + const_iterator end() const { return m_NetClasses.end(); } + + /** + * Function GetCount + * @return the number of netclasses, excluding the default one. + */ + unsigned GetCount() const + { + return m_NetClasses.size(); + } + + /** + * Function GetDefault + * @return the default net class. + */ + NETCLASSPTR GetDefault() const + { + return m_Default; + } + + /** + * Function Add + * takes ownership of \a aNetclass and puts it into this NETCLASSES container. + * @param aNetclass is netclass to add + * @return true if the name within aNetclass is unique and it could be inserted OK, + * else false because the name was not unique and caller still owns aNetclass. + */ + bool Add( NETCLASSPTR aNetclass ); + + /** + * Function Remove + * removes a NETCLASS from this container but does not destroy/delete it. + * @param aNetName is the name of the net to delete, and it may not be NETCLASS::Default. + * @return NETCLASSPTR - the NETCLASS associated with aNetName if found and removed, else NULL. + */ + NETCLASSPTR Remove( const wxString& aNetName ); + + /** + * Function Find + * searches this container for a NETCLASS given by \a aName. + * @param aName is the name of the NETCLASS to search for. + * @return NETCLASSPTR - if found, else NULL. + */ + NETCLASSPTR Find( const wxString& aName ) const; + +}; + +#endif // CLASS_NETCLASS_H |