oaBlockage.h

Go to the documentation of this file.

// *****************************************************************************
// *****************************************************************************
// oaBlockage.h
//
// This file contains the definition for the oaBlockage and related classes.
//
//  oaBlockageType
//      This class indicates a the usage of the blockage
//
//  oaBlockage
//      The oaBlockage class is the base class for the blockages types below.
//      oaBlockage objects are used to indicate the area in which certain
//      objects may not be located.
//
//  oaAreaBlockage
//      The oaAreaBlockage is a blockage for which the shape is specified by
//      a point array.
//
//  oaAreaHalo
//      The oaAreaHalo is a blockage for which the shape is derived from a
//      prBoundary shape and a set of offsets.
//
//  oaLayerBlockage
//      The oaLayerBlockage is a blockage that has an associated layer. The 
//      blockage shape is specified by a point array.
//
//  oaLayerHalo
//      The oaLayerHalo is a blockage that has an associated prBoundary. The
//      blockage shape is derived from the prBoundry shape and a set of offsets.
//
//  oaLayerRangeBlockage
//      The oaLayerRangeBlockage is a blockage that has an associated set of 
//      layers. The blockage shape is specified by a point array.
//
//  oaLayerRangeHalo
//      The oaLayerRangeHalo is a blockage that has an associated prBoundary. 
//      Its shape is derived from the prBoundry shape and a set of offsets. It
//      is associated with a set of layers.
//
// *****************************************************************************
// 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-2008 Cadence Design Systems, Inc.
//                           All Rights Reserved.
//
//  $Author: icftcm $
//  $Revision: #1 $
//  $Date: 2010/08/09 $
//  $State: Exp $
// *****************************************************************************
// *****************************************************************************



#if !defined(oaBlockage_P)
#define oaBlockage_P



// *****************************************************************************
// Nested includes
// *****************************************************************************
#include "oaPointArray.h"
#include "oaFig.h"
#include "oaLayerHeader.h"



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



// *****************************************************************************
// oaBlockageTypeEnum
// *****************************************************************************
#define oavNumBlockageTypes     9

enum oaBlockageTypeEnum {
    oacRoutingBlockageType      = 0,
    oacViaBlockageType          = 1,
    oacPlacementBlockageType    = 2,
    oacWiringBlockageType       = 3,
    oacFillBlockageType         = 4,
    oacSlotBlockageType         = 5,
    oacPinBlockageType          = 6,
    oacFeedthruBlockageType     = 7,
    oacScreenBlockageType       = 8
};



// *****************************************************************************
// oaBlockageType
// *****************************************************************************
class OA_DESIGN_DLL_API oaBlockageType {
public:
                            oaBlockageType(oaBlockageTypeEnum valueIn);
                            oaBlockageType(const oaString &name);

#if !defined(OA_DEPRECATED)
    const oaString          &getName();
#endif
                            operator oaBlockageTypeEnum() const;
    const oaString          &getName() const;

private:
    oaBlockageTypeEnum      value;

    static const oaString   names[];
};



// *****************************************************************************
// oaBlockage
// *****************************************************************************
class OA_DESIGN_DLL_API oaBlockage : public oaFig {
public:
    oaBlockageType          getBlockageType() const;
    oaBlockObject           *getOwner() const;
    oaUInt4                 getNumPoints() const;
    void                    getPoints(oaPointArray &points) const;
    oaFloat                 getDensity() const;

    void                    setOwner(oaBlockObject *owner);
    void                    setPushedDown(oaBoolean flag);
    void                    setDensity(oaFloat density);

    oaBoolean               isPushedDown() const;

    enum {dtIndex = oacBlockageDataType};
};



// *****************************************************************************
// oaAreaBlockage
// *****************************************************************************
class OA_DESIGN_DLL_API oaAreaBlockage : public oaBlockage {
public:
    static oaAreaBlockage   *create(oaBlock             *block,
                                    const oaPointArray  &points,
                                    oaBlockObject       *owner = NULL);

    oaBoolean               isSoft() const;

    void                    setPoints(const oaPointArray &points);
    void                    setSoft(oaBoolean soft);

    void                    transform(oaDouble  scale,
                                      oaDouble  angle);
};



