data_range.h

#ifndef STORAGE_DATA_RANGE_H
#define STORAGE_DATA_RANGE_H
 
#include <vkdb/concepts.h>
#include <vkdb/time_series_key.h>
#include <iostream>
 
namespace vkdb {
template <RegularNoCVRefQuals TData>
  requires std::totally_ordered<TData>
class DataRange {
public:
  using data_type = TData;
 
  DataRange() noexcept
    : is_set_{false} {}
 
  DataRange(const data_type& start, const data_type& end) noexcept
    : is_set_{true}, range_{start, end} {}
 
  DataRange(std::string&& str) {
    if (str == "null") {
      return;
    }
 
    auto ampersand_pos{str.find('&')};
    if (ampersand_pos == std::string::npos) {
      throw std::invalid_argument{
        "DataRange::DataRange(): Invalid range string '" + str + "'."
      };
    }
 
    if constexpr (std::is_same_v<data_type, TimeSeriesKey>) {
      range_.first = TimeSeriesKey{str.substr(0, ampersand_pos)};
      range_.second = TimeSeriesKey{str.substr(ampersand_pos + 1)};
    } else {
      range_.first = std::stod(str.substr(0, ampersand_pos));
      range_.second = std::stod(str.substr(ampersand_pos + 1));
    }
 
    is_set_ = true;
  }
 
  DataRange(DataRange&&) noexcept = default;
 
  DataRange& operator=(DataRange&&) noexcept = default;
 
  DataRange(const DataRange&) noexcept = default;
 
  DataRange& operator=(const DataRange&) noexcept = default;
 
  ~DataRange() noexcept = default;
 
  [[nodiscard]] auto operator<=>(const DataRange& other) const noexcept {
    if (!is_set_) {
      return std::strong_ordering::less;
    }
    if (!other.is_set_) {
      return std::strong_ordering::greater;
    }
    return range_ <=> other.range_;
  }
 
  void updateRange(const data_type& data) noexcept {
    if (!is_set_) {
      range_.first = data;
      range_.second = data;
      is_set_ = true;
      return;
    }
 
    range_.first = std::min(range_.first, data);
    range_.second = std::max(range_.second, data);
  }
 
  [[nodiscard]] bool inRange(const data_type& data) const noexcept {
    return is_set_ && data >= range_.first && data <= range_.second;
  }
 
  [[nodiscard]] bool overlapsWith(
    const data_type& start,
    const data_type& end
  ) const noexcept {
    return is_set_ && range_.first <= end && range_.second >= start;
  }
 
  [[nodiscard]] data_type lower() const {
    if (!is_set_) {
      throw std::logic_error{"DataRange::lower(): Range is not set."};
    }
    return range_.first;
  }
 
  [[nodiscard]] data_type upper() const {
    if (!is_set_) {
      throw std::logic_error{"DataRange::upper(): Range is not set."};
    }
    return range_.second;
  }
 
  void clear() noexcept {
    is_set_ = false;
  }
 
  [[nodiscard]] std::string str() const noexcept {
    if (!is_set_) {
      return "null";
    }
 
    if constexpr (std::is_same_v<data_type, TimeSeriesKey>) {
      return range_.first.str() + "&" + range_.second.str();
    } else {
      return std::to_string(range_.first)
        + "&" + std::to_string(range_.second);
    }
  }
 
private:
  bool is_set_;
 
  std::pair<data_type, data_type> range_;
};
 
using TimeRange = DataRange<Timestamp>;
 
using KeyRange = DataRange<TimeSeriesKey>;
}  // namespace vkdb
 
#endif // STORAGE_DATA_RANGE_H