array.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: MIT
// Author:  Giovanni Santini
// Mail:    giovanni.santini@proton.me
// Github:  @San7o
 
#pragma once
 
#include <cstddef>          /* for std::ptrdiff_t */
#include <initializer_list> /* brace-enclosed initializer list must use std */
#include <iterator>         /* for std::forward_iterator_tag */
#include <tenno/algorithm.hpp>
#include <tenno/error.hpp>
#include <tenno/expected.hpp>
#include <tenno/ranges.hpp>
#include <tenno/types.hpp>
 
namespace tenno
{
 
template <typename T, tenno::size N> class array
{
public:
  using value_type = T;
 
  /* TODO: may be removed */
  static constexpr T generate_default()
  {
    return T{}; // Default-initialize T
  }
 
  constexpr array() : _data{}
  {
    for (auto i : tenno::range<tenno::size>(N))
    {
      this->_data[i] = generate_default();
    }
  }
 
  constexpr array(std::initializer_list<T> list)
  {
    tenno::copy(list.begin(), list.end(), this->_data);
  }
 
  constexpr array(const array &other) : _data{}
  {
    tenno::copy(other.cbegin(), other.cend(), this->_data);
  }
 
  constexpr tenno::size size() const noexcept
  {
    return this->_size;
  }
 
  static constexpr tenno::array<T, N> init() noexcept
  {
    auto arr = tenno::array<T, N>();
    for (auto i : tenno::range<tenno::size>(N))
    {
      arr._data[i] = T();
    }
    return arr;
  }
 
  constexpr tenno::expected<T, tenno::error>
  at(const tenno::size index) const noexcept
  {
    if (index >= this->_size)
    {
      return tenno::unexpected(tenno::error::out_of_range);
    }
    return this->_data[index];
  }
 
  constexpr T front() const noexcept
  {
    return this->_data[0];
  }
 
  constexpr T back() const noexcept
  {
    return this->_data[this->_size - 1];
  }
 
  T *data() noexcept
  {
    return this->_data;
  }
 
  constexpr const T *data() const noexcept
  {
    return this->_data;
  }
 
  constexpr bool empty() const noexcept
  {
    return this->_size == 0;
  }
 
  constexpr tenno::size max_size() const noexcept
  {
    return this->_size;
  }
 
  void fill(const T &value) noexcept
  {
    tenno::for_each(this->begin(), this->end(),
                    [&value](T &elem) { elem = value; });
  }
 
  void swap(array &other) noexcept
  {
    for (auto i : tenno::range<tenno::size>(this->_size))
    {
      auto temp = this->_data[i];
      this->_data[i] = other._data[i];
      other._data[i] = temp;
    }
  }
 
  constexpr T &operator[](const tenno::size index) noexcept
  {
    return this->_data[index];
  }
 
  constexpr const T &operator[](const tenno::size index) const noexcept
  {
    return this->_data[index];
  }
 
  constexpr array &operator=(const array &other) noexcept
  {
    tenno::copy(other.begin(), other.end(), this->_data);
    return *this;
  }
 
  struct iterator
  {
    using iterator_category = std::forward_iterator_tag;
    using difference_type = std::ptrdiff_t;
    using value_type = T;
    using pointer = T *;
    using reference = T &;
 
    tenno::array<T, N> &array;
    tenno::size index;
 
    explicit iterator(tenno::array<T, N> &array_in, tenno::size end) noexcept
        : array(array_in), index(end)
    {
    }
 
    iterator &operator++() noexcept
    {
      ++index;
      return *this;
    }
 
    iterator operator++(int) noexcept
    {
      iterator _iterator = *this;
      ++index;
      return _iterator;
    }
 
    bool operator==(const iterator &other) const noexcept
    {
      return index == other.index;
    }
 
    bool operator!=(const iterator &other) const noexcept
    {
      return !(*this == other);
    }
 
    reference operator*() const noexcept
    {
      return array[index];
    }
  };
 
  iterator begin() noexcept
  {
    return iterator(*this, 0);
  }
  iterator end() noexcept
  {
    return iterator(*this, this->_size);
  }
 
  struct const_iterator
  {
    using iterator_category = std::forward_iterator_tag;
    using difference_type = std::ptrdiff_t;
    using value_type = T;
    using pointer = T *;
    using reference = T &;
 
    const tenno::array<T, N> &array;
    tenno::size index;
 
    constexpr explicit const_iterator(const tenno::array<T, N> &array_in,
                                      const tenno::size end) noexcept
        : array(array_in), index(end)
    {
    }
 
    constexpr const_iterator &operator++() noexcept
    {
      index += 1;
      return *this;
    }
 
    constexpr const_iterator operator++(int) noexcept
    {
      const_iterator _const_iterator = *this;
      index += 1;
      return _const_iterator;
    }
 
    constexpr bool operator==(const const_iterator &other) const noexcept
    {
      return index == other.index;
    }
 
    constexpr bool operator!=(const const_iterator &other) const noexcept
    {
      return !(*this == other);
    }
 
    constexpr T operator*() const noexcept
    {
      return array[index];
    }
  };
 
  constexpr const_iterator cbegin() const noexcept
  {
    return const_iterator(*this, 0);
  }
  constexpr const_iterator cend() const noexcept
  {
    return const_iterator(*this, this->_size);
  }
 
  struct reverse_iterator
  {
    using iterator_category = std::forward_iterator_tag;
    using difference_type = std::ptrdiff_t;
    using value_type = T;
    using pointer = T *;
    using reference = T &;
 
    tenno::array<T, N> &array;
    tenno::size index;
 
    explicit reverse_iterator(tenno::array<T, N> &array_in,
                              tenno::size end) noexcept
        : array(array_in), index(end)
    {
    }
 
    reverse_iterator &operator++() noexcept
    {
      --index;
      return *this;
    }
 
    reverse_iterator operator++(int) noexcept
    {
      reverse_iterator _reverse_iterator = *this;
      --index;
      return _reverse_iterator;
    }
 
    bool operator==(const reverse_iterator &other) const noexcept
    {
      return index == other.index;
    }
 
    bool operator!=(const reverse_iterator &other) const noexcept
    {
      return !(*this == other);
    }
 
    reference operator*() const noexcept
    {
      return array[index];
    }
  };
 
  reverse_iterator rbegin() noexcept
  {
    return reverse_iterator(*this, this->_size - 1);
  }
  reverse_iterator rend() noexcept
  {
    return reverse_iterator(*this, -1);
  }
 
  struct const_reverse_iterator
  {
    using iterator_category = std::forward_iterator_tag;
    using difference_type = std::ptrdiff_t;
    using value_type = T;
    using pointer = T *;
    using reference = T &;
 
    const tenno::array<T, N> &array;
    tenno::size index;
 
    constexpr explicit const_reverse_iterator(
      const tenno::array<T, N> &array_in, const tenno::size end) noexcept
        : array(array_in), index(end)
    {
    }
 
    constexpr const_reverse_iterator &operator++() noexcept
    {
      --index;
      return *this;
    }
 
    constexpr const_reverse_iterator operator++(int) noexcept
    {
      const_reverse_iterator _const_reverse_iterator = *this;
      --index;
      return _const_reverse_iterator;
    }
 
    constexpr bool
    operator==(const const_reverse_iterator &other) const noexcept
    {
      return index == other.index;
    }
 
    constexpr bool
    operator!=(const const_reverse_iterator &other) const noexcept
    {
      return !(*this == other);
    }
 
    constexpr T operator*() const noexcept
    {
      return array[index];
    }
  };
 
  constexpr const_reverse_iterator crbegin() const noexcept
  {
    return const_reverse_iterator(*this, this->_size - 1);
  }
  constexpr const_reverse_iterator crend() const noexcept
  {
    return const_reverse_iterator(*this, -1);
  }
 
private:
  T _data[N];
  const tenno::size _size = N;
 
}; // class array
 
} // namespace tenno