// *****************************************************************************
// oaAreaHalo
// *****************************************************************************
class OA_DESIGN_DLL_API oaAreaHalo : public oaBlockage {
public:
    static oaAreaHalo       *create(oaBlockObject   *owner,
                                    oaDist          left = 0,
                                    oaDist          bottom = 0,
                                    oaDist          right = 0,
                                    oaDist          top = 0);
    static oaAreaHalo       *find(const oaBlockObject *owner);

    void                    getOffsets(oaDist   &left,
                                       oaDist   &bottom,
                                       oaDist   &right,
                                       oaDist   &top) const;
    oaBoolean               isSoft() const;

    void                    setOffsets(oaDist   left,
                                       oaDist   bottom,
                                       oaDist   right,
                                       oaDist   top);
    void                    setSoft(oaBoolean soft);
};



// *****************************************************************************
// oaLayerBlockage
// *****************************************************************************
class OA_DESIGN_DLL_API oaLayerBlockage : public oaBlockage {
public:
    static oaLayerBlockage  *create(oaBlock             *block,
                                    oaBlockageType      type,
                                    oaLayerNum          layer,
                                    const oaPointArray  &points,
                                    oaBlockObject       *owner = NULL);

    oaLayerNum              getLayerNum() const;
    oaLayerHeader           *getLayerHeader() const;
    oaDist                  getEffectiveWidth() const;
    oaBoolean               hasEffectiveWidth() const;
    oaDist                  getSpacing() const;
    oaBoolean               hasSpacing() const;
    oaBoolean               allowPGNet() const;

    void                    setLayerNum(oaLayerNum layerNum);
    void                    setPoints(const oaPointArray &points);
    void                    setEffectiveWidth(oaDist width);
    void                    unsetEffectiveWidth();
    void                    setSpacing(oaDist spacing);
    void                    unsetSpacing();
    void                    setAllowPGNet(oaBoolean allowPGNet);

    void                    transform(oaDouble  scale,
                                      oaDouble  angle);
};



// *****************************************************************************
// oaLayerHalo
// *****************************************************************************
class OA_DESIGN_DLL_API oaLayerHalo : public oaBlockage {
public:
    static oaLayerHalo      *create(oaBlockObject   *owner,
                                    oaBlockageType  type,
                                    oaLayerNum      layer,
                                    oaDist          left = 0,
                                    oaDist          bottom = 0,
                                    oaDist          right = 0,
                                    oaDist          top = 0);

    oaLayerNum              getLayerNum() const;
    oaLayerHeader           *getLayerHeader() const;
    void                    getOffsets(oaDist   &left,
                                       oaDist   &bottom,
                                       oaDist   &right,
                                       oaDist   &top) const;

    void                    setLayerNum(oaLayerNum layerNum);
    void                    setOffsets(oaDist   left,
                                       oaDist   bottom,
                                       oaDist   right,
                                       oaDist   top);
};



// *****************************************************************************
// oaLayerRangeBlockage
// *****************************************************************************
class OA_DESIGN_DLL_API oaLayerRangeBlockage : public oaBlockage {
public:
    static oaLayerRangeBlockage *create(oaBlock             *block,
                                        oaBlockageType      type,
                                        const oaIntRange    &maskRange,
                                        const oaPointArray  &points,
                                        oaBlockObject       *owner = NULL);

    void                        getMaskRange(oaIntRange &maskRange) const;
    void                        getLayerHeaders(oaLayerHeaderArray &layerHeaders) const;

    void                        setMaskRange(const oaIntRange &maskRange);
    void                        setPoints(const oaPointArray &points);
    void                        transform(oaDouble  scale,
                                          oaDouble  angle);
};



// *****************************************************************************
// oaLayerRangeHalo
// *****************************************************************************
class OA_DESIGN_DLL_API oaLayerRangeHalo : public oaBlockage {
public:
    static oaLayerRangeHalo *create(oaBlockObject       *owner,
                                    oaBlockageType      type,
                                    const oaIntRange    &maskRange,
                                    oaDist              left = 0,
                                    oaDist              bottom = 0,
                                    oaDist              right = 0,
                                    oaDist              top = 0);

