Grid.h

/*
 * ########################################################################
 * The contents of this file is free and unencumbered software released into the
 * public domain. For more information, please refer to <http://unlicense.org/>
 * ########################################################################
 */
 
#ifndef BSPLINE_SUPPORT_GRID_H
#define BSPLINE_SUPPORT_GRID_H
 
#include <bspline/exceptions/BSplineException.h>
#include <bspline/internal/misc.h>
#include <bspline/internal/test_checks.h>
 
#include <algorithm>
#include <memory>
#include <vector>
 
namespace bspline::support {
using namespace bspline::exceptions;
 
template <typename T>
class Grid final {
 private:
  std::shared_ptr<const std::vector<T>> _data;
 
  bool isSteadilyIncreasing() const {
    for (size_t i = 1; i < _data->size(); i++) {
      if ((*_data)[i - 1] >= (*_data)[i]) {
        return false;
      }
    }
    return true;
  }
 
  void checkValidity() const {
    // Check the validity of the provided data.
    if (!_data || _data->size() < 2) {
      throw BSplineException(ErrorCode::MISSING_DATA);
    } else if (!isSteadilyIncreasing()) {
      throw BSplineException(ErrorCode::INCONSISTENT_DATA,
                             "The grid points are not steadily increasing.");
    }
  }
 
 public:
  using const_iterator = typename std::vector<T>::const_iterator;
 
  Grid() = delete;
 
  template <typename Iter>
  Grid(Iter begin, Iter end)
      : Grid(std::make_shared<const std::vector<T>>(begin, end)) {}
 
  explicit Grid(std::vector<T> v)
      : Grid(std::make_shared<const std::vector<T>>(std::move(v))){};
 
  explicit Grid(const std::initializer_list<T> &v) : Grid(v.begin(), v.end()){};
 
  explicit Grid(std::shared_ptr<const std::vector<T>> data)
      : _data(std::move(data)) {
    checkValidity();
  };
 
  Grid(const Grid &g) noexcept = default;
 
  Grid &operator=(const Grid &g) noexcept = default;
 
  ~Grid() = default;
 
  Grid(Grid &&g) = delete;
 
  Grid &operator=(Grid &&g) = delete;
 
  bool operator==(const Grid &g) const {
    DURING_TEST_CHECK_VALIDITY();
    DURING_TEST_CHECK_VALIDITY_OF(g);
    if (_data == g._data) {
      // Fast path: Compare pointers.
      return true;
    }
 
    // Slow path: Compare logically.
    return (*_data) == (*g._data);
  }
 
  bool operator!=(const Grid &g) const { return !(*this == g); }
 
  size_t size() const {
    DURING_TEST_CHECK_VALIDITY();
    return _data->size();
  };
 
  std::shared_ptr<const std::vector<T>> getData() const {
    DURING_TEST_CHECK_VALIDITY();
    return _data;
  };
 
  bool empty() const {
    DURING_TEST_CHECK_VALIDITY();
    return _data->empty();
  };
 
  const T &operator[](size_t i) const {
    DURING_TEST_CHECK_VALIDITY();
    return (*_data)[i];
  };
 
  const T &at(size_t i) const {
    DURING_TEST_CHECK_VALIDITY();
    if (i >= size()) {
      throw BSplineException(ErrorCode::INVALID_ACCESS);
    }
    return (*_data)[i];
  };
 
  const T &front() const {
    DURING_TEST_CHECK_VALIDITY();
    if (empty()) {
      throw BSplineException(ErrorCode::INVALID_ACCESS);
    }
    return _data->front();
  };
 
  const T &back() const {
    DURING_TEST_CHECK_VALIDITY();
    if (empty()) {
      throw BSplineException(ErrorCode::INVALID_ACCESS);
    }
    return _data->back();
  };
 
  const_iterator begin() const {
    DURING_TEST_CHECK_VALIDITY();
    return _data->begin();
  };
 
  const_iterator end() const {
    DURING_TEST_CHECK_VALIDITY();
    return _data->end();
  };
 
  size_t findElement(const T &x) const {
    DURING_TEST_CHECK_VALIDITY();
    const auto beginIt = begin();
    const auto endIt = end();
    const auto elementIt = std::lower_bound(beginIt, endIt, x);
 
    if (elementIt == endIt || *elementIt != x) {
      // Element was not found
      throw BSplineException(ErrorCode::INCONSISTENT_DATA);
    } else {
      return std::distance(beginIt, elementIt);
    }
  };
};
}  // namespace bspline::support
#endif  // BSPLINE_SUPPORT_GRID_H