array.hpp

Go to the documentation of this file.

/*
Copyright© 2014 Akihiro Nishimura

This software is released under the MIT License.
http://opensource.org/licenses/mit-license.php
*/

#ifndef SIG_UTIL_ARRAY_HPP
#define SIG_UTIL_ARRAY_HPP

#include "sigutil.hpp"
#include <array>
#include <initializer_list>

namespace sig
{

template <class T, size_t N>
class array
{
public:
    using value_type = T;
    using reference = T&;
    using const_reference = T const&;
    using pointer = T*;
    using const_pointer = T const*;
    using iterator = typename std::array<T, N>::iterator;
    using const_iterator = typename std::array<T, N>::const_iterator;
    using reverse_iterator = typename std::array<T, N>::reverse_iterator;
    using const_reverse_iterator = typename std::array<T, N>::const_reverse_iterator;
    using size_type = size_t;
    using difference_type = typename std::array<T, N>::difference_type;
#if SIG_ENABLE_BOOST
    using result_type = typename boost::call_traits<T>::value_type;
    using param_type = typename boost::call_traits<T>::param_type;
#else
    using result_type = value_type;
    using param_type = typename std::conditional<std::is_class<T>::value, T const&, T>::type;
#endif

private:
    std::array<T, N> array_;
    size_type tail_;                // 現在使用している添字末尾

private:
    template <class OP, class C1, class C2>
    void compound_assignment_(OP const& assign_op, C1& dest, C2 const& src)
    {
        auto it1 = std::begin(dest), end1 = std::end(dest);
        auto it2 = std::begin(src), end2 = std::end(src);

        while (it1 != end1 && it2 != end2){
            assign_op(*it1, *it2);
            ++it1;
            ++it2;
        }
    }

    void range_check_(size_type index)
    {
        if (index >= tail_){
            throw std::out_of_range("invalid sig::array<T, N> subscript");
        }
    }

    // pos以降の要素を1つ後へずらす
    iterator back_shift_(const_iterator pos)
    {
        auto it = rbegin();
        for (auto pit = it; it.base() != pos; pit = it++){
            *pit = std::move(*it);
        }
        return it.base();
    }

    // pos以降の要素を1つ前へずらす
    iterator front_shift_(iterator pos)
    {
        iterator post = pos;
        for (auto pit = pos, end = this->end(); pos != end; pit = pos++){
            *pit = std::move(*pos);
        }
        return post;
    }

public:
    array() : tail_(0) {}


    array(size_type size, T val) : tail_(0){ for(size_type i=0; i<size; ++i) push_back(val); }


    array(std::initializer_list<T> init) : tail_(0)
    {
        assert(init.size() <= N);
        for(auto it = init.begin(), end = init.end(); it != end; ++it){
            array_[tail_] = std::move(*it);
            ++tail_;
        }
    }


    template <size_type M>
    explicit array(std::array<T,M> const& src) : tail_(0)
    {
        static_assert(M <= N, "M must be less than N");
        compound_assignment_([this](T& dest, ParamType<T> src){ dest = src; ++tail_; }, array_, src);
    }


    template <size_type M>
    explicit array(sig::array<T,M> const& src) : tail_(src.size())
    {
        static_assert(M <= N, "M must be less than N");
        compound_assignment_([this](T& dest, ParamType<T> src){ dest = src; }, array_, src.std_array());
    }


    array(array const& src) : tail_(src.tail_)
    {
        compound_assignment_([this](T& dest, ParamType<T> src){ dest = src; }, array_, src.array_);
    }


    array(array&& src) : tail_(0)
    {
        for (auto it = src.begin(), end = src.end(); it != end; ++it){
            array_[tail_] = std::move(*it);
            ++tail_;
        }
        src.tail_ = 0;
    }


    array& operator=(array const& src)
    {
        auto tmp = array(src);
        swap(tmp);
        return *this;
    }


    array& operator=(array&& src)
    {
        swap(src);
        src.tail_ = 0;
        return *this;
    }


