---

mpackarray.h

#ifndef __PACKARRAY_H__
#define __PACKARRAY_H__

#include "magic/mobject.h"
#include "magic/mmagisupp.h"


//                                                                          //
//        ----              |     _                         /    \          //
//        |   )  ___   ___  |    / \           ___         /      \         //
//        |---   ___| |   \ | / /   \ |/\ |/\  ___| \   | <        >        //
//        |     (   | |     |/  |---| |   |   (   |  \  |  \      /         //
//        |      \__|  \__/ | \ |   | |   |    \__|   \_/   \    /          //
//                                                   \_/                    //

template <class TYPE>
class PackArray : public Object {
  public:
    TYPE*   data;

    int     size;

    PackArray   () {
        data = NULL;
        size = 0;
    }

    PackArray   (int siz) {
        data = NULL;
        size = siz;
        make (size);
    }

    PackArray   (const PackArray& orig) {
        data = NULL;
        make (orig.size);
        for (int i=0; i<size; i++)
            data[i] = orig.data[i];
    }

    void    make    (int siz) {
        if (data)
            destroy ();
        size = siz;
        if (size>0)
            data = new TYPE [size];
        else
            data = NULL;
    }

    ~PackArray  () {
        destroy ();
    }

    void    shallowCopy (const PackArray& orig) {
        if (size != orig.size)
            make (orig.size);
        memcpy (data, orig.data, size*sizeof(TYPE));
    }
    
    void    destroy () {
        delete data;
        data = NULL;
        size = 0;
    }

    void    empty () {
        destroy ();
    }

    const TYPE& operator[]  (int i) const {
        ASSERTWITH (i>=0 && i<size,
                    format("Index %d out of PackArray (size %d) bounds", i, size));
        return data [i];
    }

    TYPE&   operator[]  (int i) {
        ASSERTWITH (i>=0 && i<size,
                    format("Index %d out of PackArray (size %d) bounds", i, size));
        return data [i];
    }

    TYPE&   operator=   (const PackArray& other) {
        if (this != &other) {
            destroy ();
            if (other.size) {
                data = new TYPE [other.size];
                size = other.size;
                for (int i=0; i<size; i++)  // We have to copy these explicitly
                    data[i] = other.data[i];
            }
        }
        return *this;
    }

    /*
    void    removeFill  (int pos) {
        ASSERTWITH (i>=0 && i<size,
                    format("Index %d out of PackArray (size %d) bounds", i, size));
        delete data[pos];
        for (int i=pos; i<size-2; i++)
            data[i] = data[i+1];
        data[size-1]=NULL;
        resize (size-1);
    }
    */
    
    void    resize  (int newsize) {
        ASSERT (newsize>=0);
        
        if (newsize == size)
            return;

        if (newsize>0)
            if (data)
                data = (TYPE*) renew (data, sizeof (TYPE)*newsize);
            else
                data = new TYPE [newsize];
        else
            destroy ();

        size = newsize;
    }

    /*
    virtual CArchive&   operator>>  (CArchive& arc) const {
        arc << size;
        for (int i=0; i<size; i++)
            arc << data[i];
        return arc;
    }
    */
    
    /*
    virtual IStream&    operator<<  (IStream& arc) {
        int nsize;
        arc >> nsize;
        destroy ();
        make (nsize);
        for (int i=0; i<size; i++)
            arc >> data[i];
        return arc;
    }
    */

    virtual void    check   () const {
        ASSERT ((data?1:0) == (size?1:0));
        ASSERT (((unsigned int&)*this) != 0xdddddddd);
        if (data)
            ASSERT (((unsigned int&)*data) != 0xdddddddd);
        ASSERT (size>=0);
        ASSERTWITH (size<10000000, "Reasonable array size maximum. Grow if necessary");
    }

  private:
};

#endif

---