---

mrefarray.h

Go to the documentation of this file.

#ifndef __REFARRAY_H__
#define __REFARRAY_H__

BEGIN_NAMESPACE (MagiC);


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

template <class TYPE>
// Sisältää viittauksia, ei oikeita objekteja. Tämän merkitys on lähinnä
// siinä, ettei objekteja destruktoida vektorin tuhoutuessa
class RefArray {
    TYPE**  mpRep;
    int     mSize;
  public:

    RefArray    () {
        mSize   = 0,
        mpRep   = NULL;
    }

    // Create the reference array to refer to a real container array
    RefArray    (const Array<TYPE>& orig) {
        mSize   = 0;
        mpRep   = NULL;
        *this   = orig;
    }

    // Copy constructor
    RefArray    (const RefArray<TYPE>& orig) {
        mSize   = 0;
        mpRep   = NULL;
        *this   = orig;
    }
    
    RefArray    (int size) {
        mSize   = 0;
        mpRep   = NULL;
        make (size);
    }

    void    make    (int size) {
        delete mpRep;
        mpRep   = new TYPE* [size];
        mSize   = size;

        for (int i=0; i<size; i++)
            mpRep [i] = NULL;
    }

    int     size    () const {return mSize;}

    void    operator=   (const Array<TYPE>& orig) {
        make (orig.size());
        for (int i=0; i<mSize; i++)
            mpRep[i] = (TYPE*) orig.getp (i);
    }

    void    operator=   (const RefArray<TYPE>& orig) {
        make (orig.size());
        for (int i=0; i<mSize; i++)
            mpRep [i] = orig.mpRep[i];
    }

    virtual ~RefArray () {
        delete mpRep;
    }

    void    empty   () {
        delete mpRep;
        mpRep = NULL;
        mSize = 0;
    }

    void    add (TYPE* pItem) {
        resize (mSize + 1);
        mpRep[mSize-1] = pItem;
    }

    void    put (TYPE* pItem, int loc) {
        PRE (pItem != NULL && loc >= 0 && loc < mSize);
        delete mpRep [loc];
        mpRep [loc] = pItem;
    }

    // Palauttaa viittauksen taulukon haluttuun alkioon
    TYPE&   operator[]  (int loc) {
        PRE (loc >= 0 && loc < mSize);
        return *mpRep [loc];
    }

    // Edellisen const-versio
    const TYPE& operator[]  (int loc) const {
        PRE (loc >= 0 && loc < mSize);
        return *mpRep [loc];
    }

    void    resize  (int newsize) {
        /* Muuttaa taulukon kokoa, old[lower] = new[lower] */
        PRE (newsize > 0);
        if (newsize < mSize) { /* Pienennetään */
            mpRep = (TYPE**) renew (mpRep, sizeof (TYPE*)*(newsize));
        } else { /* Suurennetaan */
            mpRep = (TYPE**) renew (mpRep, sizeof (TYPE*)*(newsize));
            for (int i=mSize; i < newsize; i++)
                mpRep[i] = NULL;
        }
        mSize = newsize;
    }

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

#define CRefArray RefArray

END_NAMESPACE;

#endif

---