---

mpararr.h

Go to the documentation of this file.

/***************************************************************************
    copyright            : (C) 1999 by Marko Grönroos, All Rights Reserved
    email                : magi@iki.fi
**/

#ifndef __PARARR_H__
#define __PARARR_H__

#include <stdlib.h>

#include <magic/mobject.h>
#include <magic/mstring.h>
#include <magic/marchive.h>
#include <magic/mmagisupp.h>

// External:

//FormatOStream& operator<< (FormatOStream& dc, int i) {;}

/*
#ifdef new
#undef new
#define new_UNDEFD
#define renew realloc
#endif
*/

BEGIN_NAMESPACE (MagiC);

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

template <class TYPE>
class Array : public Object {
    bool    mIsRef;
    int     mSize;
    TYPE**  rep;
  public:


    Array   (int siz=0) {
        mSize  = 0;
        rep    = NULL;
        mIsRef = false;
        make (siz);
    }
    
    Array (const Array<TYPE>& orig) {
        mSize  = 0;
        rep    = NULL;
        mIsRef = false;
        operator= (orig);
    }
    
    void    make    (int siz) {
        if (mSize) {
            empty ();
            delete rep;
            rep=NULL;
            mSize=0;
        }
        if (siz>0) {
            mSize = siz;
            ASSERTWITH (rep=new TYPE*[mSize], "Out of memory in array memory allocation");
            for (int i=0; i<mSize; i++)
                rep[i] = NULL;
        }
    }

    void    isRef   (bool isref) {mIsRef=isref;}
    
    virtual ~Array () {
        empty ();
        delete rep;
        memset (this, 0xcd, sizeof(Array<TYPE>));
    }

    void    empty   () {
        if (rep)
            for (int i=0;i<mSize;i++) {
                if (!mIsRef)
                    delete rep[i];
                rep[i] = NULL;
            }
    }

    void    add (TYPE* i) {
        resize (mSize + 1);
        delete rep [mSize - 1];
        rep[mSize - 1] = i;
    }

    void    add (const TYPE& i) {
        resize (mSize + 1);
        delete rep [mSize-1];
        if (mIsRef)
            rep[mSize-1] = const_cast<TYPE*>(&i);
        else
            rep[mSize-1] = new TYPE (i);
    }

    void    put (TYPE* i, int loc) {
        ASSERTWITH (i!=NULL, "NULL-objekti put");
        if (loc<0 || loc>=mSize)
            throw out_of_range ((CONSTR)
                format("Index put %d out of Array bounds (size %d)", loc, mSize));
        if (!mIsRef)
            delete rep [loc];
        rep [loc] = i;
    }

    void    put (const TYPE& i, int loc) {
        if (loc >= mSize)
            resize (loc+1);
        if (!mIsRef) {
            delete rep [loc];
            rep[loc] = new TYPE (i);
        } else
            rep[loc] = const_cast<TYPE*>(&i);
    }

    // Lisää objektin johonkin paikkaan vektoria, muutoin loppuun
    void    put (TYPE* p) {
        for (int i=0; i < mSize; i++)
            if (!rep[i]) {
                rep [i] = p;
                return;
            }
        add (p);
    }

    const TYPE& operator[]	(int loc) const {
        ASSERTWITH (loc < mSize, format("Index %d out of Array bounds (size %d)", loc, mSize));
        if (const TYPE* tmp = rep [loc])
            return *tmp;
        else if (mIsRef)
            return *((TYPE*)NULL);
        else
            return *(rep [loc] = new TYPE ());
    }

    TYPE&   operator[]	(int loc) {
        ASSERTWITH (loc < mSize, format("Index %d out of Array bounds (size %d)", loc, mSize));
        if (TYPE* tmp = rep [loc])
            return *tmp;
        else if (mIsRef)
            return *((TYPE*)NULL);
        else
            return *(rep [loc] = new TYPE ());
    }
    
    const TYPE* getp    (int loc) const {
        ASSERTWITH (loc < mSize, format("Index %d out of Array bounds (size %d)", loc, mSize));
        return rep [loc];
    }

    TYPE*   getp    (int loc) {
        ASSERTWITH (loc < mSize, format("Index %d out of Array bounds (size %d)", loc, mSize));
        return rep [loc];
    }

    int     find    (const TYPE& item) const {
        for (int i=0; i<mSize; i++)
            if (rep[i] == &item)
                return i;
        return -1;
    }

