oaBaseCollection.h

Go to the documentation of this file.

// *****************************************************************************
// *****************************************************************************
// oaBaseCollection.h
//
// This file contains the definitions for collections and iterators and their
// supporting classes used in oaBase 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(oaBaseCollection_P)
#define oaBaseCollection_P



// *****************************************************************************
// Nested includes
// *****************************************************************************
#include "oaGroup.h"
#include "oaAppDef.h"
#include "oaCollection.h"



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



// *****************************************************************************
// Forward Class Declarations
// *****************************************************************************
template <class obj>
class oaIter;
class oaGroupTbl;
class oaConstraint;
class oaAppObjectDef;
class oaAppObjectCollection;
class oaGroupMemTbl;
class oaConstraintGroup;
class oaConstraintDef;
class oaConstraintGroupMemTbl;
class oaConstraintGroupTbl;
class oaSimpleConstraint;
class oaDatabase;
class oaAppObject;
class oaSession;
class oaAppDataTbl;
class oaGroup;
class oaGroupDef;
class oaGroupMember;
class oaConstraintDef;
class oaSession;
class oaConstraintParamDef;
class oaConstraintGroupDef;


// *****************************************************************************
// oaDatabaseCollection
//
// This is the base class for the collections of the open databases.
// *****************************************************************************
class OA_BASE_DLL_API oaDatabaseCollection {
public:
                            oaDatabaseCollection(oaUInt4 dbIDIn);
                            oaDatabaseCollection(const oaDatabaseCollection &c);

    oaUInt4                 getCount() const;
    oaBoolean               isEmpty() const;
    oaBoolean               includes(const oaObject *database) const;

protected:
    oaUInt4                 dbID;

    friend class oaDatabaseIter;
};



// *****************************************************************************
// oaDatabaseIter
//
// This is the base class for the iterators of the open databases.
// *****************************************************************************
class OA_BASE_DLL_API oaDatabaseIter {
public:
                            oaDatabaseIter(const oaDatabaseCollection &coll);
                            oaDatabaseIter(const oaDatabaseIter &iterIn);

    oaObject                *getNext();
    void                    reset();

protected:
    oaUInt4                 dbID;
    oaUInt4                 index;
};



// *****************************************************************************
// oaCollection<oaProp, oaObject>
//
// These are the specialized definitions of an oaCollection<> class and its
// methods.
// *****************************************************************************
template <>
class OA_BASE_DLL_API oaCollection<oaProp, oaObject> {
public:
                            oaCollection(const oaObject *object);
                            oaCollection(const oaCollection<oaProp, oaObject> &c);

    oaUInt4                 getCount() const;
    oaBoolean               isEmpty() const;
    oaBoolean               includes(const oaProp *object) const;

private:
    void                    *tbl;
    oaUInt4                 objDataType;
    oaUInt4                 objIndex;
    oaDomain                objDomain;

    friend class oaIter<oaProp>;
};



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

    oaProp                  *getNext();
    void                    reset();

private:
    void                    *tbl;
    oaUInt4                 index;
    oaUInt4                 objDataType;
    oaUInt4                 objIndex;
    oaDomain                objDomain;
};



// *****************************************************************************
// oaCollection<oaGroupMember, oaObject>
//
// These are the specialized definitions of an oaCollection<> class and its
// methods.
// *****************************************************************************
template <>
class OA_BASE_DLL_API oaCollection<oaGroupMember, oaObject> {
public:
                            oaCollection(const oaObject *object,
                                         oaUInt4        flagsIn = 0);
                            oaCollection(const oaCollection<oaGroupMember, oaObject> &c);

    oaUInt4                 getCount() const;
    oaBoolean               isEmpty() const;
    oaBoolean               includes(const oaGroupMember *object) const;

private:
    void                    *tbl;
    oaUInt4                 flags;
    oaUInt4                 objDataType;
    oaUInt4                 objIndex;
    oaDomain                objDomain;

    friend class oaIter<oaGroupMember>;
};



// *****************************************************************************
// oaIter<oaGroupMember>
//
// These are the definitions of a specialized oaIter<> class and its methods.
// *****************************************************************************
template <>
class OA_BASE_DLL_API oaIter<oaGroupMember> {
public:
                            oaIter(const oaCollection<oaGroupMember, oaGroup> &c);
                            oaIter(const oaCollection<oaGroupMember, oaObject> &c);
                            oaIter(const oaIter<oaGroupMember> &iterIn);

