#ifndef ARRAY_H
#define ARRAY_H

#undef SOLVED_2
#define SOLVED_2

#include <utility> // for std::move
#include <stdexcept> // for std::out_of_range

namespace Ti
{
  template<typename T, std::size_t N>
    struct array
    {
      typedef T& reference;
      typedef const T& const_reference;
      typedef T* iterator;
      typedef const T* const_iterator;
      typedef std::size_t size_type;

      static_assert(N != 0, "array<T, 0> not allowed");

      void fill(const T& u)
      {
        /* std::fill_n(begin(), size(), u); */
        for(size_type i = 0; i < N; ++i)
          m_data[i] = u;
      }

      /* range check not necessary. N must be the same in other */
      void swap(array<T,N> & other)
      {
        /* std::swap_ranges(begin(), end(), other.begin()); */
        for(size_type i = 0; i < N; ++i)
        {
          T x(m_data[i]);
          m_data[i] = other.m_data[i];
          other.m_data[i] = x;
        }
      }

      iterator begin()
      {
        return m_data;
      }

      const_iterator begin() const
      {
        return m_data;
      }

      iterator end()
      {
        return m_data + N;
      }

      const_iterator end() const
      {
        return m_data + N;
      }

      size_type size() const
      {
        return N;
      }

      size_type max_size() const
      {
        return N;
      }

      bool empty() const
      {
        return false; /* size() == 0 */
      }

      reference operator[](size_type n)
      {
        return m_data[n];
      }

      const_reference operator[](size_type n) const
      {
        return m_data[n];
      }

      reference at(size_type n)
      {
        if (n >= N)
          throw std::out_of_range("array::at");
        return m_data[n];
      }

      const_reference at(size_type n) const
      {
        if (n >= N)
          throw std::out_of_range("array::at");
        return m_data[n];
      }

      T* data()
      {
        return m_data;
      }

      private:
        T m_data[N];
    };

  /* std::move returns lvalue as rvalue */
  template<typename T, std::size_t N>
    array<T, N>&& make_array()
  {
    return std::move(array<T, N>());
  }

} // namespace

#endif

/* vim: set et sw=2 ts=2: */