time_index.hpp

#pragma once
 
#include <algorithm>
#include <chrono>
#include <cstddef>
#include <optional>
#include <stdexcept>
#include <utility>
#include <vector>
 
namespace algotradelib {
namespace analytics {

class TimeIndex {
public:
  using Instant = std::chrono::system_clock::time_point;

  TimeIndex() = default;

  explicit TimeIndex(std::vector<Instant> stamps) : stamps_(std::move(stamps)) {
    for (std::size_t position = 1; position < stamps_.size(); ++position) {
      if (!(stamps_[position - 1] < stamps_[position])) {
        throw std::invalid_argument("time index must be strictly ascending");
      }
    }
  }

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

  bool empty() const noexcept { return stamps_.empty(); }

  const Instant& at(std::size_t position) const {
    if (position >= stamps_.size()) {
      throw std::out_of_range("time index position is past the end");
    }
    return stamps_[position];
  }

  const std::vector<Instant>& stamps() const noexcept { return stamps_; }

  std::optional<std::size_t> find(const Instant& when) const {
    const auto found = std::lower_bound(stamps_.begin(), stamps_.end(), when);
    if (found == stamps_.end() || *found != when) {
      return std::nullopt;
    }
    return static_cast<std::size_t>(found - stamps_.begin());
  }

  std::optional<std::size_t> asof(const Instant& when) const {
    const auto above = std::upper_bound(stamps_.begin(), stamps_.end(), when);
    if (above == stamps_.begin()) {
      return std::nullopt;
    }
    return static_cast<std::size_t>((above - 1) - stamps_.begin());
  }

  friend bool operator==(const TimeIndex& lhs, const TimeIndex& rhs) {
    return lhs.stamps_ == rhs.stamps_;
  }

  friend bool operator!=(const TimeIndex& lhs, const TimeIndex& rhs) { return !(lhs == rhs); }
 
private:
  std::vector<Instant> stamps_;
};
 
} // namespace analytics
} // namespace algotradelib