    oaGroupMember           *getNext();
    void                    reset();

private:
    enum oaGroupMemIterType {
        oacGroupGroupMemIterType    = 0,
        oacObjectGroupMemIterType   = 1
    };

    void                    *tbl;
    void                    *assocTbl;
    oaGroupMemIterType      type;
    oaUInt4                 assocIndex;
    oaUInt4                 ownerDataType;
    oaUInt4                 ownerIndex;
    oaDomain                ownerDomain;
    oaUInt4                 flags;
};



// *****************************************************************************
// oaGroupCollection
//
// This is the base class for group in database collections. The filter flags
// are stored in domainFlags and the index into the name table is stored in
// nameIndex for name based iterations.  If a def base iteration is intended
// then the oacGroupIterGroupDef flag needs to be set in the domainFlags. The
// session group def index will then be stored in defIndex.
// *****************************************************************************
class OA_BASE_DLL_API oaGroupCollection {
public:
                            oaGroupCollection(const oaObject    *database,
                                              oaUInt4           domainFlags,
                                              oaUInt4           nameIndexIn);
                            oaGroupCollection(const oaGroupCollection &c);

    oaUInt4                 getCount() const;
    oaBoolean               isEmpty() const;
    oaBoolean               includes(const oaGroup *object) const;

private:
    oaGroupTbl              *tbl;
    oaUInt4                 domainFlags;
    union {
        oaUInt4             nameIndex;
        oaUInt4             defIndex;
    };

    friend class oaIter<oaGroup>;
};



// *****************************************************************************
// oaCollection<oaGroup, oaObject>
//
// These are the specialized definitions of an oaCollection<> class and its
// methods.
// *****************************************************************************
template <>
class OA_BASE_DLL_API oaCollection<oaGroup, oaObject> {
public:
                            oaCollection(const oaObject *object);
                            oaCollection(const oaCollection<oaGroup, oaObject> &c);

    oaUInt4                 getCount() const;
    oaBoolean               isEmpty() const;
    oaBoolean               includes(const oaGroup *object) const;

private:
    oaGroupTbl              *tbl;
    oaUInt4                 objDataType;
    oaUInt4                 objIndex;
    oaDomain                objDomain;

    friend class oaIter<oaGroup>;
};



// *****************************************************************************
// oaIter<oaGroup>
//
// These are the definitions of a specialized oaIter<> class and its methods.
// *****************************************************************************
template <>
class OA_BASE_DLL_API oaIter<oaGroup> {
public:
                            oaIter(const oaGroupCollection &c);
                            oaIter(const oaCollection<oaGroup, oaObject> &c);
                            oaIter(const oaIter<oaGroup> &iterIn);

    oaGroup                 *getNext();
    void                    reset();

private:
    enum oaGroupIterType {
        oacInDatabaseGroupIterType  = 0,
        oacByNameGroupIterType      = 1,
        oacObjectGroupIterType      = 2,
        oacEmptyGroupIterType       = 3,
        oacByDefGroupIterType       = 4
    };

    oaGroupTbl              *tbl;
    oaGroupMemTbl           *memTbl;
    oaGroupIterType         type;
    union {
        oaUInt4             nameIndex;
        oaUInt4             objIndex;
        oaUInt4             defIndex;
    };
    union {
        oaUInt4             domainFlags;
        oaUInt4             objDataType;
    };
    oaDomainEnum            objDomain;
    oaUInt4                 index;
};



// *****************************************************************************
// oaConstraintCollection
//
// This is the base class for constraint database collections.
// *****************************************************************************
class OA_BASE_DLL_API oaConstraintCollection {
public:
                            oaConstraintCollection(const oaObject *database);
                            oaConstraintCollection(const oaObject   *database,
                                                   oaUInt4          defIndex);
                            oaConstraintCollection(const oaConstraintCollection &c);

    oaUInt4                 getCount() const;
    oaBoolean               isEmpty() const;
    oaBoolean               includes(const oaConstraint *constraint) const;

