#ifndef ARRAY_H
#define ARRAY_H

#include <utility>
#include <algorithm>
#include <stdexcept>

#undef SOLVED_2
#define SOLVED_2

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(), N, u);
      }

      void swap(array<T,N> & other)
      {
        std::swap_ranges(begin(), end(), other.begin());
      }

      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: */