oaArray.h

Go to the documentation of this file.

// *****************************************************************************
// *****************************************************************************
// oaArray.h
//
// This file contains definitions of the oaArrayBase<>, oaArray<> and oaSubset
// class templates. The oaArrayBase<> class implements a template for an array
// of elements. The size of the array can be different than the number of
// elements actually stored. This is useful in situations where the array is
// being used as a buffer because it reduces the need to re-allocate the array.
//
// The oaArray<> template extends the oaArrayBase<> template with some higher-
// level operations that allow it to function more like a typical container.
//
// The oaSubset<> template is an ordered array for fast lookup.
//
// The oaManagedTypeArray is an ordered array of oaManagedTypes.
//
// *****************************************************************************
// 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(oaArray_P)
#define oaArray_P



// *****************************************************************************
// Nested includes
// *****************************************************************************
#include "oaBaseTypes.h"
#include "oaType.h"



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



// *****************************************************************************
// Forward Public Class Declarations
// *****************************************************************************
class oaFeature;
class oaObject;


// *****************************************************************************
// oaArrayBase
// *****************************************************************************
template <class T>
class oaArrayBase {
public:
                            oaArrayBase(oaUInt4 size = 0);
                            oaArrayBase(const oaArrayBase<T> &arrayIn);
                            oaArrayBase(const T arrayIn[],
                                        oaUInt4 numElementsIn);

                            ~oaArrayBase();

    oaArrayBase<T>          &operator=(const oaArrayBase<T> &arrayIn);

    const T                 *getElements() const;
    oaUInt4                 getNumElements() const;
    oaUInt4                 getSize() const;

    void                    setNumElements(oaUInt4 n);
    void                    setSize(oaUInt4     newSize,
                                    oaBoolean   saveElements = false);
    void                    set(const T *arrayIn,
                                oaUInt4 numElementsIn);

    const T                 &get(oaUInt4 index) const;
    T                       &get(oaUInt4 index);

    const T                 &operator[](oaUInt4 i) const;
    T                       &operator[](oaUInt4 i);

protected:
    void                    copyElements(T          *elementsTo,
                                         const T    *elementsFrom,
                                         oaUInt4    num);

    oaUInt4                 size;
    oaUInt4                 numElements;
    T                       *elements;
};



// *****************************************************************************
// oaArray
// *****************************************************************************
template <class T>
class oaArray : public oaArrayBase<T> {
public:
                            oaArray(oaUInt4 size = 0);
                            oaArray(const oaArray<T> &arrayIn);
                            oaArray(const T arrayIn[],
                                    oaUInt4 numElementsIn);

    virtual                 ~oaArray();

    oaUInt4                 find(const T &element) const;

    void                    append(const T &element);
    void                    append(const oaArray<T> &arrayIn);

    void                    remove(const T &element);

    void                    sort(int (*compare)(const T *,
                                                const T *));

    oaArray<T>              &operator=(const oaArray<T> &arrayIn);

    virtual oaBoolean       operator==(const oaArray<T> &other) const;
    oaBoolean               operator!=(const oaArray<T> &other) const;

protected:
    virtual void            copyElements(T          *elementsTo,
                                         const T    *elementsFrom,
                                         oaUInt4    num);
    virtual oaBoolean       cmpElements(const T *elementsOther,
                                        oaUInt4 num) const;
};



// *****************************************************************************
// oaSubset
// *****************************************************************************
template <class T>
class oaSubset : public oaArray<T> {
public:
                            oaSubset();

    void                    add(T type);
    oaBoolean               includes(T type) const;
};



// *****************************************************************************
// oaFeatureArray
// *****************************************************************************
class OA_BASE_DLL_API oaFeatureArray : public oaArray<oaFeature*> {
public:
                            oaFeatureArray(oaUInt4 sizeIn = 0);
};



// *****************************************************************************
// oaManagedTypeArray
// *****************************************************************************
class OA_BASE_DLL_API oaManagedTypeArray : public oaSubset<oaManagedType> {
};



// *****************************************************************************
// Explicit template instantiations
// *****************************************************************************
#if defined(OA_BASE_DLL_EXTERN)
OA_BASE_DLL_EXTERN template
 class OA_BASE_DLL_API oaArray<oaString>;

OA_BASE_DLL_EXTERN template
 class OA_BASE_DLL_API oaArray<oaFeature*>;

OA_BASE_DLL_EXTERN template
 class OA_BASE_DLL_API oaArray<oaUInt4>;

OA_BASE_DLL_EXTERN template
 class OA_BASE_DLL_API oaArray<oaObject*>;

OA_BASE_DLL_EXTERN template
 class OA_BASE_DLL_API oaArray<oaArray<oaUInt4> >;
#endif



END_OA_NAMESPACE

#endif

Return to top of page

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