    template <size_type M>
    array& operator=(std::array<T,M> const& src)
    {
        static_assert(M <= N, "M must be less than N");
        array copy(src);
        swap(copy);
        return *this;
    }


    template <size_type M>
    array& operator=(sig::array<T, M> const& src)
    {
        static_assert(M <= N, "M must be less than N");
        array copy(src);
        swap(copy);
        return *this;
    }

    bool operator==(array const& obj){
        if (tail_ != obj.tail_) return false;
        bool same = true;
        for (size_type i = 0; i < tail_; ++i) same = same && (array_[i] == obj.array_[i]);
        return same;
    }

    bool operator!=(array const& obj){
        return !(*this == obj);
    }


    iterator begin() noexcept{ return array_.begin(); }
    const_iterator begin() const noexcept{ return array_.begin(); }
    const_iterator cbegin() const noexcept{ return array_.cbegin(); }


    iterator end() noexcept{ return array_.begin() + tail_; }
    const_iterator end() const noexcept{ return array_.begin() + tail_; }
    const_iterator cend() const noexcept{ return array_.cbegin() + tail_; }


    reverse_iterator rbegin() noexcept{ return array_.rend() - tail_; }
    const_reverse_iterator rbegin() const noexcept{ return array_.rend() - tail_; }
    const_reverse_iterator crbegin() const noexcept{ return array_.crend() - tail_; }


    reverse_iterator rend() noexcept{ return array_.rend(); }
    const_reverse_iterator rend() const noexcept{ return array_.rend(); }
    const_reverse_iterator crend() const noexcept{ return array_.crend(); }


    reference at(size_type pos){ range_check_(pos); return array_.at(pos); }
    const_reference at(size_type pos) const{ range_check_(pos); return array_.at(pos); }


    reference operator [](size_type pos){ return array_[pos]; }
    const_reference operator [](size_type pos) const{ return array_[pos]; }


    reference front(){ return array_.front(); }
    const_reference front() const{ return array_.front(); }


    reference back(){ return tail_ ? array_[tail_-1] : array_.front(); }
    const_reference back() const{ return tail_ ? array_[tail_ - 1] : array_.front(); }


    bool empty() const noexcept{ return tail_ == 0; }


    size_type size() const noexcept{ return tail_; }


    size_type max_size() const noexcept{ return N; }


    value_type* data() noexcept{ return array_.data(); }
    value_type const* data() const noexcept{ return array_.data(); }


    auto std_array() noexcept ->std::array<T, N>&{ return array_; }
    auto std_array() const noexcept ->std::array<T, N> const&{ return array_; }


    void fill(value_type const& val){ array_.fill(val); tail_ = N; }


    void swap(array& other) //noexcept(noexcept(swap(std::declval<value_type&>(), std::declval<value_type&>())))
    {
        std::swap(array_, other.array_); 
        std::swap(tail_, other.tail_);
    }


    void push_back(value_type const& val)
    {
        if (tail_ >= N) throw std::length_error("this container reached upper maxsize limit. so, can't hold more elements.");
        array_[tail_++] = val;
    }
    void push_back(value_type&& val)
    {
        if (tail_ >= N) throw std::length_error("this container reached upper maxsize limit. so, can't hold more elements.");
        array_[tail_++] = std::forward<value_type>(val); 
    }

    void pop_back() noexcept{ if(tail_ > 0) --tail_; }


    iterator insert(const_iterator position, const value_type& val)
    {
        if (tail_ >= N) throw std::length_error("this container reached upper maxsize limit. so, can't hold more elements.");
        ++tail_;
        auto p = back_shift_(position);
        *p = val;
        return p;
    }
    iterator insert(const_iterator position, value_type&& val)
    {
        if (tail_ >= N) throw std::length_error("this container reached upper maxsize limit. so, can't hold more elements.");
        ++tail_;
        auto p = back_shift_(position);
        *p = std::move(val);
        return p;
    }


    iterator erase(iterator position)
    {
        auto p = front_shift_(position);
        --tail_;
        return p;
    }

    void clear() noexcept{ tail_ = 0; }
};

}
#endif