Saf/Collection/Array.h

Go to the documentation of this file.

/*
    This file is part of Simple Application Framework (Saf) library.
    Copyright (C) 2010 - 2012 Ondrej Danek <ondrej.danek@gmail.com>

    This library is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published 
    by the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    Saf is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with Simple Application Framework library. If not, 
    see <http://www.gnu.org/licenses/>.
*/

#ifndef SAF_COLLECTION_ARRAY_H
#define SAF_COLLECTION_ARRAY_H

#include "../Mem/Alloc.h"
#include "../OutOfMemoryException.h"
#include "../OverflowException.h"
#include "../InvalidOperationException.h"
#include "../Math/Algebra/Vector.h"
#include "../Type/Limits.h"
#include "../Algo/Swap.h"
#include "../Algo/Range.h"

namespace Saf
{
    namespace Collection
    {
        template <Size N, class T>
        class Array
        {
        protected:
            typedef Array<N,T> MyType;

        public:
            typedef T* Iterator;
            typedef const T* ConstIterator;

        private:
            Math::Algebra::Vector<N,Size> m_dim;
            T *m_data;

            Math::Algebra::Vector<N,Size> m_stride;
            Size m_elems;

        public:
            Array()
                : m_dim(0), m_data(nullptr), m_stride(0), m_elems(0)
            {}

            explicit Array(const Math::Algebra::Vector<N,Size> &dim)
                : m_dim(0), m_data(nullptr), m_stride(0), m_elems(0)
            {
                Resize(dim);
            }

            Array(const Math::Algebra::Vector<N,Size> &dim, const T& val)
                : m_dim(0), m_data(nullptr), m_stride(0), m_elems(0)
            {
                Resize(dim, val);
            }

            explicit Array(Size sz)
                : m_dim(0), m_data(nullptr), m_stride(0), m_elems(0)
            {
                Resize(sz);
            }

            Array(Size sz, const T& val)
                : m_dim(0), m_data(nullptr), m_stride(0), m_elems(0)
            {
                Resize(sz, val);
            }

            Array(const MyType& v)
                : m_dim(0), m_data(nullptr), m_stride(0), m_elems(0)
            {
                *this = v;
            }

            ~Array()
            {
                Free();
            }

            MyType& Free()
            {
                if (m_elems > 0)
                {
                    Mem::Delete(m_data, m_elems);
                    m_dim.Fill(0);
                    m_stride.Fill(0);
                    m_elems = 0;
                }
                    
                return *this;
            }

            MyType& operator=(const MyType& a)
            {
                if (this != &a)
                {                        
                    if (!a.IsEmpty())
                    {
                        // Resize and copy
                        Resize(a.Dimensions());
                        Algo::Range::Copy(Begin(), End(), a.Begin());
                    }
                    else
                    {
                        Free();
                    }
                }

                return *this;
            }

            MyType& Swap(MyType& a)
            {
                if (this != &a)
                {
                    Algo::Swap(m_dim, a.m_dim);
                    Algo::Swap(m_data, a.m_data);
                    Algo::Swap(m_stride, a.m_stride);
                    Algo::Swap(m_elems, a.m_elems);
                }

                return *this;
            }

            Size Elements() const
            {
                return m_elems;
            }

            const Math::Algebra::Vector<N,Size>& Dimensions() const
            {
                return m_dim;
            }

            const Math::Algebra::Vector<N,Size>& Stride() const
            {
                return m_stride;
            }

            bool IsEmpty() const
            {
                return (m_elems == 0);
            }

            MyType& Resize(const Math::Algebra::Vector<N,Size> &dim)
            {
                if (!Algo::Range::AnyEqualTo(dim.Begin(), dim.End(), Size(0)))
                {
                    CheckOverflow(dim);

                    if (dim.Product() != m_elems)
                    {                            
                        Free();
                        m_data = SAF_NEW T[dim.Product()];
                    }

                    m_dim = dim;
                    UpdateCache();
                }
                else
                {
                    throw ArgumentException(SAF_SOURCE_LOCATION, "The size of the array must "
                        "be non-zero in all dimensions.");
                }

                return *this;
            }

            MyType& Resize(const Math::Algebra::Vector<N,Size> &dim, const T& val)
            {
                Resize(dim);
                Algo::Range::Fill(Begin(), End(), val);
                return *this;
            }

            MyType& Resize(Size sz, const T& val)
            {
                if (N == 1)
                {
                    Resize(Math::Algebra::Vector<N,Size>(sz), val);
                }
                else
                {
                    throw InvalidOperationException(SAF_SOURCE_LOCATION, "Method applicable"
                        " to one dimensional arrays only.");
                }

                return *this;
            }

