oaConstraintDef.h

Go to the documentation of this file.

// *****************************************************************************
// *****************************************************************************
// oaConstraintDef.h
//
// This file contains the definitions for the following classes:
//      oaSimpleConstraintType
//      oaLayerConstraintType
//      oaLayerPairConstraintType
//      oaLayerArrayConstraintType
//      oaConstraintDef
//      oaSimpleConstraintDef
//      oaLayerConstraintDef
//      oaLayerPairConstraintDef
//      oaLayerArrayConstraintDef
//
// *****************************************************************************
// 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(oaConstraintDef_P)
#define oaConstraintDef_P



// *****************************************************************************
// Nested includes
// *****************************************************************************
#include "oaArray.h"
#include "oaSessionObject.h"



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



// *****************************************************************************
// oaSimpleConstraintTypeEnum
// *****************************************************************************
#define oavNumSimpleConstraintTypes  21

enum oaSimpleConstraintTypeEnum {
    oacValidRoutingLayers               = 0,
    oacValidRoutingVias                 = 1,
    oacCumMetalAntenna                  = 2,
    oacCumViaAntenna                    = 3,
    oacViaStackLimit                    = 4,
    oacHorizontalPlacementGridPitch     = 5,
    oacHorizontalPlacementGridOffset    = 6,
    oacVerticalPlacementGridPitch       = 7,
    oacVerticalPlacementGridOffset      = 8,
    oacDefaultHorizontalRouteGridPitch  = 9,
    oacDefaultVerticalRouteGridPitch    = 10,
    oacDefault135RouteGridPitch         = 11,
    oacDefault45RouteGridPitch          = 12,
    oacDefaultHorizontalRouteGridOffset = 13,
    oacDefaultVerticalRouteGridOffset   = 14,
    oacDefault135RouteGridOffset        = 15,
    oacDefault45RouteGridOffset         = 16,
    oacTaperHalo                        = 17,
    oacShapeAngle                       = 18,
    oacUseNonOrthogonalRoutingRules     = 19,
    oacMaxFloatingArea                  = 20
};



// *****************************************************************************
// oaLayerConstraintTypeEnum
// *****************************************************************************
#define oavNumLayerConstraintTypes  83

