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);}
 
        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 = nullptr; // vector of objects
    int capacity = 0;         // allocated size of vect[]
    int delta;                // if needed, grows by delta
    int firstfree = 0;        // first free position in vect[]
    int last = -1;            // 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