oaTechCollection.h

Go to the documentation of this file.

// *****************************************************************************
// *****************************************************************************
// oaTechCollection.h
//
// This file contains the definitions for specialized collections and iterators
// and their supporting classes used in the Tech package.
//
// *****************************************************************************
// 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-2007 Cadence Design Systems, Inc.
//                           All Rights Reserved.
//
//  $Author: icftcm $
//  $Revision: #1 $
//  $Date: 2010/08/09 $
//  $State: Exp $
// *****************************************************************************
// *****************************************************************************



#if !defined(oaTechCollection_P)
#define oaTechCollection_P



// *****************************************************************************
// Nested includes
// *****************************************************************************
#include "oaConstraintGroup.h"
#include "oaBaseCollection.h"
#include "oaConstraintDef.h"
#include "oaLayerArray.h"



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



// *****************************************************************************
// Control bits for the oaTech iterators. These generic control bits should be
// used to define the same object specific control bits.
// *****************************************************************************
#define oacTechIterAll          0x0000u
#define oacTechIterLocal        0x0001u



// *****************************************************************************
// Control bits for the analysisLib iterators
// *****************************************************************************
#define oacAnalysisLibIterAll   oacTechIterAll
#define oacAnalysisLibIterLocal oacTechIterLocal



// *****************************************************************************
// Control bits for the layer iterators
// *****************************************************************************
#define oacLayerIterAll         oacTechIterAll
#define oacLayerIterLocal       oacTechIterLocal
#define oacLayerAboveIterAll    0x0002u
#define oacLayerAboveIterLocal  0x0003u
#define oacLayerBelowIterAll    0x0004u
#define oacLayerBelowIterLocal  0x0005u



// *****************************************************************************
// Control bits for the opPoint iterators
// *****************************************************************************
#define oacOpPointIterAll       oacTechIterAll
#define oacOpPointIterLocal     oacTechIterLocal



// *****************************************************************************
// Control bits for the purpose iterators
// *****************************************************************************
#define oacPurposeIterAll       oacTechIterAll
#define oacPurposeIterLocal     oacTechIterLocal



// *****************************************************************************
// Control bits for the siteDef iterators
// *****************************************************************************
#define oacSiteDefIterAll       oacTechIterAll
#define oacSiteDefIterLocal     oacTechIterLocal



// *****************************************************************************
// Control bits for the viaDef iterators
// *****************************************************************************
#define oacViaDefIterAll        oacTechIterAll
#define oacViaDefIterLocal      oacTechIterLocal



// *****************************************************************************
// Control bits for the viaSpec iterators
// *****************************************************************************
#define oacViaSpecIterAll       oacTechIterAll
#define oacViaSpecIterLocal     oacTechIterLocal



// *****************************************************************************
// Control bits for the viaVariant iterators
// *****************************************************************************
#define oacViaVariantIterAll    oacTechIterAll
#define oacViaVariantIterLocal  oacTechIterLocal



// *****************************************************************************
// Control bits for the viaVariantHeader iterators
// *****************************************************************************
#define oacViaVariantHeaderIterAll      oacTechIterAll
#define oacViaVariantHeaderIterLocal    oacTechIterLocal



// *****************************************************************************
// Control bits for the value iterators
// *****************************************************************************
#define oacTechValueIterAll     oacTechIterAll
#define oacTechValueIterLocal   oacTechIterLocal



// *****************************************************************************
// Control bits for the constraint iterators
// *****************************************************************************
#define oacTechConstraintIterAll        oacTechIterAll
#define oacTechConstraintIterLocal      oacTechIterLocal
#define oacTechConstraintIterFlagShift  31
#define oacTechConstraintIterFlagMask   0x80000000u



// *****************************************************************************
// Control bits for the constraintGroup iterators
// *****************************************************************************
#define oacTechConstraintGroupIterAll           oacTechIterAll
#define oacTechConstraintGroupIterLocal         oacTechIterLocal
#define oacTechConstraintGroupIterInitialized   0x0002u



// *****************************************************************************
// Control bits for the constraintParam iterators
// *****************************************************************************
#define oacTechConstraintParamIterAll   oacTechIterAll
#define oacTechConstraintParamIterLocal oacTechIterLocal



// *****************************************************************************
// Control bits for the derivedLayerParam iterators
// *****************************************************************************
#define oacTechDerivedLayerParamIterAll     oacTechIterAll
#define oacTechDerivedLayerParamIterLocal   oacTechIterLocal