enum oaLayerConstraintTypeEnum {
    oacMinArea                          = 0,
    oacMinEnclosedArea                  = 1,
    oacMinDensity                       = 2,
    oacMaxDensity                       = 3,
    oacMinEdgeLength                    = 4,
    oacMinConcaveEdgeLength             = 5,
    oacMinConvexEdgeLength              = 6,
    oacMinDiagonalEdgeLength            = 7,
    oacMinSpacing                       = 8,
    oacMinDiagonalSpacing               = 9,
    oacMinCenterToCenterSpacing         = 10,
    oacMinDiffPotentialSpacing          = 11,
    oacMinEnclosedSpacing               = 12,
    oacMinFillPatternSpacing            = 13,
    oacMinProximitySpacing              = 14,
    oacMinProtrudedProximitySpacing     = 15,
    oacMinSameNetSpacing                = 16,
    oacMinAdjacentViaSpacing            = 17,
    oacMergeSpaceAllowed                = 18,
    oacMinWidth                         = 19,
    oacMinDiagonalWidth                 = 20,
    oacMinProtrusionWidth               = 21,
    oacMaxWidth                         = 22,
    oacMinSize                          = 23,
    oacMinNumCut                        = 24,
    oacMinProtrusionNumCut              = 25,
    oacHorizontalRouteGridPitch         = 26,
    oacHorizontalRouteGridOffset        = 27,
    oacVerticalRouteGridPitch           = 28,
    oacVerticalRouteGridOffset          = 29,
    oac135RouteGridPitch                = 30,
    oac135RouteGridOffset               = 31,
    oac45RouteGridPitch                 = 32,
    oac45RouteGridOffset                = 33,
    oacErrorLayer                       = 34,
    oacAntenna                          = 35,
    oacMinLength                        = 36,
    oacMaxLength                        = 37,
    oacDiagonalShapesAllowed            = 38,
    oacMaxTapSpacing                    = 39,
    oacMinBoundaryExtension             = 40,
    oacMinBoundaryInteriorHalo          = 41,
    oacMinWireExtension                 = 42,
    oacMinParallelViaSpacing            = 43,
    oacMinEndOfLineSpacing              = 44,
    oacMinLargeViaArraySpacing          = 45,
    oacMinLargeViaArrayWidth            = 46,
    oacMinLargeViaArrayCutSpacing       = 47,
    oacRectangularLargeViaArraysAllowed = 48,
    oacMinEdgeMaxCount                  = 49,
    oacMinEdgeAdjacentDistance          = 50,
    oacMaxDiagonalEdgeLength            = 51,
    oacMaxRoutingDistance               = 52,
    oacKeepAlignedShapeAndBoundary      = 53,
    oacPreferredRoutingDirection        = 54,
    oacMinEdgeAdjacentLength            = 55,
    oacMinRectArea                      = 56,
    oacGateOrientation                  = 57,
    oacMinOrthogonalViaSpacing          = 58,
    oacMinNotchSpacing                  = 59,
    oacMinEndOfNotchSpacing             = 60,
    oacLayerShapeAngle                  = 61,
    oacAllowedSpacingRange              = 62,
    oacMinViaSpacing                    = 63,
    oacCutClass                         = 64,
    oacGateClearance                    = 65,
    oacMaxDiffDensity                   = 66,
    oacMinAreaEdgeLength                = 67,
    oacMinCornerToCornerDistance        = 68,
    oacMinCutClassSpacing               = 69,
    oacMinEndOfLinePerpSpacing          = 70,
    oacMinEndOfLineExtensionSpacing     = 71,
    oacMinFillToFillSpacing             = 72,
    oacMinNeighborViaSpacing            = 73,
    oacMinOppositeSpanSpacing           = 74,
    oacMinParallelSpanSpacing           = 75,
    oacMinParallelWithinViaSpacing      = 76,
    oacMinPerimeter                     = 77,
    oacMinSameMetalSharedEdgeViaSpacing = 78,
    oacAllowedWidthRange                = 79,
    oacMinBoundaryExteriorHalo          = 80,
    oacMinVoltageSpacing                = 81,
    oacMinProtrusionSpacing             = 82
};



// *****************************************************************************
// oaLayerPairConstraintTypeEnum
// *****************************************************************************
#define oavNumLayerPairConstraintTypes  23

enum oaLayerPairConstraintTypeEnum {
    oacMinClearance                 = 0,
    oacMaxClearance                 = 1,
    oacMinSameNetClearance          = 2,
    oacMinExtension                 = 3,
    oacMaxExtension                 = 4,
    oacMinDualExtension             = 5,
    oacMinOverlap                   = 6,
    oacViaStackingAllowed           = 7,
    oacMinRedundantViaSetback       = 8,
    oacMinConcaveCornerOverlap      = 9,
    oacMinConcaveCornerExtension    = 10,
    oacKeepAlignedShapes            = 11,
    oacMinEndOfLineExtension        = 12,
    oacAllowedClearanceRange        = 13,
    oacMinViaClearance              = 14,
    oacIllegalHGatePattern          = 15,
    oacMaxTouchingDirectionLength   = 16,
    oacMinCutClassClearance         = 17,
    oacMinExtensionEdge             = 18,
    oacMinGateExtension             = 19,
    oacMinOuterVertexSpacing        = 20,
    oacMinViaExtension              = 21,
    oacMinVoltageClearance          = 22

};



// *****************************************************************************
// oaLayerArrayConstraintTypeEnum
// *****************************************************************************
#define oavNumLayerArrayConstraintTypes     8
#define oavNumDM4LayerArrayConstraintTypes  1

enum oaLayerArrayConstraintTypeEnum {
    oacMinTouchingDirectionExtension    = 0,
    oacMinTouchingDirectionClearance    = 1,
    oacMinClearanceOverLayer            = 2,
    oacMinParallelViaClearance          = 3,
    oacDummyPolyExtension               = 4,
    oacMaxPolyLength                    = 5,
    oacMinInnerVertexSpacing            = 6,
    oacValidRoutingLPPs                 = 7
};



