---

mtable.h

Go to the documentation of this file.

#ifndef __TABLE_H__
#define __TABLE_H__

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

BEGIN_NAMESPACE (MagiC);

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

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


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

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

    PackTable   (const PackTable& orig, bool deep=false) {
        mData = NULL;
        rows   = cols = 0;
        if (orig.mData) {
            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;
                mData = new TYPE[rows*cols];
                memcpy (mData, orig.mData, rows*cols*sizeof(double));
            }
        }
    }
    
    ~PackTable  () {
        destroy ();
    }

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

    virtual void    make    (int nrows, int ncols) {
        ASSERT (nrows>=0 && ncols>=0);
        if (mData)
            destroy ();
        rows = nrows,
        cols = ncols;
        if (rows>0 && cols>0) {
            // Luodaan uusi tietorakenne valmiiksi
            newComment (format ("PackTable<> data, %d rows, %d cols", rows, cols));
            mData = 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 mData[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 mData[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) {} 
};

END_NAMESPACE;

#endif

---