// *****************************************************************************
// oaCollection<oaTech, oaTech>
//
// These are the specialized open tech db collection definition and its methods.
// *****************************************************************************
template<>
class OA_TECH_DLL_API oaCollection<oaTech, oaTech> : public oaDatabaseCollection {
public:
                            oaCollection(oaUInt4 dbIDIn);
                            oaCollection(const oaCollection<oaTech, oaTech> &c);

    oaBoolean               includes(const oaTech *db) const;
};



// *****************************************************************************
// oaIter<oaTech>
//
// This is the oaTech specialization of oaIter<>.
// *****************************************************************************
template <>
class OA_TECH_DLL_API oaIter<oaTech> : public oaDatabaseIter {
public:
                            oaIter(const oaCollection<oaTech, oaTech> &c);
                            oaIter(const oaIter<oaTech> &iterIn);

    oaTech                  *getNext();
};



// *****************************************************************************
// oaCollection<oaAppDef, oaTech>
//
// This is the specialization of an oaCollection<> that supplies the collection
// of appDefs in a technology database.
// *****************************************************************************
template <>
class OA_TECH_DLL_API oaCollection<oaAppDef, oaTech> : public oaCollection<oaAppDef, oaObject> {
public:
                            oaCollection(const oaObject *db,
                                         oaTechDataType dataType);
                            oaCollection(const oaCollection<oaAppDef, oaTech> &c);
};



// *****************************************************************************
// oaCollection<oaAppObject, oaTech>
//
// This is the specialization of an oaCollection<> that supplies the collection
// of appObjects in a technology database.
// *****************************************************************************
template <>
class OA_TECH_DLL_API oaCollection<oaAppObject, oaTech> : public oaAppObjectCollection {
public:
                            oaCollection(const oaObject         *db,
                                         const oaAppObjectDef   *def);
                            oaCollection(const oaCollection<oaAppObject, oaTech> &c);
};



// *****************************************************************************
// oaCollection<oaAppObjectDef, oaTech>
//
// This is the specialization of an oaCollection<> that supplies the collection
// of appObjectDefs in a technology database.
// *****************************************************************************
template <>
class OA_TECH_DLL_API oaCollection<oaAppObjectDef, oaTech> : public oaAppObjectDefCollection {
public:
                            oaCollection(const oaObject *db);
                            oaCollection(const oaCollection<oaAppObjectDef, oaTech> &c);
};



// *****************************************************************************
// oaCollection<oaGroup, oaTech>
//
// This is the specialization of an oaCollection<> that supplies the collection
// of groups in a technology database.
// *****************************************************************************
template <>
class OA_TECH_DLL_API oaCollection<oaGroup, oaTech> : public oaGroupCollection {
public:
                            oaCollection(const oaObject *db,
                                         oaUInt4        nameIndexIn = oacNullIndex);
                            oaCollection(const oaObject *db,
                                         oaUInt4        filterFlags,
                                         oaUInt4        defIndexIn);
                            oaCollection(const oaCollection<oaGroup, oaTech> &c);
};



// *****************************************************************************
// oaCollection<oaConstraint, oaTech>
//
// This is the specialization of an oaCollection<> that supplies the collection
// of constraints in a technology database.
// *****************************************************************************
template <>
class OA_TECH_DLL_API oaCollection<oaConstraint, oaTech> : public oaConstraintCollection {
public:
                            oaCollection(const oaObject *db);
                            oaCollection(const oaObject *db,
                                         oaUInt4        defIndexIn);
                            oaCollection(const oaObject *db,
                                         oaUInt4        defIndexIn,
                                         oaUInt4        flagsIn,
                                         oaBoolean      iterAllIn = true);
                            oaCollection(const oaCollection<oaConstraint, oaTech> &c);
};



// *****************************************************************************
// oaCollection<oaLayerConstraint, oaConstraintGroup>
//
// This is the specialization for layer constraints in constraint group
// collections.
// *****************************************************************************
template <>
class OA_TECH_DLL_API oaCollection<oaLayerConstraint, oaConstraintGroup> : public oaConstraintInGroupCollection {
public:
                            oaCollection(const oaConstraintGroup    *group,
                                         oaLayerNum                 layer,
                                         const oaConstraintDef      *def,
                                         oaBoolean                  hardOnly);
                            oaCollection(const oaCollection<oaLayerConstraint, oaConstraintGroup> &c);

protected:
    virtual oaBoolean       isMatch(const oaConstraintGroupMemTbl   *mTbl,
                                    oaUInt4                         mIndex,
                                    const oaConstraint              *obj = NULL) const;

private:
    oaLayerNum              layer;

