array.h

Go to the documentation of this file.

/*
Copyright (C) 2001-2006, William Joseph.
All Rights Reserved.

This file is part of GtkRadiant.

GtkRadiant 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 2 of the License, or
(at your option) any later version.

GtkRadiant 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 GtkRadiant; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
*/

#if !defined(INCLUDED_CONTAINER_ARRAY_H)
#define INCLUDED_CONTAINER_ARRAY_H

#include <cstddef>
#include <algorithm>

#include "memory/allocator.h"

template < typename Element, typename Allocator = DefaultAllocator<Element> >
class Array : public Allocator {
    std::size_t m_size;
    Element* m_data;

    Element* construct(std::size_t size) {
        return New<Element, Allocator>(*this).vector(size);
    }
    template<typename T1>
    Element* construct(std::size_t size, const T1& value) {
        return New<Element, Allocator>(*this).vector(size, value);
    }
    void destroy(Element* data, std::size_t size) {
        Delete<Element, Allocator>(*this).vector(data, size);
    }

public:
    typedef Element value_type;
    typedef value_type* iterator;
    typedef const value_type* const_iterator;

    Array()
            : m_size(0), m_data(0) {
    }
    Array(std::size_t size)
            : m_size(size), m_data(construct(size)) {
    }
    template<typename T1>
    Array(std::size_t size, const T1& value)
            : m_size(size), m_data(construct(size, value)) {
    }
    Array(const Array& other)
            : Allocator(other), m_size(other.size()), m_data(construct(m_size)) {
        std::copy(other.begin(), other.end(), begin());
    }
    template<typename Iterator>
    Array(Iterator start, Iterator finish)
            : m_size(std::distance(start, finish)), m_data(construct(m_size)) {
        std::copy(start, finish, begin());
    }
    ~Array() {
        destroy(m_data, m_size);
    }

    Array& operator=(const Array& other) {
        if (other.size() == size()) {
            std::copy(other.begin(), other.end(), begin());
        } else {
            Array temp(other);
            temp.swap(*this);
        }
        return *this;
    }

    void swap(Array& other) {
        std::swap(m_size, other.m_size);
        std::swap(m_data, other.m_data);
    }

    iterator begin() {
        return m_data;
    }
    const_iterator begin() const {
        return m_data;
    }
    iterator end() {
        return m_data + m_size;
    }
    const_iterator end() const {
        return m_data + m_size;
    }

    value_type& operator[](std::size_t index) {
#if defined(DEBUG)
        ASSERT_MESSAGE(index < size(), "array index out of bounds");
#endif
        return m_data[index];
    }
    const value_type& operator[](std::size_t index) const {
#if defined(DEBUG)
        ASSERT_MESSAGE(index < size(), "array index out of bounds");
#endif
        return m_data[index];
    }
    value_type* data() {
        return m_data;
    }
    const value_type* data() const {
        return m_data;
    }
    std::size_t size() const {
        return m_size;
    }
    bool empty() const {
        return m_size == 0;
    }

    void resize(std::size_t count) {
        if (count != size()) {
            Array temp(count);
            temp.swap(*this);
        }
    }
    void resize(std::size_t count, const value_type& value) {
        if (count != size()) {
            Array temp(count, value);
            temp.swap(*this);
        }
    }
};

namespace std {
template<typename Element, typename Allocator>
inline void swap(Array<Element, Allocator>& self, Array<Element, Allocator>& other) {
    self.swap(other);
}
}

#endif