event.hpp

Go to the documentation of this file.

#pragma once
 
#include <algotradelib/core>
 
#include <array>
#include <chrono>
#include <cstdint>
#include <optional>
#include <ratio>
#include <string>
#include <vector>
 
namespace algotradelib {
namespace strategy {


enum class MarketPhase {
  UNKNOWN,
  CLOSED,
  PRE_OPEN,
  OPEN,
  POST_CLOSE,
};

inline constexpr std::array<MarketPhase, 5> all_market_phases{
  MarketPhase::UNKNOWN,
  MarketPhase::CLOSED,
  MarketPhase::PRE_OPEN,
  MarketPhase::OPEN,
  MarketPhase::POST_CLOSE,
};

inline constexpr std::string_view market_phase_name(MarketPhase phase) noexcept {
  switch (phase) {
    case MarketPhase::UNKNOWN:
      return "unknown";
    case MarketPhase::CLOSED:
      return "closed";
    case MarketPhase::PRE_OPEN:
      return "pre_open";
    case MarketPhase::OPEN:
      return "open";
    case MarketPhase::POST_CLOSE:
      return "post_close";
  }
  return "";
}

inline constexpr bool market_phase_session_ended(MarketPhase phase) noexcept {
  switch (phase) {
    case MarketPhase::CLOSED:
    case MarketPhase::POST_CLOSE:
      return true;
    case MarketPhase::UNKNOWN:
    case MarketPhase::PRE_OPEN:
    case MarketPhase::OPEN:
      return false;
  }
  return false;
}
 
static_assert(
  lists_every_value(all_market_phases, [](MarketPhase phase) { return !market_phase_name(phase).empty(); }),
  "all_market_phases must list every MarketPhase"
);

struct SessionWindow {
  std::chrono::minutes open_{std::chrono::hours(9)};
  std::chrono::minutes close_{std::chrono::hours(15) + std::chrono::minutes(30)};
  std::chrono::minutes utc_offset_{std::chrono::hours(9)};
  std::string source_{"KRX regular session, 09:00-15:30 KST (library default)"};

  static SessionWindow krx() { return SessionWindow{}; }

  MarketPhase phase(
    std::chrono::system_clock::time_point now,
    std::optional<bool> trading_day
  ) const {
    if (!trading_day) {
      return MarketPhase::UNKNOWN;
    }
    if (!*trading_day) {
      return MarketPhase::CLOSED;
    }
    const auto local = now + utc_offset_;
    const auto since_midnight =
      std::chrono::duration_cast<std::chrono::minutes>(local - local_midnight(now));
    if (since_midnight < open_) {
      return MarketPhase::PRE_OPEN;
    }
    if (close_ <= since_midnight) {
      return MarketPhase::POST_CLOSE;
    }
    return MarketPhase::OPEN;
  }

  Date local_date(std::chrono::system_clock::time_point now) const {
    using Days = std::chrono::duration<std::int64_t, std::ratio<86400>>;
    return date_from_epoch_days(
      std::chrono::duration_cast<Days>(local_midnight(now).time_since_epoch()).count()
    );
  }