    friend class oaIter<oaLayerConstraint>;
};



// *****************************************************************************
// oaCollection<oaLayerPairConstraint, oaConstraintGroup>
//
// This is the specialization for layer pair constraints in constraint group
// collections.
// *****************************************************************************
template <>
class OA_TECH_DLL_API oaCollection<oaLayerPairConstraint, oaConstraintGroup> : public oaConstraintInGroupCollection {
public:
                            oaCollection(const oaConstraintGroup    *group,
                                         oaLayerNum                 layer,
                                         oaLayerNum                 layer2,
                                         const oaConstraintDef      *def,
                                         oaBoolean                  hardOnly);
                            oaCollection(const oaCollection<oaLayerPairConstraint, oaConstraintGroup> &c);

protected:
    virtual oaBoolean       isMatch(const oaConstraintGroupMemTbl   *mTbl,
                                    oaUInt4                         mIndex,
                                    const oaConstraint              *obj = NULL) const;
private:
    oaLayerNum              layer1;
    oaLayerNum              layer2;

    friend class oaIter<oaLayerPairConstraint>;
};



// *****************************************************************************
// oaCollection<oaLayerArrayConstraint, oaConstraintGroup>
//
// This is the specialization for layer array constraints in constraint group
// collections.
// *****************************************************************************
template <>
class OA_TECH_DLL_API oaCollection<oaLayerArrayConstraint, oaConstraintGroup> : public oaConstraintInGroupCollection {
public:
                            oaCollection(const oaConstraintGroup    *group,
                                         const oaLayerArray         &layersIn,
                                         const oaConstraintDef      *def,
                                         oaBoolean                  hardOnly);
                            oaCollection(const oaCollection<oaLayerArrayConstraint, oaConstraintGroup> &c);

protected:
    virtual oaBoolean       isMatch(const oaConstraintGroupMemTbl   *mTbl,
                                    oaUInt4                         mIndex,
                                    const oaConstraint              *obj = NULL) const;
private:
    oaLayerArray            layers;

    friend class oaIter<oaLayerArrayConstraint>;
};



// *****************************************************************************
// oaIter<oaLayerConstraint>
//
// These are the definitions of a specialized oaIter<> class and its methods.
// *****************************************************************************
template <>
class OA_TECH_DLL_API oaIter<oaLayerConstraint> : public oaConstraintInGroupIter {
public:
                            oaIter(const oaCollection<oaLayerConstraint, oaConstraintGroup> &c);
                            oaIter(const oaIter<oaLayerConstraint> &iterIn);

    oaLayerConstraint       *getNext();

private:
    virtual oaBoolean       isMatch(const oaConstraintGroupMemTbl   *tbl,
                                    oaUInt4                         index) const;
    oaLayerNum              layer;
};



// *****************************************************************************
// oaIter<oaLayerPairConstraint>
//
// These are the definitions of a specialized oaIter<> class and its methods.
// *****************************************************************************
template <>
class OA_TECH_DLL_API oaIter<oaLayerPairConstraint> : public oaConstraintInGroupIter {
public:
                            oaIter(const oaCollection<oaLayerPairConstraint, oaConstraintGroup> &c);
                            oaIter(const oaIter<oaLayerPairConstraint> &iterIn);

    oaLayerPairConstraint   *getNext();

private:
    virtual oaBoolean       isMatch(const oaConstraintGroupMemTbl   *tbl,
                                    oaUInt4                         index) const;

    oaLayerNum              layer1;
    oaLayerNum              layer2;
};



// *****************************************************************************
// oaIter<oaLayerArrayConstraint>
//
// These are the definitions of a specialized oaIter<> class and its methods.
// *****************************************************************************
template <>
class OA_TECH_DLL_API oaIter<oaLayerArrayConstraint> : public oaConstraintInGroupIter {
public:
                            oaIter(const oaCollection<oaLayerArrayConstraint, oaConstraintGroup> &c);
                            oaIter(const oaIter<oaLayerArrayConstraint> &iterIn);

    oaLayerArrayConstraint  *getNext();

private:
    virtual oaBoolean       isMatch(const oaConstraintGroupMemTbl   *tbl,
                                    oaUInt4                         index) const;

    const oaLayerArray      &layers;
};



END_OA_NAMESPACE

#endif

Return to top of page

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