Array2D.h

/*
 * Gamedev Framework (gf)
 * Copyright (C) 2016-2018 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 "Log.h"

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

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

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

    }

    Array2D(Vector<I, 2> size)
    : m_size(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)
    : m_size(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) {
      std::swap(m_data, other.m_data);
      std::swap(m_size, other.m_size);
    }

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

    std::size_t getDataSize() const noexcept {
      return m_data.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 isEmpty() const noexcept {
      return m_data.empty();
    }

    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));
    }

    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];
    }

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

    template<typename Func>
    void visit4Neighbors(Vector<I, 2> pos, Func func) {
      visitNeighborsDiamond(pos, func, 1);
    }

    template<typename Func>
    void visit4Neighbors(Vector<I, 2> pos, Func func) const {
      visitNeighborsDiamond(pos, func, 1);
    }

    template<typename Func>
    void visit12Neighbors(Vector<I, 2> pos, Func func) {
      visitNeighborsDiamond(pos, func, 2);
    }

    template<typename Func>
    void visit12Neighbors(Vector<I, 2> pos, Func func) const {
      visitNeighborsDiamond(pos, func, 2);
    }

    template<typename Func>
    void visit8Neighbors(Vector<I, 2> pos, Func func) {
      visitNeighborsSquare(pos, func, 1);
    }

    template<typename Func>
    void visit8Neighbors(Vector<I, 2> pos, Func func) const {
      visitNeighborsSquare(pos, func, 1);
    }

    template<typename Func>
    void visit24Neighbors(Vector<I, 2> pos, Func func) {
      visitNeighborsSquare(pos, func, 2);
    }

    template<typename Func>
    void visit24Neighbors(Vector<I, 2> pos, Func func) const {
      visitNeighborsSquare(pos, func, 2);
    }

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

    constexpr RangeZ getIndexRange() const noexcept {
      return { 0, m_size.col * 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() };
    }

  private:
    T& get(Vector<I, 2> pos) {
      return m_data[pos.row * m_size.col + pos.col];
    }

    const T& get(Vector<I, 2> pos) const {
      return m_data[pos.row * m_size.col + pos.col];
    }

    template<typename Func>
    void visitNeighborsSquare(Vector<I, 2> pos, Func func, I n) const {
      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);

      for (auto row = rowMin; row <= rowMax; ++row) {
        for (auto col = colMin; col <= colMax; ++col) {
          if (col == pos.col && row == pos.row) { // avoid to include VectorOps.h
            continue;
          }

          func({ col, row }, get({ col, row }));
        }
      }
    }

    template<typename Func>
    void visitNeighborsSquare(Vector<I, 2> pos, Func func, I n) {
      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);

      for (auto row = rowMin; row <= rowMax; ++row) {
        for (auto col = colMin; col <= colMax; ++col) {
          if (col == pos.col && row == pos.row) { // avoid to include VectorOps.h
            continue;
          }

          func({ col, row }, get({ col, row }));
        }
      }
    }


    template<typename Func>
    void visitNeighborsDiamond(Vector<I, 2> pos, Func func, I n) const {
      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);

      for (auto row = rowMin; row <= rowMax; ++row) {
        for (auto col = colMin; col <= colMax; ++col) {
          if (col == pos.col && row == pos.row) { // avoid to include VectorOps.h
            continue;
          }

          if (gf::absdiff(col, pos.col) + gf::absdiff(row, pos.row) > n) {
            continue;
          }

          func({ col, row }, get({ col, row }));
        }
      }
    }

    template<typename Func>
    void visitNeighborsDiamond(Vector<I, 2> pos, Func func, I n) {
      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);

      for (auto row = rowMin; row <= rowMax; ++row) {
        for (auto col = colMin; col <= colMax; ++col) {
          if (col == pos.col && row == pos.row) { // avoid to include VectorOps.h
            continue;
          }

          if (gf::absdiff(col, pos.col) + gf::absdiff(row, pos.row) > n) {
            continue;
          }

          func({ col, row }, get({ col, row }));
        }
      }
    }

  private:
    Vector<I, 2> m_size;
    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 | 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