Array.h

Go to the documentation of this file.

#ifndef GfxTL__ARRAY_HEADER__
#define GfxTL__ARRAY_HEADER__
#include <iostream>
#include <iterator>
 
namespace GfxTL
{
 
    template <unsigned int DimT, class IteratorT>
    class ArrayAccessor
    {
    public:
        ArrayAccessor(IteratorT arr, const size_t* fac) : m_arr(arr), m_fac(fac)
        {
        }
 
        ArrayAccessor<DimT - 1, IteratorT>
        operator[](size_t i)
        {
            return ArrayAccessor<DimT - 1, IteratorT>(m_arr + i * (*m_fac), m_fac + 1);
        }
 
        const ArrayAccessor<DimT - 1, IteratorT>
        operator[](size_t i) const
        {
            return ArrayAccessor<DimT - 1, IteratorT>(m_arr + i * (*m_fac), m_fac + 1);
        }
 
        IteratorT
        begin() const
        {
            return m_arr;
        }
 
        IteratorT
        end() const
        {
            return m_arr + *(m_fac - 1);
        }
 
    private:
        IteratorT m_arr;
        const size_t* m_fac;
    };
 
    template <class IteratorT>
    class ArrayAccessor<1, IteratorT>
    {
    public:
        typedef typename std::iterator_traits<IteratorT>::value_type value_type;
        typedef typename std::iterator_traits<IteratorT>::reference reference;
 
        ArrayAccessor(IteratorT arr, const size_t* fac) : m_arr(arr), m_fac(fac)
        {
        }
 
        reference
        operator[](size_t i) const
        {
            return m_arr[i];
        }
 
        IteratorT
        begin() const
        {
            return m_arr;
        }
 
        IteratorT
        end() const
        {
            return m_arr + *(m_fac - 1);
        }
 
    private:
        IteratorT m_arr;
        const size_t* m_fac;
    };
 
    template <unsigned int DimT, class IteratorT>
    class Array
    {
    public:
        typedef typename std::iterator_traits<IteratorT>::value_type value_type;
        typedef IteratorT iterator;
        typedef Array<DimT, IteratorT> ThisType;
        template <unsigned int D>
        friend std::ostream& operator<<(std::ostream& o, const Array<D, IteratorT>& a);
 
        Array()
        {
            for (unsigned int i = 0; i < DimT; ++i)
            {
                m_ext[i] = 0;
            }
        }
 
        Array(IteratorT arr, const size_t* ext) : m_arr(arr)
        {
            SetExtent(ext);
        }
 
        void
        SetExtent(const size_t* ext)
        {
            for (unsigned int i = 0; i < DimT; ++i)
            {
                m_ext[i] = ext[i];
            }
            m_fac[DimT - 1] = 1;
            for (unsigned int i = DimT - 1; i != 0; --i)
            {
                m_fac[i - 1] = m_fac[i] * m_ext[i];
            }
        }
 
        void
        Iterator(iterator i)
        {
            m_arr = i;
        }
 
        ArrayAccessor<DimT - 1, IteratorT>
        operator[](size_t i)
        {
            return ArrayAccessor<DimT - 1, IteratorT>(m_arr + i * m_fac[0], m_fac + 1);
        }
 
        const ArrayAccessor<DimT - 1, IteratorT>
        operator[](size_t i) const
        {
            return ArrayAccessor<DimT - 1, IteratorT>(m_arr + i * m_fac[0], m_fac + 1);
        }
 
        const size_t
        Extent(unsigned int d) const
        {
            return m_ext[d];
        }
 
        const size_t*
        Extent() const
        {
            return m_ext;
        }
 
        iterator
        begin()
        {
            return m_arr;
        }
 
        iterator
        end()
        {
            return m_arr + m_fac[0] * m_ext[0];
        }
 
        iterator
        begin() const
        {
            return m_arr;
        }
 
        iterator
        end() const
        {
            return m_arr + m_fac[0] * m_ext[0];
        }
 
    private:
        Array(const ThisType& a)
        {
        }
 
        void
        operator=(const ThisType& a)
        {
        }
 
    private:
        IteratorT m_arr;
        size_t m_fac[DimT];
        size_t m_ext[DimT];
    };
 
    template <unsigned int DimT, class IteratorT>
    std::ostream&
    operator<<(std::ostream& o, const Array<DimT, IteratorT>& a)
    {
        o << "[";
        for (size_t i = 0; i < a.Extent(0); ++i)
        {
            o << Array<DimT - 1, IteratorT>(a.m_arr + a.m_fac[0] * i, a.m_ext + 1);
            if (i < a.Extent(0) - 1)
            {
                o << ", ";
            }
        }
        o << "]";
        return o;
    }
 
    template <class IteratorT>
    std::ostream&
    operator<<(std::ostream& o, const Array<1, IteratorT>& a)
    {
        o << "[";
        for (size_t i = 0; i < a.Extent(0); ++i)
        {
            o << a.m_arr[i];
            if (i < a.Extent(0) - 1)
            {
                o << ", ";
            }
        }
        o << "]";
        return o;
    }
 
}; // namespace GfxTL
 
#endif