Support.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_SUPPORT_H
#define BSPLINE_SUPPORT_SUPPORT_H
 
#include <bspline/exceptions/BSplineException.h>
#include <bspline/support/Grid.h>
 
#include <optional>
 
namespace bspline::support {
using namespace bspline::exceptions;
 
template <typename T>
class Support final {
 public:
  using AbsoluteIndex = size_t;
 
  using RelativeIndex = size_t;
 
  using const_iterator = typename Grid<T>::const_iterator;
 
 private:
  Grid<T> _grid;
  AbsoluteIndex _startIndex;
  AbsoluteIndex _endIndex;
 
  void checkValidity() const {
    const bool isEmpty = _startIndex == 0 && _endIndex == 0;
    const bool containsElement = _endIndex > _startIndex;
    const bool withinBounds = _endIndex <= _grid.size();
 
    const bool valid = isEmpty || (containsElement && withinBounds);
 
    if (!valid) {
      throw BSplineException(ErrorCode::INCONSISTENT_DATA);
    }
  }
 
 public:
  Support(const Grid<T> &grid, AbsoluteIndex startIndex, AbsoluteIndex endIndex)
      : _grid(grid), _startIndex(startIndex), _endIndex(endIndex) {
    checkValidity();
  };
 
  Support(const Support &s) noexcept = default;
 
  Support &operator=(const Support &s) noexcept = default;
 
  ~Support() = default;
 
  Support(Support &&s) noexcept
      : _grid{s._grid}, _startIndex{s._startIndex}, _endIndex{s._endIndex} {
    s._startIndex = 0;
    s._endIndex = 0;
 
    DURING_TEST_CHECK_VALIDITY();
    DURING_TEST_CHECK_VALIDITY_OF(s);
  }
 
  Support &operator=(Support &&s) noexcept {
    _grid = s._grid;
    _startIndex = s._startIndex;
    _endIndex = s._endIndex;
 
    s._startIndex = 0;
    s._endIndex = 0;
    DURING_TEST_CHECK_VALIDITY();
    DURING_TEST_CHECK_VALIDITY_OF(s);
 
    return *this;
  }
 
  static Support<T> createEmpty(const Grid<T> &grid) {
    return Support<T>{grid, 0, 0};
  };
 
  static Support<T> createWholeGrid(const Grid<T> &grid) {
    const auto gridSize = grid.size();
    return Support<T>{grid, 0, gridSize};
  };
 
  size_t size() const {
    DURING_TEST_CHECK_VALIDITY();
    return _endIndex - _startIndex;
  };
 
  bool empty() const {
    DURING_TEST_CHECK_VALIDITY();
    return (_startIndex == _endIndex);
  };
 
  bool containsIntervals() const {
    DURING_TEST_CHECK_VALIDITY();
    return (size() > 1);
  };
 
  std::optional<RelativeIndex> relativeFromAbsolute(AbsoluteIndex index) const {
    DURING_TEST_CHECK_VALIDITY();
    if (index >= _startIndex && index < _endIndex) {
      return index - _startIndex;
    } else {
      return std::nullopt;
    }
  };
 
  std::optional<RelativeIndex> intervalIndexFromAbsolute(
      AbsoluteIndex index) const {
    DURING_TEST_CHECK_VALIDITY();
    if (index >= _startIndex && index + 1 < _endIndex) {
      return index - _startIndex;
    } else {
      return std::nullopt;
    }
  };
 
  AbsoluteIndex absoluteFromRelative(RelativeIndex index) const {
    DURING_TEST_CHECK_VALIDITY();
    if (index >= size()) {
      throw BSplineException(ErrorCode::UNDETERMINED);
    }
    return index + _startIndex;
  };
 
  size_t numberOfIntervals() const {
    DURING_TEST_CHECK_VALIDITY();
    const size_t si = size();
    if (si == 0) {
      return 0;
    } else {
      return si - 1;
    }
  };
 
