array2d.h

Go to the documentation of this file.

#ifndef ARRAY2D_H
#define ARRAY2D_H

#include <limits.h>
#include <memory.h>
#include <QtGlobal>

namespace frechet { namespace data {

template<class T>
class Array2D
{
protected:
    T* d; 
public:
    const int n;
    const int m;

    Array2D(int an=0, int am=0);
    Array2D(const Array2D& that);
    Array2D(Array2D&& that);
    ~Array2D();
    Array2D& operator= (const Array2D& that);
    Array2D& operator= (Array2D&& that);

    T&          at (int i, int j)       { return d[offset(i,j)]; }
    const T&    at (int i, int j) const { return d[offset(i,j)]; }

    T&          at (int offset)         {
        Q_ASSERT(offset>=0 && offset < n*m);
        return d[offset];
    }

    const T&    at (int offset) const   {
        Q_ASSERT(offset>=0 && offset < n*m);
        return d[offset];
    }

    T&          operator[] (int offset)         { return at(offset); }
    const T&    operator[] (int offset) const   { return at(offset); }

    class iterator {
    public:
        iterator() : parent(NULL), _offset(0) {}
        iterator& operator= (const iterator& that) {
            parent = that.parent;
            _offset = that._offset;
            return *this;
        }
        bool operator== (const iterator& that) const {
            return (parent==that.parent) && (_offset==that._offset);
        }
        bool operator!= (const iterator& that) const {
            return ! operator==(that);
        }
        bool valid() const { return valid(_offset); }
        bool valid(int off) const { return (off >= 0) && (off < parent->n * parent->m); }

        int offset() const  { return _offset; }
        int i() const { return _offset / parent->m; }
        int j() const { return _offset % parent->m; }

        T&          operator* ()        { return parent->at(_offset); }
        T*          operator-> ()       { return & parent->at(_offset); }

        iterator&    operator++ (/*pre-increment*/)       { _offset++; return *this; }
        iterator     operator++ (int/*post-increment*/)   { iterator it=*this; _offset++; return it; }

        iterator&    operator-- (/*pre-increment*/)       { _offset--; return *this; }
        iterator     operator-- (int/*post-increment*/)   { iterator it=*this; _offset--; return it; }

        iterator&    up()       { _offset++; return *this; }
        iterator&    down()     { _offset--; return *this; }
        iterator&    right()    { _offset += parent->m; return *this; }
        iterator&    left()     { _offset -= parent->m; return *this; }

        iterator&    to(int i, int j)   { to(i*parent->m + j); }
        iterator&    to(int off)        { _offset = off; }

        T* leftNeighbor() {
            if (i() > 0)
                return &parent->at(_offset-parent->m);
            else
                return nullptr;
        }
        T* rightNeighbor() {
            if (i()+1 < parent->n)
                return &parent->at(_offset+parent->m);
            else
                return nullptr;
        }
        T* topNeighbor() {
            if (j()+1 < parent->m)
                return &parent->at(_offset+1);
            else
                return nullptr;
        }
        T* bottomNeighbor() {
            if (j() > 0)
                return &parent->at(_offset-parent->m);
            else
                return nullptr;
        }

    protected:
        iterator(Array2D* aparent, int start) : parent(aparent), _offset(start) { }
        Array2D* parent;
        int _offset;
    };
    iterator    begin() { return iterator(this,0); }
    iterator    end()   { return iterator(this,n*m); }

public:
    size_t offset(int i, int j) const {
        Q_ASSERT(i>=0 && i < n && j>=0 && j < m);
        return i*m+j;
    }
    void indices(int off, int* i, int* j) const {
        Q_ASSERT(off>=0 && off<n*m);
        *i = off/m;
        *j = off%m;
    }
    static void copy(T* dst, T* src, int count);
};

} }  //  namespace

#include <array2d_impl.h>

#endif // ARRAY2D_H