  std::chrono::system_clock::time_point opens_at(
    std::chrono::system_clock::time_point now
  ) const {
    return local_midnight(now) - utc_offset_ + open_;
  }
 
private:
  // The market's local midnight before `now`, as a UTC-shifted instant. floor rounds toward
  // negative infinity, so instants before the epoch work too. phase() and local_date() share it so
  // they always agree on the day.
  std::chrono::time_point<std::chrono::system_clock, std::chrono::seconds> local_midnight(
    std::chrono::system_clock::time_point now
  ) const {
    using Days = std::chrono::duration<std::int64_t, std::ratio<86400>>;
    return std::chrono::time_point_cast<std::chrono::seconds>(
      std::chrono::floor<Days>(now + utc_offset_)
    );
  }
};

struct BarEvent {
  InstrumentId instrument_;
  BarInterval interval_{BarInterval::ONE_DAY};
  BarStamp stamp_{BarStamp::CLOSE};
  Bar bar_;
  std::chrono::system_clock::time_point period_end_{};
};

inline std::chrono::system_clock::time_point bar_period_end(
  const Bar& bar,
  BarInterval interval,
  BarStamp stamp
) {
  if (stamp == BarStamp::CLOSE) {
    return bar.timestamp_;
  }
  switch (interval) {
    case BarInterval::ONE_MINUTE:
      return bar.timestamp_ + std::chrono::minutes(1);
    case BarInterval::FIVE_MINUTES:
      return bar.timestamp_ + std::chrono::minutes(5);
    case BarInterval::FIFTEEN_MINUTES:
      return bar.timestamp_ + std::chrono::minutes(15);
    case BarInterval::THIRTY_MINUTES:
      return bar.timestamp_ + std::chrono::minutes(30);
    case BarInterval::ONE_HOUR:
      return bar.timestamp_ + std::chrono::hours(1);
    case BarInterval::ONE_DAY:
      return bar.timestamp_ + std::chrono::hours(24);
    case BarInterval::ONE_WEEK:
      return bar.timestamp_ + std::chrono::hours(24 * 7);
    case BarInterval::ONE_MONTH:
      // Nominal: a month has no fixed length. Documented on the function.
      return bar.timestamp_ + std::chrono::hours(24 * 31);
    case BarInterval::ONE_YEAR:
      return bar.timestamp_ + std::chrono::hours(24 * 366);
  }
  return bar.timestamp_;
}

inline BarEvent make_bar_event(
  InstrumentId instrument,
  BarInterval interval,
  BarStamp stamp,
  Bar bar
) {
  BarEvent event;
  event.instrument_ = std::move(instrument);
  event.interval_ = interval;
  event.stamp_ = stamp;
  event.period_end_ = bar_period_end(bar, interval, stamp);
  event.bar_ = std::move(bar);
  return event;
}

struct BarSlice {
  std::chrono::system_clock::time_point period_end_{};
  BarInterval interval_{BarInterval::ONE_DAY};
  std::vector<BarEvent> bars_;

  const BarEvent* find(const InstrumentId& id) const noexcept {
    for (const auto& event : bars_) {
      if (event.instrument_ == id) {
        return &event;
      }
    }
    return nullptr;
  }
};

namespace slice_detail {

class Bucket {
public:
  bool empty() const noexcept { return slices_.empty(); }

  std::chrono::system_clock::time_point period_end() const noexcept { return period_end_; }

  bool holds(const BarEvent& event) const noexcept {
    for (const auto& slice : slices_) {
      if (slice.interval_ == event.interval_) {
        return slice.find(event.instrument_) != nullptr;
      }
    }
    return false;
  }

  void add(const BarEvent& event) {
    if (slices_.empty()) {
      period_end_ = event.period_end_;
    }
    for (auto& slice : slices_) {
      if (slice.interval_ == event.interval_) {
        slice.bars_.push_back(event);
        return;
      }
    }
    BarSlice slice;
    slice.period_end_ = event.period_end_;
    slice.interval_ = event.interval_;
    slice.bars_.push_back(event);
    slices_.push_back(std::move(slice));
  }

  BarSlice take_first() {
    BarSlice slice = std::move(slices_.front());
    slices_.erase(slices_.begin());
    return slice;
  }

  std::vector<BarSlice> take() {
    std::vector<BarSlice> slices = std::move(slices_);
    slices_.clear();
    return slices;
  }

  void clear() noexcept { slices_.clear(); }
 
private:
  std::chrono::system_clock::time_point period_end_{};
  std::vector<BarSlice> slices_;
};
 
} // namespace slice_detail

struct QuoteEvent {
  QuoteSnapshot quote_;
};

struct Fill {
  std::string order_id_;
  InstrumentId instrument_;
  OrderSide side_{OrderSide::BUY};
  Decimal64 quantity_;
  Decimal64 price_;
  std::string tag_;
  std::chrono::system_clock::time_point at_{};
};
 
} // namespace strategy
} // namespace algotradelib