    void    remove  (int loc) {
        ASSERTWITH (loc < mSize, format("Index %d out of Array bounds (size %d)", loc, mSize));
        delete rep[loc];
        rep[loc] = NULL;
    }

    // Poista objekti ja täytä aukko
    void    removeFill  (int loc) {
        ASSERTWITH (loc < mSize, format("Index %d out of Array bounds (size %d)", loc, mSize));
        delete rep[loc];
        for (int i=loc+1; i<mSize; i++)
            rep[i-1]=rep[i];
        rep[mSize-1] = NULL;
        resize (mSize-1);
    }
    
    void    cut     (int loc) {
        ASSERTWITH (loc < mSize, format("Index %d out of Array bounds (size %d)", loc, mSize));
        rep[loc] = NULL;
    }
    
    void    resize  (int newsize) {
        /* Muuttaa taulukon kokoa, old[lower] = new[lower] */
        if (newsize < mSize) { /* Pienennetään */
            for (int i=newsize; i<mSize; i++)
                delete rep [i];
            if (newsize==0) {
                delete rep;
                rep = NULL;
            } else
                rep = (TYPE**) renew (rep, sizeof (TYPE*)*(newsize));
        } else { /* Suurennetaan */
            if (rep)
                rep = (TYPE**) renew (rep, sizeof (TYPE*)*(newsize));
            else
                rep = (TYPE**) new TYPE* [newsize];
            for (int i=mSize; i<newsize; i++)
                rep [i] = NULL;
        }
        mSize   = newsize;
    }

    void    operator=	(const Array<TYPE>& other) {
        empty ();
        make (other.mSize);
        for (int i=0; i<other.mSize; i++)
            if (other.rep[i])
                put (*other.rep[i], i);
    }

    /* Currently not in use before I get new stream classes done.
    CArchive&   operator>>  (CArchive& arc) const {
        arc.name("lower") << lower;
        arc.name("size") << size;
        for (int i=0; i<size; i++)
            arc << ((Object&) (*this)[i]);
        return arc;
    }
    */

    /* Currently not in use before I get new stream classes done.
    IStream&    operator<<  (IStream& arc) {
        int nlower, nsize;
        arc >> nlower;
        arc >> nsize;
        resize (nlower, nlower+nsize-1);
        for (int i=0; i<size; i++) {
            arc >> ((Object&) (*this)[i]);
        }
        return arc;
    }
    */

    virtual void    check   () const {
        ASSERT (mSize>=0);
    }

    void    quicksort   () {
        qsort (rep, mSize, sizeof (TYPE*), compareComparable);
    }

    int     size        () const {
        return mSize;
    }

    class iterator {
        const Array<TYPE>&  arr;
        int                 i;
        
      public:
                        iterator                (const iterator& o) : arr (o.arr) {i=o.i;}
                        iterator                (const Array<TYPE>& ar) : arr (ar) {i=0;}
        
        void            first                   () {i=0;}
        void            next                    () {i++;}
        int             exhausted               () const {return i>=arr.size();}
        TYPE&           getvaluev               () {return const_cast<TYPE&>(arr[i]);}
        const TYPE&     getvalue                () const {return const_cast<const TYPE&> (arr[i]);}
                        operator const TYPE&    () const {return const_cast<const TYPE&> (arr[i]);}
    };

    iterator start () const {
        return iterator (*this);
    }
};

template <class TYPE>
Array<TYPE>*    clone   (const Array<TYPE>& orig) {
    Array<TYPE>* res = new Array<TYPE> (orig.size);
    for (int i=0; i<orig.size; i++)
        put ((TYPE*)orig[i].clone(), i);
}

template <class TYPE>
void    copyClone   (Array<TYPE>& trg, const Array<TYPE>& orig) {
    trg.empty ();
    trg.make (orig.size());
    for (int i=0; i<orig.size(); i++)
        if (orig.getp(i))
            trg.put ((TYPE*)orig.getp(i)->clone(), i);
}


#define foreach_Array(valuetype,arrayname,varname) \
    for (ArrayIter<keytype,valuetype> varname (arrayname); \
         !varname.exhausted(); varname.next())


/*
#ifdef new_UNDEFD
#define new DEBUG_NEW
#undef renew
#undef new_UNDEFD
#endif
*/

END_NAMESPACE;

#endif

---