Saf/Collection/StaticArray.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_STATICARRAY_H
#define SAF_COLLECTION_STATICARRAY_H

#include "../Type.h"
#include "../InvalidOperationException.h"
#include "../Algo/Range.h"

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

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

        protected: 
            T m_data[N];

        public:
            StaticArray()
            {}

            explicit StaticArray(const T& val)
            {
                // Compiler will optimize this out 
                if (N == 1)
                {
                    *m_data = val;
                }
                else if (N == 2)
                {
                    m_data[0] = val;
                    m_data[1] = val;
                }
                else if (N == 3)
                {
                    m_data[0] = val;
                    m_data[1] = val;
                    m_data[2] = val;
                }
                else if (N == 4)
                {
                    m_data[0] = val;
                    m_data[1] = val;
                    m_data[2] = val;
                    m_data[3] = val;
                }
                else
                {
                    Algo::Range::Fill(Begin(), End(), val);
                }
            }

            StaticArray(const T& v1, const T& v2)
            {
                Set(v1, v2);
            }

            StaticArray(const T& v1, const T& v2, const T& v3)
            {
                Set(v1, v2, v3);
            }

            StaticArray(const T& v1, const T& v2, const T& v3, const T& v4)
            {
                Set(v1, v2, v3, v4);
            }

            StaticArray(const MyType& t)
            {
                *this = t;
            }

            MyType& operator=(const MyType& t)
            {
                // Compiler will optimize this out
                if (N == 1)
                {
                    *m_data = *t.m_data;
                }
                else if (N == 2)
                {
                    m_data[0] = t.m_data[0];
                    m_data[1] = t.m_data[1];
                }
                else if (N == 3)
                {
                    m_data[0] = t.m_data[0];
                    m_data[1] = t.m_data[1];
                    m_data[2] = t.m_data[2];
                }
                else if (N == 4)
                {
                    m_data[0] = t.m_data[0];
                    m_data[1] = t.m_data[1];
                    m_data[2] = t.m_data[2];
                    m_data[3] = t.m_data[3];
                }
                else
                {
                    Algo::Range::Copy(t.Begin(), t.End(), Begin());
                }

                return *this;
            }

            Size Elements() const
            {
                return N;
            }

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

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

            Iterator Begin()
            {
                return m_data;
            }

            ConstIterator Begin() const
            {
                return m_data;
            }

            Iterator End()
            {
                return m_data + N;
            }

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

            Iterator Front()
            {
                return m_data;
            }

            ConstIterator Front() const
            {
                return m_data;
            }

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

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

            MyType& Set(const T& v1, const T& v2)
            {
                if (N != 2)
                {
                    throw InvalidOperationException(SAF_SOURCE_LOCATION, "Method applicable"
                        " to arrays of size 2 only.");
                }
                else
                {
                    m_data[0] = v1;
                    m_data[1] = v2;
                }

                return *this;
            }

            MyType& Set(const T& v1, const T& v2, const T& v3)
            {
                if (N != 3)
                {
                    throw InvalidOperationException(SAF_SOURCE_LOCATION, "Method applicable"
                        " to arrays of size 2 only.");
                }
                else
                {
                    m_data[0] = v1;
                    m_data[1] = v2;
                    m_data[2] = v3;
                }

                return *this;
            }

            MyType& Set(const T& v1, const T& v2, const T& v3, const T& v4)
            {
                if (N != 4)
                {
                    throw InvalidOperationException(SAF_SOURCE_LOCATION, "Method applicable"
                        " to arrays of size 2 only.");
                }
                else
                {
                    m_data[0] = v1;
                    m_data[1] = v2;
                    m_data[2] = v3;
                    m_data[3] = v4;
                }

                return *this;
            }

            bool operator==(const MyType& t) const
            {
                // Compiler will optimize this out
                if (N == 1)
                {
                    return (*m_data == *t.m_data);
                }
                else if (N == 2)
                {
                    return (m_data[0] == t.m_data[0] && m_data[1] == t.m_data[1]);
                }
                else if (N == 3)
                {
                    return (m_data[0] == t.m_data[0] && m_data[1] == t.m_data[1] &&
                        m_data[2] == t.m_data[2]);
                }
                else if (N == 4)
                {
                    return (m_data[0] == t.m_data[0] && m_data[1] == t.m_data[1] &&
                        m_data[2] == t.m_data[2] && m_data[3] == t.m_data[3]);
                }

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

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

#endif