oaNet.h

Go to the documentation of this file.

// *****************************************************************************
// *****************************************************************************
// oaNet.h
//
// This file contains the definition for the oaNet and oaBitNet classes and
// their public supporting classes. The oaNet class is an abstract base for
// all types of nets. The oaBitNet class is the base class for all single-bit
// nets. The supporting classes include:
//
//  oaNetAttrType
//      This class implements an enumerated type that designates different
//      net attributes for use with the oaAttributeDisplay object.
//
//  oaRoutePattern
//      This class implements an enumerated type that describes the routing
//      pattern for the associated net.
//
//  oaConnStatus
//      This class implements an enumerated type that describes the connection
//      status for the associated net.
//
//  oaMemNetIter
//      This class implements an iterator over the collection of nets that
//      a specified net is a member of.
//
// *****************************************************************************
// Except as specified in the OpenAccess terms of use of Cadence or Silicon
// Integration Initiative, this material may not be copied, modified,
// re-published, uploaded, executed, or distributed in any way, in any medium,
// in whole or in part, without prior written permission from Cadence.
//
//                Copyright 2002-2005 Cadence Design Systems, Inc.
//                           All Rights Reserved.
//
//  $Author: icftcm $
//  $Revision: #1 $
//  $Date: 2010/08/09 $
//  $State: Exp $
// *****************************************************************************
// *****************************************************************************



#if !defined(oaNet_P)
#define oaNet_P



// *****************************************************************************
// Nested includes
// *****************************************************************************
#include "oaName.h"
#include "oaConstraintGroup.h"
#include "oaDesignModTypes.h"
#include "oaBlockObject.h"
#include "oaDesignCollection.h"
#include "oaConnCollection.h"
#include "oaAttrType.h"
#include "oaSigType.h"
#include "oaSource.h"



// *****************************************************************************
// Declare and define types in the OpenAccess namespace.
// *****************************************************************************
BEGIN_OA_NAMESPACE



// *****************************************************************************
// oaNetAttrTypeEnum
// *****************************************************************************
#define oavNumNetAttrTypes      6

enum oaNetAttrTypeEnum {
    oacNameNetAttrType          = 0,
    oacSigTypeNetAttrType       = 1,
    oacIsGlobalNetAttrType      = 2,
    oacIsImplicitNetAttrType    = 3,
    oacIsEmptyNetAttrType       = 4,
    oacNumBitsNetAttrType       = 5
};



// *****************************************************************************
// oaNetAttrType
// *****************************************************************************
class OA_DESIGN_DLL_API oaNetAttrType : public oaAttrType {
public:
                            oaNetAttrType(oaNetAttrTypeEnum valueIn);
                            oaNetAttrType(const oaString &name);
                            oaNetAttrType(oaAttrType attr);

    virtual const oaString  &getName() const;

    oaNetAttrTypeEnum       getValue() const;

private:
    static const oaString   names[];
};



// *****************************************************************************
// oaRoutePatternEnum
// *****************************************************************************
#define oavNumRoutePatternTypes 3

enum oaRoutePatternEnum {
    oacSteinerRoutePattern  = 0,
    oacBalancedRoutePattern = 1,
    oacTrunkRoutePattern    = 2
};



// *****************************************************************************
// oaRoutePattern
// *****************************************************************************
class OA_DESIGN_DLL_API oaRoutePattern {
public:         
                            oaRoutePattern(oaRoutePatternEnum valueIn);
                            oaRoutePattern(const oaString &name);
                            ~oaRoutePattern();

    const oaString          &getName() const;

                            operator                oaRoutePatternEnum() const;

private:
    oaRoutePatternEnum      value;

    static const oaString   names[];
};



// *****************************************************************************
// oaConnStatusEnum
// *****************************************************************************
#define oavNumConnStatusTypes   3

enum oaConnStatusEnum {
    oacNormalConnStatus = 0,
    oacFixedConnStatus  = 1,
    oacLockedConnStatus = 2
};



// *****************************************************************************
// oaConnStatus
// *****************************************************************************
class OA_DESIGN_DLL_API oaConnStatus {
public:         
                            oaConnStatus(oaConnStatusEnum valueIn);
                            oaConnStatus(const oaString &name);
                            ~oaConnStatus();

    const oaString          &getName() const;

                            operator                oaConnStatusEnum() const;

private:
    oaConnStatusEnum        value;

    static const oaString   names[];
};



// *****************************************************************************
// oaNet
// *****************************************************************************
class OA_DESIGN_DLL_API oaNet : public oaBlockObject {
public:
    static oaNet                    *create(oaBlock                 *block,
                                            const oaName            &name,
                                            oaSigType               sigType = oacSignalSigType,
                                            oaBoolean               isGlobal = false,
                                            oaBlockDomainVisibility view = oacInheritFromTopBlock);

    void                            destroy();

    static oaNet                    *find(const oaBlock *block,
                                          const oaName  &name);

    static oaBoolean                isValidName(const oaBlock   *block,
                                                const oaName    &name);

