oaCollection.h

Go to the documentation of this file.

// *****************************************************************************
// *****************************************************************************
// oaCollection.h
//
// This file contains the definitions for collections and iterators and their
// supporting classes. The supporting classes include:
//
//  oaBaseCollection
//      This is the base class for the oaCollection class.
//
//  oaCollection
//      This class implements a collection of database objects.
//
//  oaEnumCollection
//      This class implements a collection over a oaEnumProp values. It's a
//      special case collection because it constructs an iterator that returns
//      a oaString instead of a database object.
//
//  oaBaseIter
//      This is the base class for the oaIter class.
//
//  oaIter
//      This class implements an templated iterator. It iterates over objects
//      in a collection.
//
//  oaEnumIter
//      This class implements a special case iterator. It returns a oaString
//      which contains the name of an enumeration value.
//
// *****************************************************************************
// 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(oaCollection_P)
#define oaCollection_P



// *****************************************************************************
// Nested includes
// *****************************************************************************
#include "oaObject.h"



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



// *****************************************************************************
// Forward Class Declarations
// *****************************************************************************
class oaDatabase;



// *****************************************************************************
// oaCollTypeEnum
// *****************************************************************************
enum oaCollTypeEnum {
    oacBaseCollType         = 0,
    oacDomainBaseCollType   = 1,
    oacAllCollType          = 2,
    oacGenericCollType      = 3,
    oacEmptyCollType        = 7
};



// *****************************************************************************
// oaBaseCollection
// *****************************************************************************
class OA_BASE_DLL_API oaBaseCollection {
public:
                            oaBaseCollection(const oaObject *object,
                                             oaUInt4        dataTypeIn);
                            oaBaseCollection(const oaObject *object,
                                             oaUInt4        dataTypeIn,
                                             oaDomain       domain);
                            oaBaseCollection(const oaObject *object,
                                             oaUInt4        assocDataType,
                                             oaDomain       domain,
                                             oaCollTypeEnum typeIn,
                                             oaUInt4        flagsIn,
                                             oaUInt4        objFlagsIn,
                                             const oaObject *scopeObjIn = NULL);
                            oaBaseCollection(const oaBaseCollection &coll);

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

    void                    *owner;
    void                    *scopeObj;

    oaCollTypeEnum          type;

    oaDomain                ownerDomain;
    oaUInt4                 ownerDataType;
    oaUInt4                 ownerIndex;
    oaDomain                objDomain;
    oaUInt4                 objDataType;
    oaUInt4                 scopeIndex;
    oaUInt4                 objFlags;
    oaUInt4                 flags;
};



// *****************************************************************************
// oaBaseIter
// *****************************************************************************
class OA_BASE_DLL_API oaBaseIter {
public:
                            oaBaseIter(const oaBaseCollection &coll);
                            oaBaseIter(const oaBaseIter &iter);

    oaObject                *getNext();
    void                    reset();

    void                    *owner;
    void                    *objTbl;
    void                    *scopeObj;

    oaCollTypeEnum          type;

    oaDomain                objDomain;
    oaUInt4                 objDataType;
    oaDomain                ownerDomain;
    oaUInt4                 ownerDataType;
    oaUInt4                 ownerIndex;
    oaUInt4                 scopeIndex;
    oaUInt4                 objFlags;
    oaUInt4                 flags;

    oaUInt4                 index;
    oaUInt4                 index1;
};



// *****************************************************************************
// oaCollection
// *****************************************************************************
template <class obj, class container>
class OA_DLL_EXPORT oaCollection : public oaBaseCollection {
public:
                            oaCollection(const oaObject *db,
                                         oaUInt4        dataTypeIn);
                            oaCollection(const oaObject *db,
                                         oaUInt4        dataTypeIn,
                                         oaDomain       domainIn);
                            oaCollection(const oaObject *object,
                                         oaUInt4        assocDataType,
                                         oaDomain       domainIn,
                                         oaCollTypeEnum collTypeIn,
                                         oaUInt4        flagsIn,
                                         oaUInt4        objFlagsIn,
                                         const oaObject *scopeObj = NULL);
                            oaCollection(const oaCollection<obj, container> &coll);

    oaBoolean               includes(const obj *o);
};



// *****************************************************************************
// oaIter
// *****************************************************************************
template <class obj>
class oaIter : public oaBaseIter {
public:
                            oaIter(const oaBaseCollection &coll);
                            oaIter(const oaIter<obj> &iterIn);

    obj                     *getNext();
};



// *****************************************************************************
// oaEnumIterState
// *****************************************************************************
class OA_BASE_DLL_API oaEnumIterState {
public:
                            oaEnumIterState(oaDatabase  *db,
                                            oaObject    *objIn);

    virtual oaBoolean       getNext(oaString &enumVal) = 0;
    virtual void            reset() = 0;
    virtual oaEnumIterState *copy() = 0;

protected:
    oaDatabase              *database;
    oaObject                *object;
};



// *****************************************************************************
// oaEnumIter
// *****************************************************************************
class OA_BASE_DLL_API oaEnumPropIter {
public:
                            oaEnumPropIter(oaEnumIterState *sub);
                            oaEnumPropIter(oaEnumPropIter &iterIn);

                            ~oaEnumPropIter();

    oaEnumPropIter          &operator=(oaEnumPropIter &iterIn);

    oaBoolean               getNext(oaString &enumV);

    void                    reset();

protected:
    oaEnumIterState         *state;
};



// *****************************************************************************
// oaEnumCollection
// *****************************************************************************
class OA_BASE_DLL_API oaEnumCollection {
public:
                            oaEnumCollection(oaDatabase *db,
                                             oaObject   *objIn);

                            operator oaEnumIterState *();

    oaUInt4                 getCount();
    oaBoolean               isEmpty();

protected:
    oaDatabase              *database;
    oaObject                *object;
};



END_OA_NAMESPACE

#endif

Return to top of page

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