---

mrefarray.h

/***************************************************************************
 *   This file is part of the MagiC++ library.                             *
 *                                                                         *
 *   Copyright (C) 1998-2001 Marko Grönroos <magi@iki.fi>                  *
 *                                                                         *
 ***************************************************************************
 *                                                                         *
 *  This library is free software; you can redistribute it and/or          *
 *  modify it under the terms of the GNU Library General Public            *
 *  License as published by the Free Software Foundation; either           *
 *  version 2 of the License, or (at your option) any later version.       *
 *                                                                         *
 *  This library is distributed in the hope that it will be useful,        *
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of         *
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU      *
 *  Library General Public License for more details.                       *
 *                                                                         *
 *  You should have received a copy of the GNU Library General Public      *
 *  License along with this library; see the file COPYING.LIB.  If         *
 *  not, write to the Free Software Foundation, Inc., 59 Temple Place      *
 *  - Suite 330, Boston, MA 02111-1307, USA.                               *
 *                                                                         *
 ***************************************************************************/

#ifndef __REFARRAY_H__
#define __REFARRAY_H__

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

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

    RefArray    () {
        lower   = 0,
        upper   = -1,
        size    = 0,
        rep     = NULL;
    }

    // Create the reference array to refer to a real container array
    RefArray    (const Array<TYPE>& orig) {
        lower   = 0;
        upper   = -1;
        size    = 0;
        rep     = NULL;
        operator= (orig);
    }

    // Copy constructor
    RefArray    (const RefArray<TYPE>& orig) {
        lower   = 0;
        upper   = -1;
        size    = 0;
        rep     = NULL;
        operator= (orig);
    }
    
    RefArray    (int low, int upp) {
        size    = 0;
        make (low, upp);
    }

    void    make    (int low, int upp) {
        PRE (low <= upp);
        lower   = low,
        upper   = upp,
        size    = upper-lower+1;

        delete rep;
        rep     = new TYPE* [size];
        
        for (int i=0; i<size; i++)
            rep [i] = NULL;
    }

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

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

    virtual ~RefArray () {
        delete rep;
    }

    // Tyhjentää vektorin
    void    empty   () {
        delete rep;
        rep = NULL;
        size = 0;
        upper=lower-1;
        //if (rep)
        //  for (int i=0;i<size;i++)
        //      rep[i] = NULL;
    }

    void    add (TYPE* i) {
        /* Lis„„ alkion taulukon loppuun, matalakopioi! */
        resize (lower, upper+1);
        rep[upper-lower] = i;
    }

    void    put (TYPE* i, int loc) {
        /* Lis„„ alkion annettuun vaikkaan taulukoss, ei kopioi, tuhoaa vanhan */
        PRE (i != NULL && loc>= lower && loc<=upper);
        delete rep [loc-lower];
        rep [loc-lower] = i;
    }

    // Palauttaa viittauksen taulukon haluttuun alkioon
    TYPE&   operator[]  (int loc) {
        PRE (loc>= lower && loc<=upper);
        return *rep [loc-lower];
    }

    // Edellisen const-versio
    const TYPE& operator[]  (int loc) const {
        PRE (loc>= lower && loc<=upper);
        return *rep [loc-lower];
    }

    void    resize  (int low, int upp) {
        /* Muuttaa taulukon kokoa, old[lower] = new[lower] */
        PRE (low <= upp);
        int nsize = upp-low+1;
        if (nsize < size) { /* Pienennet„„n */
            rep = (TYPE**) renew (rep, sizeof (TYPE*)*(nsize));
        } else { /* Suurennetaan */
            rep = (TYPE**) renew (rep, sizeof (TYPE*)*(nsize));
            for (int i=size; i<nsize; i++)
                rep [i] = NULL;
        }
        lower   = low,
        upper   = upp,
        size    = nsize;
    }

    // Sorts the references... WOW!
    // The contained class MUST inherit Comparable...
    void    quicksort   () {
        qsort (rep, size, sizeof (TYPE*), compareComparable);
    }
};

#define CRefArray RefArray

#endif

---