  const Grid<T> &getGrid() const {
    DURING_TEST_CHECK_VALIDITY();
    return _grid;
  };
 
  AbsoluteIndex getStartIndex() const {
    DURING_TEST_CHECK_VALIDITY();
    return _startIndex;
  };
 
  AbsoluteIndex getEndIndex() const {
    DURING_TEST_CHECK_VALIDITY();
    return _endIndex;
  }
 
  const T &operator[](RelativeIndex index) const {
    DURING_TEST_CHECK_VALIDITY();
    return _grid[_startIndex + index];
  };
 
  const T &at(RelativeIndex index) const {
    DURING_TEST_CHECK_VALIDITY();
    if (_startIndex + index >= _endIndex) {
      throw BSplineException(ErrorCode::INVALID_ACCESS);
    }
    return _grid.at(_startIndex + index);
  };
 
  const T &front() const {
    DURING_TEST_CHECK_VALIDITY();
    if (empty()) {
      throw BSplineException(ErrorCode::INVALID_ACCESS);
    }
    return _grid[_startIndex];
  };
 
  const T &back() const {
    DURING_TEST_CHECK_VALIDITY();
    if (empty()) {
      throw BSplineException(ErrorCode::INVALID_ACCESS);
    }
    return _grid[_endIndex - 1];
  };
 
  const_iterator begin() const {
    DURING_TEST_CHECK_VALIDITY();
    return _grid.begin() + _startIndex;
  };
 
  const_iterator end() const {
    DURING_TEST_CHECK_VALIDITY();
    return _grid.begin() + _endIndex;
  };
 
  bool hasSameGrid(const Support &s) const {
    DURING_TEST_CHECK_VALIDITY();
    return _grid == s._grid;
  };
 
  bool operator==(const Support &s) const {
    DURING_TEST_CHECK_VALIDITY();
    DURING_TEST_CHECK_VALIDITY_OF(s);
    return hasSameGrid(s) &&
           ((_startIndex == s._startIndex && _endIndex == s._endIndex) ||
            (empty() && s.empty()));
  };
 
  bool operator!=(const Support &s) const {
    DURING_TEST_CHECK_VALIDITY();
    DURING_TEST_CHECK_VALIDITY_OF(s);
    return !(*this == s);
  };
 
  Support calcUnion(const Support &s) const {
    DURING_TEST_CHECK_VALIDITY();
    DURING_TEST_CHECK_VALIDITY_OF(s);
    if (!hasSameGrid(s)) {
      throw BSplineException(ErrorCode::DIFFERING_GRIDS);
    }
 
    const bool thisEmpty = empty();
    const bool sEmpty = s.empty();
 
    if (thisEmpty && sEmpty) {
      // Both Supports are empty, return empty Support.
      return createEmpty(_grid);
    } else if (thisEmpty && !sEmpty) {
      return s;
    } else if (!thisEmpty && sEmpty) {
      return *this;
    }
 
    const size_t newStartIndex = std::min(_startIndex, s._startIndex);
    const size_t newEndIndex = std::max(_endIndex, s._endIndex);
    return Support(_grid, newStartIndex, newEndIndex);
  };
 
  Support calcIntersection(const Support &s) const {
    DURING_TEST_CHECK_VALIDITY();
    DURING_TEST_CHECK_VALIDITY_OF(s);
    if (!hasSameGrid(s)) {
      throw BSplineException(ErrorCode::DIFFERING_GRIDS);
    }
 
    const size_t newStartIndex = std::max(_startIndex, s._startIndex);
    const size_t newEndIndex = std::min(_endIndex, s._endIndex);
 
    if (newStartIndex >= newEndIndex) {
      // No overlap, return empty Support.
      return createEmpty(_grid);
    } else {
      return Support(_grid, newStartIndex, newEndIndex);
    }
  };
};  // end class Support
}  // namespace bspline::support
#endif  // BSPLINE_SUPPORT_SUPPORT_H