    oaBoolean                       isEmpty() const;
    oaBoolean                       isImplicit() const;
    oaBoolean                       isGlobal() const;

    oaUInt4                         getNumBits() const;
    oaBitNet                        *getBit(oaUInt4 bitIndex) const;

    void                            getName(oaName &name) const;
    void                            getName(const oaNameSpace   &ns,
                                            oaString            &name) const;

    oaSigType                       getSigType() const;
    oaInt4                          getPriority() const;
    oaSource                        getSource() const;

    void                            setGlobal(oaBoolean isGlobal);
    void                            setSigType(const oaSigType &sigType);
    void                            setPriority(oaInt4 priority);
    void                            setSource(oaSource source);

    oaBoolean                       hasDefaultConstraintGroup() const;
    oaConstraintGroup               *getDefaultConstraintGroup() const;

    void                            transfer(oaNet *fromNet);
    void                            merge(oaNet *fromNet);

    void                            scalarize();

    oaOccNet                        *getOccNet() const;

    oaCollection<oaGuide, oaNet>    getGuides(oaBoolean includeRouteGuides = true) const;
    oaCollection<oaInstTerm, oaNet> getInstTerms(oaUInt4 filterFlags = oacInstTermIterNotImplicit) const;
    oaCollection<oaOccNet, oaNet>   getOccNets(const oaOccurrence *top) const;
    oaCollection<oaPin, oaNet>      getPins() const;
    oaCollection<oaRoute, oaNet>    getRoutes() const;
    oaCollection<oaShape, oaNet>    getShapes(oaUInt4 filterFlags = oacShapeIterNetRoutes) const;
    oaCollection<oaBitNet, oaNet>   getSingleBitMembers() const;
    oaCollection<oaSteiner, oaNet>  getSteiners() const;
    oaCollection<oaTerm, oaNet>     getTerms(oaUInt4 filterflags = oacTermIterNotImplicit) const;
    oaCollection<oaVia, oaNet>      getVias(oaUInt4 filterFlags = oacViaIterNetRoutes) const;

    oaMemNetCollection              getMemberNets(oaBoolean unique = true) const;

    enum {dtIndex = oacNetDataType};
};



// *****************************************************************************
// oaBitNet
// *****************************************************************************
class OA_DESIGN_DLL_API oaBitNet : public oaNet {
public:
    oaBoolean                           isPreferredEquivalent() const;
    oaBoolean                           isOriginal() const;

    oaNetConnectDef                     *getConnectDef() const;
    oaConnStatus                        getConnStatus() const;
    oaBitNet                            *getOriginal() const;
    void                                getParasiticConfidence(oaUInt4  &minValue,
                                                               oaUInt4  &maxValue) const;
    oaBitNet                            *getPreferredEquivalent() const;
    oaRoutePattern                      getRoutePattern() const;
    oaBitNet                            *getShieldNet1() const;
    oaBitNet                            *getShieldNet2() const;
    oaFloat                             getVoltage() const;

    void                                setConnStatus(oaConnStatus status);
    void                                setOriginal(oaBitNet *original);
    void                                setParasiticConfidence(oaUInt4 value);
    void                                setParasiticConfidence(oaUInt4  minValue,
                                                               oaUInt4  maxValue);
    void                                setPreferredEquivalent();
    void                                setRoutePattern(oaRoutePattern routePattern);
    void                                setShieldNet1(oaBitNet *shieldNet);
    void                                setShieldNet2(oaBitNet *shieldNet);
    void                                setVoltage(oaFloat voltage);

    void                                makeEquivalent(oaBitNet *equivNet);
    void                                breakEquivalence();
    oaBoolean                           hasImplicitEquivalence() const;

    oaCollection<oaBitNet, oaBitNet>    getEquivalentNets() const;
    oaCollection<oaBitNet, oaBitNet>    getEquivalentNets(oaUInt4 filterFlags) const;
};



// *****************************************************************************
// Design Traits.
// *****************************************************************************
template<>
class oaTraits<oaNet> {
public:
    typedef oaBlockObject       parentType;
    typedef oaNetModTypeEnum    modTypeType;
    enum {domain = oacBlockDomain};
    enum {dbType = oacDesignDBType};
    enum {isConcrete = false};
    enum {dtIndex = oacNetDataType};
    enum {isMultiDomain = true};
    enum {dataTypeEnumVal = oacNetDataType};
    enum {abstractTypeEnumVal = oacNetType};
};

template<>
class oaTraits<oaBitNet> {
public:
    typedef oaNetModTypeEnum    modTypeType;
    typedef oaNet               parentType;
    enum {dtIndex = oacNetDataType};
    enum {isMultiDomain = true};
    enum {dataTypeEnumVal = oacNetDataType};
    enum {domain = oacBlockDomain};
    enum {dbType = oacDesignDBType};
    enum {isConcrete = false};
    enum {abstractTypeEnumVal = oacBitNetType};
};



END_OA_NAMESPACE

#endif

Return to top of page

Copyright © 2002 - 2010 Cadence Design Systems, Inc.
All Rights Reserved.