    void                    getMaskRange(oaIntRange &maskRange) const;
    void                    getLayerHeaders(oaLayerHeaderArray &layerHeaders) const;
    void                    getOffsets(oaDist   &left,
                                       oaDist   &bottom,
                                       oaDist   &right,
                                       oaDist   &top) const;

    void                    setMaskRange(const oaIntRange &maskRange);
    void                    setOffsets(oaDist   left,
                                       oaDist   bottom,
                                       oaDist   right,
                                       oaDist   top);
};



// *****************************************************************************
// Design Traits.
// *****************************************************************************
template<>
class oaTraits<oaBlockage> {
public:
    typedef oaFig                   parentType;
    typedef oaBlockageModTypeEnum   modTypeType;
    enum {domain = oacBlockDomain};
    enum {dbType = oacDesignDBType};
    enum {isMultiDomain = false};
    enum {isConcrete = false};
    enum {dtIndex = oacBlockageDataType};
    enum {dataTypeEnumVal = oacBlockageDataType};
    enum {abstractTypeEnumVal = oacBlockageType};
};

template<>
class oaTraits<oaAreaBlockage> {
public:
    typedef oaBlockageModTypeEnum   modTypeType;
    typedef oaBlockage              parentType;
    enum {dtIndex = oacBlockageDataType};
    enum {dataTypeEnumVal = oacBlockageDataType};
    enum {domain = oacBlockDomain};
    enum {dbType = oacDesignDBType};
    enum {isMultiDomain = false};
    enum {isConcrete = true};
    enum {objectTypeEnumVal = oacAreaBlockageType};
};

template<>
class oaTraits<oaAreaHalo> {
public:
    typedef oaBlockageModTypeEnum   modTypeType;
    typedef oaBlockage              parentType;
    enum {dtIndex = oacBlockageDataType};
    enum {dataTypeEnumVal = oacBlockageDataType};
    enum {domain = oacBlockDomain};
    enum {dbType = oacDesignDBType};
    enum {isMultiDomain = false};
    enum {isConcrete = true};
    enum {objectTypeEnumVal = oacAreaHaloType};
};

template<>
class oaTraits<oaLayerBlockage> {
public:
    typedef oaBlockageModTypeEnum   modTypeType;
    typedef oaBlockage              parentType;
    enum {dtIndex = oacBlockageDataType};
    enum {dataTypeEnumVal = oacBlockageDataType};
    enum {domain = oacBlockDomain};
    enum {dbType = oacDesignDBType};
    enum {isMultiDomain = false};
    enum {isConcrete = true};
    enum {objectTypeEnumVal = oacLayerBlockageType};
};

template<>
class oaTraits<oaLayerHalo> {
public:
    typedef oaBlockageModTypeEnum   modTypeType;
    typedef oaBlockage              parentType;
    enum {dtIndex = oacBlockageDataType};
    enum {dataTypeEnumVal = oacBlockageDataType};
    enum {domain = oacBlockDomain};
    enum {dbType = oacDesignDBType};
    enum {isMultiDomain = false};
    enum {isConcrete = true};
    enum {objectTypeEnumVal = oacLayerHaloType};
};

template<>
class oaTraits<oaLayerRangeBlockage> {
public:
    typedef oaBlockageModTypeEnum   modTypeType;
    typedef oaBlockage              parentType;
    enum {dtIndex = oacBlockageDataType};
    enum {dataTypeEnumVal = oacBlockageDataType};
    enum {domain = oacBlockDomain};
    enum {dbType = oacDesignDBType};
    enum {isMultiDomain = false};
    enum {isConcrete = true};
    enum {objectTypeEnumVal = oacLayerRangeBlockageType};
};

template<>
class oaTraits<oaLayerRangeHalo> {
public:
    typedef oaBlockageModTypeEnum   modTypeType;
    typedef oaBlockage              parentType;
    enum {dtIndex = oacBlockageDataType};
    enum {dataTypeEnumVal = oacBlockageDataType};
    enum {domain = oacBlockDomain};
    enum {dbType = oacDesignDBType};
    enum {isMultiDomain = false};
    enum {isConcrete = true};
    enum {objectTypeEnumVal = oacLayerRangeHaloType};
};



END_OA_NAMESPACE

#endif

Return to top of page

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