carray.h

//==========================================================================
//  CARRAY.H - part of
//                     OMNeT++/OMNEST
//            Discrete System Simulation in C++
//
//
//  Declaration of the following classes:
//    cArray : flexible array to store cObject objects
//
//==========================================================================

/*--------------------------------------------------------------*
  Copyright (C) 1992-2008 Andras Varga
  Copyright (C) 2006-2008 OpenSim Ltd.

  This file is distributed WITHOUT ANY WARRANTY. See the file
  `license' for details on this and other legal matters.
*--------------------------------------------------------------*/

#ifndef __CARRAY_H
#define __CARRAY_H

#include "cownedobject.h"

NAMESPACE_BEGIN


class SIM_API cArray : public cOwnedObject
{
  public:
    class Iterator
    {
      private:
        cArray *array;
        int k;

      public:
        Iterator(const cArray& a, bool athead=true)  {init(a, athead);}

        void init(const cArray& a, bool athead=true);

        cObject *operator()()  {return array->get(k);}

        bool end() const   {return k<0 || k>=array->size();}

        cObject *operator++(int);

        cObject *operator--(int);
    };

  private:
    enum {FL_TKOWNERSHIP = 4};
    cObject **vect;   // vector of objects
    int capacity;     // allocated size of vect[]
    int delta;        // if needed, grows by delta
    int firstfree;    // first free position in vect[]
    int last;         // last used position

  private:
    void copy(const cArray& other);

  public:

    cArray(const cArray& list);

    explicit cArray(const char *name=NULL, int capacity=0, int delta=10);

    virtual ~cArray();

    cArray& operator=(const cArray& list);


    virtual cArray *dup() const  {return new cArray(*this);}

    virtual std::string info() const;

    virtual void forEachChild(cVisitor *v);

    virtual void parsimPack(cCommBuffer *buffer);

    virtual void parsimUnpack(cCommBuffer *buffer);


    int size() const {return last+1;}

    void clear();

    int getCapacity() const {return capacity;}

    void setCapacity(int capacity);

    int add(cObject *obj);

    int addAt(int m, cObject *obj);

    int set(cObject *obj);

    int find(cObject *obj) const;

    int find(const char *objname) const;

    cObject *get(int m);

    cObject *get(const char *objname);

    const cObject *get(int m) const;

    const cObject *get(const char *objname) const;

    cObject *operator[](int m)  {return get(m);}

    cObject *operator[](const char *objname)  {return get(objname);}

    const cObject *operator[](int m) const  {return get(m);}

    const cObject *operator[](const char *objname) const  {return get(objname);}

    bool exist(int m) const  {return m>=0 && m<=last && vect[m]!=NULL;}

    bool exist(const char *objname) const  {return find(objname)!=-1;}

    cObject *remove(int m);

    cObject *remove(const char *objname);

    cObject *remove(cObject *obj);


    void setTakeOwnership(bool tk) {setFlag(FL_TKOWNERSHIP,tk);}

    bool getTakeOwnership() const   {return flags&FL_TKOWNERSHIP;}
};

NAMESPACE_END


#endif