    void                    *getTbl() const;
    oaBoolean               getIterAll() const;
    oaUInt4                 getDefIndex() const;

protected:
    void                    *tbl;
    oaBoolean               iterAll;
    oaUInt4                 defIndex;

    friend class oaIter<oaConstraint>;
};



// *****************************************************************************
// oaConstraintInGroupCollection
//
// This is the base class for constraint in constraint group collections.
// *****************************************************************************
class OA_BASE_DLL_API oaConstraintInGroupCollection {
public:
                            oaConstraintInGroupCollection(const oaConstraintGroup   *group,
                                                          const oaConstraintDef     *def,
                                                          oaBoolean                 hardOnly);
                            oaConstraintInGroupCollection(const oaConstraintInGroupCollection &c);

    oaUInt4                 getCount() const;
    oaBoolean               isEmpty() const;
    oaBoolean               includes(const oaConstraint *object) const;

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

    oaUInt4                 traverse(const oaConstraintGroupMemTbl  *memTbl,
                                     oaUInt4                        startIndex,
                                     oaBoolean                      stopOnFirst = false,
                                     const oaConstraint             *obj = NULL) const;

    oaConstraintGroupTbl    *gTbl;
    oaUInt4                 gIndex;
    oaUInt4                 defIndex;
    oaBoolean               hard;

    friend class oaConstraintInGroupIter;
};



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



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



// *****************************************************************************
// oaConstraintInGroupIter
//
// This is the definition of the base iterator for iterating over constraints
// in a group.
// *****************************************************************************
class OA_BASE_DLL_API oaConstraintInGroupIter {
public:
    virtual void            reset();
    virtual                 ~oaConstraintInGroupIter();

protected:
                            oaConstraintInGroupIter(const oaConstraintInGroupCollection &c);
                            oaConstraintInGroupIter(const oaConstraintInGroupIter &iterIn);
                            oaConstraintInGroupIter();

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

    oaConstraint            *getNextInGroup();

    void                    findNext(oaUInt4 startIndex);
    void                    resize(oaUInt4 newSize);

    oaConstraintInGroupIter &operator=(const oaConstraintInGroupIter &iterIn);

    void                    *gTbl;
    oaUInt4                 gIndex;
    oaUInt4                 defIndex;
    oaBoolean               hard;

    void                    **memTbl;
    void                    *memIndex;
    oaUInt4                 stackSize;
    oaUInt4                 position;
    oaUInt4                 index;

    friend class oaConstraintInGroupCollection;
};



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

    oaConstraint            *getNext();
    virtual void            reset();

private:
    enum oaConstraintIterType {
        oacAllInDatabaseIterType    = 0,
        oacByConstraintDefIterType  = 1,
        oacAllInGroupIterType       = 2
    };

    void                    *tbl;
    oaConstraintIterType    type;
};



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

    oaSimpleConstraint      *getNext();
};



// *****************************************************************************
// Explicit template instantiations
// *****************************************************************************
#if defined(OA_BASE_DLL_EXTERN)
OA_BASE_DLL_EXTERN template
 class OA_BASE_DLL_API oaCollection<oaGroupMember, oaGroup>;
OA_BASE_DLL_EXTERN template
 class OA_BASE_DLL_API oaCollection<oaConstraintParamDef, oaSession>;
OA_BASE_DLL_EXTERN template
 class OA_BASE_DLL_API oaCollection<oaConstraintDef, oaSession>;
OA_BASE_DLL_EXTERN template
 class OA_BASE_DLL_API oaCollection<oaGroupDef, oaSession>;
OA_BASE_DLL_EXTERN template
 class OA_BASE_DLL_API oaCollection<oaConstraintGroupDef, oaSession>;
#endif



// *****************************************************************************
// oaCollection<oaAppDef, oaObject>
//
// These are the specialized definitions of an oaCollection<> class and its
// methods.
// *****************************************************************************
template <>
class OA_BASE_DLL_API oaCollection<oaAppDef, oaObject> {
public:
                            oaCollection(const oaObject *object);
                            oaCollection(const oaObject *object,
                                         oaUInt4        dtIndex,
                                         oaDomain       domain = oacNoDomain);
                            oaCollection(const oaCollection<oaAppDef, oaObject> &c);

