---

mtable.h

#ifndef __TABLE_H__
#define __TABLE_H__

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

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

// Obey the global no-bounds-checking option
#ifndef NOCHECKBOUNDS
#define PACKTABLE_CHECKBOUNDS 1
#endif


template <class TYPE>
class PackTable : public Object {
  protected:
    TYPE*   data;
  public:
    PackTable   () {
        data = NULL;
        rows = 0,
        cols = 0;
    }

    PackTable   (int rs, int cs) {
        data = NULL;
        rows = 0,
        cols = 0;
        make (rs, cs);
    }

    PackTable   (const PackTable& orig, bool deep=false) {
        data = NULL;
        rows = cols = 0;
        if (orig.data) {
            if (deep) {
                // Deep copy requested
                make (orig.rows, orig.cols);
                for (int i=0; i<rows; i++)
                    for (int j=0; j<cols; j++)
                        get(i,j) = orig.get(i,j);
            } else {
                // Default fast but shallow copy
                rows = orig.rows;
                cols = orig.cols;
                data = new TYPE[rows*cols];
                memcpy (data, orig.data, rows*cols);
            }
        }
    }
    
    ~PackTable  () {
        destroy ();
    }

    void    destroy () {
        delete data;
        data = NULL;
        rows = 0,
        cols = 0;
    }

    virtual void    make    (int nrows, int ncols) {
        ASSERT (nrows>=0 && ncols>=0);
        if (data)
            destroy ();
        rows = nrows,
        cols = ncols;
        if (rows>0 && cols>0) {
            // Luodaan uusi tietorakenne valmiiksi
            newComment (format ("PackTable<> data, %d rows, %d cols", rows, cols));
            data = new TYPE [rows*cols];
        }
    }

    const TYPE& get (int row, int col) const {
#ifdef PACKTABLE_CHECKBOUNDS
        if (!(row>=0 && row<rows && col>=0 && col<cols))
            throw out_of_bounds (strformat ("Table range overflow: %d,%d out of %d,%d",
                                            row, col, rows, cols));
#endif
        return data[row*cols+col];
    }

    TYPE&   get (int row, int col) {
#ifdef PACKTABLE_CHECKBOUNDS
        if (!(row>=0 && row<rows && col>=0 && col<cols))
            throw out_of_bounds (strformat ("Table range overflow: %d,%d out of %d,%d",
                                            row, col, rows, cols));
#endif
        return data[row*cols+col];
    }

    /*
    virtual CArchive&   operator>>  (CArchive& arc) const {
        arc << rows << cols;
        for (int i=0; i<rows; i++)
            for (int j=0; j<cols; j++)
                arc << get (i, j);
        return arc;
    }
    */

    /*
    IStream&    operator<<  (IStream& arc) {
        int nrows, ncols;
        arc >> nrows >> ncols;
        make (nrows, ncols);
        for (int i=0; i<rows; i++)
            for (int j=0; j<cols; j++)
                arc >> get (i, j);
        return arc;
    }
    */

    int rows;

    int cols;
    
  private:
    void operator=  (const PackTable& other) {} 
};

#endif

---