            MyType& Resize(Size sz)
            {
                if (N == 1)
                {
                    Resize(Math::Algebra::Vector<N,Size>(sz));
                }
                else
                {
                    throw InvalidOperationException(SAF_SOURCE_LOCATION, "Method applicable"
                        " to one dimensional arrays only.");
                }

                return *this;
            }

            T& operator[](Size i)
            {
                return m_data[i];
            }

            const T& operator[](Size i) const
            {
                return m_data[i];
            }

            Iterator Begin()
            {
                return m_data;
            }

            ConstIterator Begin() const
            {
                return m_data;
            }

            Iterator End()
            {
                return m_data + m_elems;
            }

            ConstIterator End() const
            {
                return m_data + m_elems;
            }

            Iterator Front()
            {
                return m_data;
            }

            ConstIterator Front() const
            {
                return m_data;
            }

            Iterator Back()
            {
                return m_data + (m_elems - 1);
            }

            ConstIterator Back() const
            {
                return m_data + (m_elems - 1);
            }

            bool operator==(const MyType& a) const
            {
                if (m_dim != a.m_dim)
                {
                    return false;
                }

                return Algo::Range::Equal(Begin(), End(), a.Begin());
            }

            bool operator!=(const MyType& a) const
            {
                return !(*this == a);
            }

            template <class U>
            U Index(const Math::Algebra::Vector<N,U> &ofs) const
            {
                Math::Algebra::Vector<N,U> coef = m_stride.template Convert<N,U>(0);
                return (ofs * coef).Sum();
            }

            template <class U>
            static U Index(const Math::Algebra::Vector<N,Size> &dim, 
                const Math::Algebra::Vector<N,U> &ofs)
            {
                Size stride = 1;
                U idx = 0;

                for (Size i = 0; i < N; i++)
                {
                    idx += ofs[i] * U(stride);
                    stride *= dim[i];
                }
                    
                return idx;
            }

            template <class U>
            void Indexes(const Collection::Array<1,Math::Algebra::Vector<N,U> > &ofs,
                Collection::Array<1,U> &idx) const
            {
                // Calculate offsets
                idx.Resize(ofs.Elements());
                Math::Algebra::Vector<N,U> coef = m_stride.template Convert<N,U>(0);
                for (Size i = 0; i < ofs.Elements(); i++)
                {
                    idx[i] = (ofs[i] * coef).Sum();
                }
            }

            template <class U>
            static void Indexes(const Math::Algebra::Vector<N,Size> &dim, 
                const Collection::Array<1,Math::Algebra::Vector<N,U> > &ofs,
                Collection::Array<1,U> &idx)
            {
                Math::Algebra::Vector<N,U> stride;
                stride[0] = 1;
                for (Size i = 1; i < N; i++)
                {
                    stride[i] = stride[i-1] * U(dim[i-1]);
                }

                // Calculate offsets
                idx.Resize(ofs.Elements());
                for (Size i = 0; i < ofs.Elements(); i++)
                {
                    idx[i] = (ofs[i] * stride).Sum();
                }
            }

            void Coord(Size idx, Math::Algebra::Vector<N,Size> &coord) const
            {
                for (Size i = N; i-- > 0; )
                {
                    coord[i] = idx / m_stride[i];
                    idx = idx % m_stride[i];
                }
            }

            void Coords(const Collection::Array<1,Size> &iv,
                Collection::Array<1,Math::Algebra::Vector<N,Size> > &cv) const
            {
                cv.Resize(iv.Elements());
                for (Size i = 0; i < cv.Elements(); i++)
                {
                    Size idx = iv[i];

                    for (Size j = N; j-- > 0; )
                    {
                        cv[i][j] = idx / m_stride[j];
                        idx -= idx % m_stride[j];
                    }
                }
            }

        protected:
            void CheckOverflow(const Math::Algebra::Vector<N,Size> &dim)
            {
                Size max_elems = (Type::Limits<Size>::Max() / sizeof(T)) - 1;

                for (Size i = 0; i < N; i++)
                {
                    max_elems /= dim[i];
                }

                if (!max_elems)
                {
                    throw OverflowException(SAF_SOURCE_LOCATION, "The number of elements is too large "
                        "to be stored in the memory.");
                }
            }

            void UpdateCache()
            {
                // Update number of elements
                m_elems = m_dim.Product();

                // Compute stride
                m_stride[0] = 1;
                for (Size i = 1; i < N; i++)
                {
                    m_stride[i] = m_stride[i-1] * m_dim[i-1];
                }
            }
        };
    }

    namespace Algo
    {
        // Swap specialization for arrays.
        template <Size N, class T>
        struct SwapFunc< Collection::Array<N,T> >
        {
            void operator()(Collection::Array<N,T>& x, Collection::Array<N,T>& y)
            {
                x.Swap(y);
            }
        };
    }
}

#endif