FixedArray.hpp

/*
 *  Copyright 2011, 2012 Lukas Jirkovsky
 *
 *  This file is part of FotoSHOCKcore.
 *
 *  FotoSHOCKcore is free software: you can redistribute it and/or modify it
 *  under the terms of the GNU Lesser General Public License as published by
 *  the Free Software Foundation, version 3 of the License.
 *
 *  FotoSHOCKcore 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 Lesser General Public License for more details.
 *
 *  You should have received a copy of the GNU Lesser General Public License
 *  along with FotoSHOCKcore.  If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef FIXEDARRAY_H
#define FIXEDARRAY_H

#include "CoreException.hpp"

#include <cassert>
#include <cstddef>
#include <cstring>

namespace FotoSHOCKcore {


template <typename T>
class FixedArray {
    public:
        typedef T              value_type;
        typedef T*             iterator;
        typedef const T*       const_iterator;
        typedef T&             reference;
        typedef const T&       const_reference;
        typedef std::size_t    size_type;
        typedef std::ptrdiff_t difference_type;


        FixedArray(const size_type size) : m_size(size) {
            if (size > 0) {
                m_content = new value_type[size]();
            } else {
                m_content = 0;
            }
        }

        FixedArray(const FixedArray<value_type>& other) : m_size(other.m_size) {
            if (other.m_size > 0) {
                m_content = new value_type[m_size];
                std::memcpy(m_content, other.m_content, m_size * sizeof(value_type));
            } else {
                m_content = 0;
            }
        }

        ~FixedArray() {
            if (m_content) {
                delete[] m_content;
            }
        }

        reference operator=(const_reference other) {
            if (m_size == other.m_size) {
                std::memcpy(m_content, other.m_content, m_size * sizeof(value_type));
                return *this;
            } else {
                throw ArrayException("Array sizes differ", __FILE__, __LINE__);
            }
        }


        reference operator[](size_type i) {
            assert (m_content != 0);
            return m_content[i];
        }


        const_reference operator[](size_type i) const {
            assert (m_content != 0);
            return m_content[i];
        }

        size_type size() const {
            return m_size;
        }

    private:
        const size_type m_size;
        value_type* m_content;
};

}

#endif