MNArray.h

Go to the documentation of this file.

/* Copyright (C) 2000 KOM/Darmstadt University of Technology
 *
 * You are allowed to use all other parts of the code under the following terms:
 *
 * For non-commercial use, code may be used in unmodified form provided
 * that this copyright notice and this permission notice appear in
 * supporting documentation.
 *
 * This software is provided "as is" and without any express or implied
 * warranties, including, without limitation, the implied warranty of
 * fitness for a particular purpose.
 *
 * The code may be subjected to the GNU General Public License, Version 2,
 * and re-distributed under the terms of this license.
 * As a special exception, permission is granted to link this code
 * with the Qt library and distribute executables, as long as you
 * follow the requirements of the GNU GPL in regard to all of the
 * software in the executable aside from Qt.
 *
 * Commercial use other than under the terms of the GNU General Public
 * License is allowed only after express negotiation of conditions
 * with the authors.
 */
#ifndef MN_ARRAY_H
#define MN_ARRAY_H

#include "MNValid.h"

template <class T> class MNArray2
{
    DECLARE_VALID
private:
    int  _xsize;
    int  _ysize;
    T*   _array;

    typedef T Item;
public:
    MNArray2( int x, int y ) {
        _xsize = x;
        _ysize = y;
        _array = new Item[ x * y ];
        memset ( _array, '\0', x*y*sizeof(Item) );
        MAKE_VALID
    }

    MNArray2( const MNArray2<T>& ar ) {
        _xsize = ar.xsize();
        _ysize = ar.ysize();
        _array = new Item[ _xsize * _ysize ];
        memcpy ( _array, ar.array(), _xsize*_ysize*sizeof(Item) );
        MAKE_VALID
    }

    ~MNArray2( ) {
        MAKE_INVALID
        delete [] _array;
    }

    inline T& operator()(int x, int y) {
        CHECK_VALID
        assert( 0 <= x );
        assert( 0 <= y );
        assert( x < _xsize);
        assert( y < _ysize);
        return _array[ y*_xsize + x ];
    }

    inline int xsize() const { CHECK_VALID return _xsize; }
    inline int ysize() const { CHECK_VALID return _ysize; }
    inline int low1()  const { CHECK_VALID return 0; }
    inline int low2()  const { CHECK_VALID return 0; }
    inline int high1() const { CHECK_VALID return _xsize; }
    inline int high2() const { CHECK_VALID return _ysize; }

    inline T* array() const {
        CHECK_VALID
        return _array;
    }
};

template <class T> class MNArrayN
{
    DECLARE_VALID
private:
    int  _dimension;
    int  _length;
    int* _sizes;
    T*   _array;

    typedef T Item;
public:
    MNArrayN( int dimension, int* sizes ) {
        _dimension = dimension;
        _sizes     = new int[dimension];
        _length = 1;
        for ( int i=0; i<_dimension; i++ )
        {
            _length *= sizes[i];
            _sizes[i] = sizes[i];
        }
        _array = new Item[ _length ];
        memset ( _array, '\0', _length*sizeof(Item) );
        MAKE_VALID
    }

    ~MNArrayN( ) {
        MAKE_INVALID
        delete [] _array;
        delete [] _sizes;
    }

    inline T& operator()(int* v) {
        CHECK_VALID
        int offset = 0;
        int factor = 1;
        for ( int i=0; i<_dimension; i++ )
        {
            assert (    0 <= v[i] );
            assert ( v[i] <= _sizes[i] );
            offset += v[i] * factor;
            factor *= _sizes[i];
        }
        return _array[ offset ];
    }

    inline int size( int d ) const { CHECK_VALID return _sizes[d]; }
    inline int low ( int d )  const { CHECK_VALID return 0; }
    inline int high( int d ) const { CHECK_VALID return _sizes[d]; }

    inline T* array() const {
        CHECK_VALID
        return _array;
    }
};

#endif /* MN_ARRAY_H */

---