    oaUInt4                 getCount() const;
    oaBoolean               isEmpty() const;
    oaBoolean               includes(const oaAppDef *object) const;

private:
    oaAppDataTbl            *tbl;
    oaUInt4                 objDtIndex;
    oaUInt4                 objIndex;
    oaDomain                objDomain;

    friend class oaIter<oaAppDef>;
};



// *****************************************************************************
// oaCollection<oaAppDef, oaSession>
//
// These are the specialized definitions of an oaCollection<> class and its
// methods.
// *****************************************************************************
template <>
class OA_BASE_DLL_API oaCollection<oaAppDef, oaSession> {
public:
    oaUInt4                 getCount() const;
    oaBoolean               isEmpty() const;

    friend class oaIter<oaAppDef>;
};



// *****************************************************************************
// oaIter<oaAppDef>
//
// These are the definitions of a specialized oaIter<> class and its methods.
// *****************************************************************************
template <>
class OA_BASE_DLL_API oaIter<oaAppDef> {
public:
                            oaIter(const oaCollection<oaAppDef, oaSession> &c);
                            oaIter(const oaCollection<oaAppDef, oaObject> &c);
                            oaIter(const oaIter<oaAppDef> &iterIn);

    oaAppDef                *getNext();
    void                    reset();

private:
    oaAppDataTbl            *tbl;
    oaUInt4                 objIndex;
    oaUInt4                 objDtIndex;
    oaDomainEnum            objDomain;
    oaUInt4                 index;
};



// *****************************************************************************
// oaAppObjectDefCollection
//
// This is the base class for appObjectDef collections in databases.
// *****************************************************************************
class OA_BASE_DLL_API oaAppObjectDefCollection {
public:
                            oaAppObjectDefCollection(const oaObject *database);
                            oaAppObjectDefCollection(const oaAppObjectDefCollection &c);

    oaUInt4                 getCount() const;
    oaBoolean               isEmpty() const;
    oaBoolean               includes(const oaAppObjectDef *object) const;

private:
    oaDatabase              *db;

    friend class oaIter<oaAppObjectDef>;
};



// *****************************************************************************
// oaCollection<oaAppObjectDef, oaSession>
//
// These are the specialized definitions of an oaCollection<> class and its
// methods.
// *****************************************************************************
template <>
class OA_BASE_DLL_API oaCollection<oaAppObjectDef, oaSession> {
public:
    oaUInt4                 getCount() const;
    oaBoolean               isEmpty() const;
};



// *****************************************************************************
// oaIter<oaAppObjectDef>
//
// These are the definitions of a specialized oaIter<> class and its methods.
// *****************************************************************************
template <>
class OA_BASE_DLL_API oaIter<oaAppObjectDef> {
public:
                            oaIter(const oaAppObjectDefCollection &c);
                            oaIter(const oaCollection<oaAppObjectDef, oaSession> &c);
                            oaIter(const oaIter<oaAppObjectDef> &iterIn);

    oaAppObjectDef          *getNext();
    void                    reset();

private:
    oaDatabase              *db;
    oaUInt4                 index;
};



// *****************************************************************************
// oaCollection<oaAppObject>
//
// This is the base class for app objects in database collections.
// *****************************************************************************
class OA_BASE_DLL_API oaAppObjectCollection {
public:
                            oaAppObjectCollection(const oaObject        *database,
                                                  const oaAppObjectDef  *def);
                            oaAppObjectCollection(const oaAppObjectCollection &c);

    oaUInt4                 getCount() const;
    oaBoolean               isEmpty() const;
    oaBoolean               includes(const oaAppObject *object) const;

private:
    void                    *db;
    oaUInt4                 id;

    friend class oaIter<oaAppObject>;
};



// *****************************************************************************
// oaIter<oaAppObject>
//
// These are the definitions of a specialized oaIter<> class and its methods.
// *****************************************************************************
template <>
class OA_BASE_DLL_API oaIter<oaAppObject> {
public:
                            oaIter(const oaAppObjectCollection &c);
                            oaIter(const oaIter<oaAppObject> &iterIn);

    oaAppObject             *getNext();
    void                    reset();
    void                    reset(const oaAppObjectCollection &c);

private:
    void                    *db;
    void                    *tbl;
    oaUInt4                 id;
    oaUInt4                 index;
};



END_OA_NAMESPACE

#endif

Return to top of page

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