carray.h

//==========================================================================
//  CARRAY.H - part of
//                     OMNeT++/OMNEST
//            Discrete System Simulation in C++
//
//==========================================================================

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

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

#ifndef __OMNETPP_CARRAY_H
#define __OMNETPP_CARRAY_H

#include "cownedobject.h"

namespace omnetpp {


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

     private:
        void advance();
        void retreat();

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

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

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

        _OPPDEPRECATED cObject *operator()() const {return operator*();}

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

        Iterator& operator++() {if (!end()) advance(); return *this;}

        Iterator operator++(int) {Iterator tmp(*this); if (!end()) advance(); return tmp;}

        Iterator& operator--() {if (!end()) retreat(); return *this;}

        Iterator operator--(int) {Iterator tmp(*this); if (!end()) retreat(); return tmp;}
    };

  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=nullptr, int capacity=0, int delta=10);

    virtual ~cArray();

    cArray& operator=(const cArray& list);


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

    virtual std::string str() const override;

    virtual void forEachChild(cVisitor *v) override;

    virtual void parsimPack(cCommBuffer *buffer) const override;

    virtual void parsimUnpack(cCommBuffer *buffer) override;


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

    virtual void clear();

    virtual int getCapacity() const {return capacity;}

    virtual void setCapacity(int capacity);

    virtual int add(cObject *obj);

    virtual int addAt(int m, cObject *obj);

    virtual int set(cObject *obj);

    virtual int find(cObject *obj) const;

    virtual int find(const char *objname) const;

    virtual cObject *get(int m);

    virtual cObject *get(const char *objname);

    virtual const cObject *get(int m) const;

    virtual 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);}

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

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

    virtual cObject *remove(int m);

    virtual cObject *remove(const char *objname);

    virtual cObject *remove(cObject *obj);


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

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

}  // namespace omnetpp


#endif