// *****************************************************************************
// oaSimpleConstraintType
// *****************************************************************************
class OA_BASE_DLL_API oaSimpleConstraintType {
public:
                                oaSimpleConstraintType(oaSimpleConstraintTypeEnum typeIn);
                                oaSimpleConstraintType(const oaString &name);
                                ~oaSimpleConstraintType();

    const oaString              &getName() const;
                                operator                    oaSimpleConstraintTypeEnum() const;
    static void                 validate(oaSimpleConstraintTypeEnum typeIn);

private:
    static const oaString       *initNames();

    oaSimpleConstraintTypeEnum  type;

    static const oaString       names[];
};



// *****************************************************************************
// oaLayerConstraintType
// *****************************************************************************
class OA_BASE_DLL_API oaLayerConstraintType {
public:
                                oaLayerConstraintType(oaLayerConstraintTypeEnum typeIn);
                                oaLayerConstraintType(const oaString &name);
                                ~oaLayerConstraintType();

    const oaString              &getName() const;
                                operator                    oaLayerConstraintTypeEnum() const;
    static void                 validate(oaLayerConstraintTypeEnum typeIn);

private:
    static const oaString       *initNames();

    oaLayerConstraintTypeEnum   type;

    static const oaString       names[];
};



// *****************************************************************************
// oaLayerPairConstraintType
// *****************************************************************************
class OA_BASE_DLL_API oaLayerPairConstraintType {
public:
                                    oaLayerPairConstraintType(oaLayerPairConstraintTypeEnum typeIn);
                                    oaLayerPairConstraintType(const oaString &name);
                                    ~oaLayerPairConstraintType();

    const oaString                  &getName() const;
                                    operator                oaLayerPairConstraintTypeEnum() const;
    static void                     validate(oaLayerPairConstraintTypeEnum typeIn);

private:
    static const oaString           *initNames();

    oaLayerPairConstraintTypeEnum   type;

    static const oaString           names[];
};



// *****************************************************************************
// oaLayerArrayConstraintType
// *****************************************************************************
class OA_BASE_DLL_API oaLayerArrayConstraintType {
public:
                                    oaLayerArrayConstraintType(oaLayerArrayConstraintTypeEnum typeIn);
                                    oaLayerArrayConstraintType(const oaString &name);
                                    ~oaLayerArrayConstraintType();

    const oaString                  &getName() const;
                                    operator                oaLayerArrayConstraintTypeEnum() const;
    static void                     validate(oaLayerArrayConstraintTypeEnum typeIn);

private:
    static const oaString           *initNames();

    oaLayerArrayConstraintTypeEnum  type;

    static const oaString           *names;
};



// *****************************************************************************
// oaConstraintDef
// *****************************************************************************
class OA_BASE_DLL_API oaConstraintDef : public oaSessionObject {
public:
    static oaConstraintDef  *find(const oaString &name);

    void                    getName(oaString &name) const;
    void                    getValueTypes(oaSubset<oaType> &allowedValues) const;
    void                    getObjectTypes(oaSubset<oaType> &allowedObjects) const;
    void                    getDatabaseTypes(oaSubset<oaDBType> &allowedDbs) const;
    oaBoolean               isBuiltIn() const;

    void                    destroy();
    void                    remove(oaObject *database);

    enum {dtIndex = oacBaseConstraintDefDataType};
};



// *****************************************************************************
// oaSimpleConstraintDef
// *****************************************************************************
class OA_BASE_DLL_API oaSimpleConstraintDef : public oaConstraintDef {
public:
    static oaSimpleConstraintDef    *create(const oaString              &name,
                                            const oaSubset<oaType>      &allowedValues,
                                            const oaSubset<oaType>      &allowedObjects,
                                            const oaSubset<oaDBType>    &allowedDB);

    static oaSimpleConstraintDef    *get(oaSimpleConstraintType type);
};



