Array2D.h

/*
 * Gamedev Framework (gf)
 * Copyright (C) 2016-2021 Julien Bernard
 *
 * This software is provided 'as-is', without any express or implied
 * warranty.  In no event will the authors be held liable for any damages
 * arising from the use of this software.
 *
 * Permission is granted to anyone to use this software for any purpose,
 * including commercial applications, and to alter it and redistribute it
 * freely, subject to the following restrictions:
 *
 * 1. The origin of this software must not be misrepresented; you must not
 *    claim that you wrote the original software. If you use this software
 *    in a product, an acknowledgment in the product documentation would be
 *    appreciated but is not required.
 * 2. Altered source versions must be plainly marked as such, and must not be
 *    misrepresented as being the original software.
 * 3. This notice may not be removed or altered from any source distribution.
 */
#ifndef ARRAY2D_H
#define ARRAY2D_H

#include <cassert>
#include <algorithm>
#include <type_traits>
#include <utility>
#include <vector>

#include "CoreApi.h"
#include "Math.h"
#include "Range.h"
#include "SerializationFwd.h"
#include "Vector.h"

namespace gf {
#ifndef DOXYGEN_SHOULD_SKIP_THIS
inline namespace v1 {
#endif

  template<typename I>
  class Index2D {
  public:
    Index2D()
    : m_size(0, 0)
    {
    }

    Index2D(Vector<I, 2> size)
    : m_size(size)
    {
    }

    Index2D(const Index2D&) = default;

    Index2D& operator=(const Index2D&) = default;

    Index2D(Index2D&&) = default;

    Index2D& operator=(Index2D&&) = default;

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

    constexpr Vector<I, 2> getSize() const noexcept {
      return m_size;
    }

    constexpr I getCols() const noexcept {
      return m_size.col;
    }

    constexpr I getRows() const noexcept {
      return m_size.row;
    }

    constexpr bool isValid(Vector<I, 2> pos) const noexcept {
      return pos.col < m_size.col && pos.row < m_size.row && (std::is_unsigned<I>::value || (0 <= pos.col && 0 <= pos.row));
    }

    constexpr Vector<I, 2> toPosition(std::size_t index) const noexcept {
      return { static_cast<I>(index % m_size.col), static_cast<I>(index / m_size.col) };
    }

    constexpr std::size_t toIndex(Vector<I, 2> pos) const noexcept {
      return pos.row * m_size.col + pos.col;
    }

    constexpr RangeZ getIndexRange() const noexcept {
      return { 0, static_cast<std::size_t>(m_size.col) * static_cast<std::size_t>(m_size.row) };
    }

    constexpr Range<I> getRowRange() const noexcept {
      return { 0, m_size.row };
    }

    constexpr Range<I> getColRange() const noexcept {
      return { 0, m_size.col };
    }

    constexpr PositionRange<I> getPositionRange() const noexcept {
      return { getColRange(), getRowRange() };
    }

    NeighborSquareRange<I> get8NeighborsRange(Vector<I, 2> pos) const noexcept {
      return getNeighborSquareRange(pos, 1);
    }

    NeighborSquareRange<I> get24NeighborsRange(Vector<I, 2> pos) const noexcept {
      return getNeighborSquareRange(pos, 2);
    }

    NeighborDiamondRange<I> get4NeighborsRange(Vector<I, 2> pos) const noexcept {
      return getNeighborDiamondRange(pos, 1);
    }

    NeighborDiamondRange<I> get12NeighborsRange(Vector<I, 2> pos) const noexcept {
      return getNeighborDiamondRange(pos, 2);
    }

  private:
    NeighborSquareRange<I> getNeighborSquareRange(Vector<I, 2> pos, I n) const noexcept {
      assert(isValid(pos));

      auto colMin = pos.col - std::min(pos.col, n);
      auto colMax = pos.col + std::min(m_size.col - pos.col - 1, n);
      auto rowMin = pos.row - std::min(pos.row, n);
      auto rowMax = pos.row + std::min(m_size.row - pos.row - 1, n);

      return NeighborSquareRange<I>{ Range<I>{ colMin, colMax + 1 }, Range<I>{ rowMin, rowMax + 1 }, pos };
    }

    NeighborDiamondRange<I> getNeighborDiamondRange(Vector<I, 2> pos, I n) const noexcept {
      assert(isValid(pos));

      auto colMin = pos.col - std::min(pos.col, n);
      auto colMax = pos.col + std::min(m_size.col - pos.col - 1, n);
      auto rowMin = pos.row - std::min(pos.row, n);
      auto rowMax = pos.row + std::min(m_size.row - pos.row - 1, n);

      return NeighborDiamondRange<I>{ Range<I>{ colMin, colMax + 1 }, Range<I>{ rowMin, rowMax + 1 }, pos, n };
    }

  private:
    Vector<I, 2> m_size;
  };

// MSVC does not like extern template
#ifndef _MSC_VER
  extern template class GF_CORE_API Index2D<unsigned>;
  extern template class GF_CORE_API Index2D<int>;
#endif

  template<typename T, typename I = unsigned>
  class Array2D : public Index2D<I> {
  public:
    Array2D()
    : Index2D<I>()
    {
    }

    Array2D(Vector<I, 2> size)
    : Index2D<I>(size)
    , m_data(static_cast<std::size_t>(size.width) * static_cast<std::size_t>(size.height))
    {
    }

    Array2D(Vector<I, 2> size, const T& value)
    : Index2D<I>(size)
    , m_data(static_cast<std::size_t>(size.width) * static_cast<std::size_t>(size.height), value)
    {
    }

    Array2D(const Array2D&) = default;

    Array2D& operator=(const Array2D&) = default;

    Array2D(Array2D&&) = default;

    Array2D& operator=(Array2D&&) = default;

    void swap(Array2D& other) {
      Index2D<I>::swap(other);
      std::swap(m_data, other.m_data);
    }

    using Index2D<I>::getSize;
    using Index2D<I>::getCols;
    using Index2D<I>::getRows;
    using Index2D<I>::isValid;
    using Index2D<I>::toPosition;
    using Index2D<I>::toIndex;
    using Index2D<I>::getIndexRange;
    using Index2D<I>::getRowRange;
    using Index2D<I>::getColRange;
    using Index2D<I>::getPositionRange;
    using Index2D<I>::get8NeighborsRange;
    using Index2D<I>::get24NeighborsRange;

    const T *getDataPtr() const noexcept {
      return m_data.data();
    }

    std::size_t getDataSize() const noexcept {
      return m_data.size();
    }

    constexpr bool isEmpty() const noexcept {
      return m_data.empty();
    }

    T& operator()(Vector<I, 2> pos) {
      return get(pos);
    }

    T& operator()(std::size_t index) {
      return m_data[index];
    }

    const T& operator()(Vector<I, 2> pos) const {
      return get(pos);
    }

    const T& operator()(std::size_t index) const {
      return m_data[index];
    }

    const T *begin() const noexcept {
      return m_data.data();
    }

    const T *end() const noexcept {
      return m_data.data() + m_data.size();
    }

    T *begin() noexcept {
      return m_data.data();
    }

    T *end() noexcept {
      return m_data.data() + m_data.size();
    }

  private:
    T& get(Vector<I, 2> pos) {
      return m_data[toIndex(pos)];
    }

    const T& get(Vector<I, 2> pos) const {
      return m_data[toIndex(pos)];
    }

  private:
    std::vector<T> m_data;
  };

  template<typename T, typename I>
  bool operator==(const Array2D<T,I>& lhs, const Array2D<T,I>& rhs) {
    auto lhsSize = lhs.getSize();
    auto rhsSize = rhs.getSize();

    if (lhsSize.width != rhsSize.width || lhsSize.height != rhsSize.height) {
      return false;
    }

    return std::equal(lhs.begin(), lhs.end(), rhs.begin(), rhs.end());
  }

  template<typename T, typename I>
  Serializer& operator|(Serializer& ar, const Array2D<T,I>& array) {
    auto size = array.getSize();
    ar | size.width | size.height;

    for (auto& item : array) {
      ar | const_cast<T&>(item);
    }

    return ar;
  }

  template<typename T, typename I>
  Deserializer& operator|(Deserializer& ar, Array2D<T,I>& array) {
    Vector<I, 2> size;
    ar | size.width | size.height;

    Array2D<T,I> tmp(size);

    for (auto& item : tmp) {
      ar | item;
    }

    array = std::move(tmp);
    return ar;
  }


#ifndef DOXYGEN_SHOULD_SKIP_THIS
}
#endif
}

#endif // ARRAY2D_H