---

mpararr.h

/***************************************************************************
    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:

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

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



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

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

    int size;

    Array   (int siz=0) {
        size = 0;
        rep = NULL;
        make (siz);
        mIsRef = false;
    }
    
    void    make    (int siz) {
        if (size) {
            empty ();
            delete rep;
            rep=NULL;
            size=0;
        }
        if (siz>0) {
            size = siz;
            ASSERTWITH (rep=new TYPE*[size], "Out of memory in array memory allocation");
            for (int i=0; i<size; 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<size;i++) {
                if (!mIsRef)
                    delete rep[i];
                rep[i] = NULL;
            }
    }

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

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

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

    void    put (const TYPE& i, int loc) {
        if (loc>=size)
            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<size; i++)
            if (!rep[i]) {
                rep [i] = p;
                return;
            }
        add (p);
    }

    const TYPE& operator[]  (int loc) const {
        ASSERTWITH (loc<size, format("Index %d out of Array bounds (size %d)", loc, size));
        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<size, format("Index %d out of Array bounds (size %d)", loc, size));
        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<size, format("Index %d out of Array bounds (size %d)", loc, size));
        return rep [loc];
    }

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

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

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

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

    void    operator=   (const Array<TYPE>& other) {
        empty ();
        make (other.size);
        for (int i=0; i<other.size; 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 (size>=0);
    }

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


    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
*/

#endif

---