// *****************************************************************************
// oaLayerConstraintDef
// *****************************************************************************
class OA_BASE_DLL_API oaLayerConstraintDef : public oaConstraintDef {
public:
    static oaLayerConstraintDef *create(const oaString              &name,
                                        const oaSubset<oaType>      &allowedValues,
                                        const oaSubset<oaType>      &allowedObjects,
                                        const oaSubset<oaDBType>    &allowedDB);

    static oaLayerConstraintDef *get(oaLayerConstraintType type);
};



// *****************************************************************************
// oaLayerPairConstraintDef
// *****************************************************************************
class OA_BASE_DLL_API oaLayerPairConstraintDef : public oaConstraintDef {
public:
    static oaLayerPairConstraintDef *create(const oaString              &name,
                                            const oaSubset<oaType>      &allowedValues,
                                            const oaSubset<oaType>      &allowedObjects,
                                            const oaSubset<oaDBType>    &allowedDB,
                                            oaBoolean                   symmetric = false);

    static oaLayerPairConstraintDef *get(oaLayerPairConstraintType type);

    oaBoolean                       isSymmetric() const;
};



// *****************************************************************************
// oaLayerArrayConstraintDef
// *****************************************************************************
class OA_BASE_DLL_API oaLayerArrayConstraintDef : public oaConstraintDef {
public:
    static oaLayerArrayConstraintDef    *create(const oaString              &name,
                                                const oaSubset<oaType>      &allowedValues,
                                                const oaSubset<oaType>      &allowedObjects,
                                                const oaSubset<oaDBType>    &allowedDB,
                                                oaUInt4                     numLayers);

    static oaLayerArrayConstraintDef    *get(oaLayerArrayConstraintType type);

    oaUInt4                             getNumLayers() const;
};



// *****************************************************************************
// Traits
// *****************************************************************************
template<>
class oaTraits<oaConstraintDef> {
public:
    typedef oaSessionObject             parentType;
    typedef oaConstraintDefModTypeEnum  modTypeType;
    enum {domain = oacNoDomain};
    enum {isMultiDomain = false};
    enum {isConcrete = false};
    enum {dbType = oacBaseDBType};
    enum {abstractTypeEnumVal = oacConstraintDefType};
};

template<>
class oaTraits<oaSimpleConstraintDef> {
public:
    typedef oaConstraintDef parentType;
    enum {domain = oacNoDomain};
    enum {isMultiDomain = false};
    enum {dbType = oacBaseDBType};
    enum {isConcrete = true};
    enum {objectTypeEnumVal = oacSimpleConstraintDefType};
    enum {dataTypeEnumVal = oacBaseConstraintDefDataType};
};

template<>
class oaTraits<oaLayerConstraintDef> {
public:
    typedef oaConstraintDef parentType;
    enum {domain = oacNoDomain};
    enum {isMultiDomain = false};
    enum {dbType = oacBaseDBType};
    enum {isConcrete = true};
    enum {objectTypeEnumVal = oacLayerConstraintDefType};
    enum {dataTypeEnumVal = oacBaseConstraintDefDataType};
};

template<>
class oaTraits<oaLayerPairConstraintDef> {
public:
    typedef oaConstraintDef parentType;
    enum {domain = oacNoDomain};
    enum {isMultiDomain = false};
    enum {dbType = oacBaseDBType};
    enum {isConcrete = true};
    enum {objectTypeEnumVal = oacLayerPairConstraintDefType};
    enum {dataTypeEnumVal = oacBaseConstraintDefDataType};
};

template<>
class oaTraits<oaLayerArrayConstraintDef> {
public:
    typedef oaConstraintDef parentType;
    enum {domain = oacNoDomain};
    enum {isMultiDomain = false};
    enum {dbType = oacBaseDBType};
    enum {isConcrete = true};
    enum {objectTypeEnumVal = oacLayerArrayConstraintDefType};
    enum {dataTypeEnumVal = oacBaseConstraintDefDataType};
};



END_OA_NAMESPACE

#endif

Return to top of page

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