market_data.hpp

#pragma once
 
#include "./types.hpp"
 
#include <algorithm>
#include <array>
#include <chrono>
#include <optional>
#include <string>
#include <vector>
 
namespace algotradelib {

enum class BarInterval {
  ONE_MINUTE,
  ONE_DAY,
  ONE_WEEK,
  ONE_MONTH,
  ONE_YEAR,
  FIVE_MINUTES,
  FIFTEEN_MINUTES,
  THIRTY_MINUTES,
  ONE_HOUR,
};

inline constexpr std::array<BarInterval, 9> all_bar_intervals{
  BarInterval::ONE_MINUTE,
  BarInterval::ONE_DAY,
  BarInterval::ONE_WEEK,
  BarInterval::ONE_MONTH,
  BarInterval::ONE_YEAR,
  BarInterval::FIVE_MINUTES,
  BarInterval::FIFTEEN_MINUTES,
  BarInterval::THIRTY_MINUTES,
  BarInterval::ONE_HOUR,
};

inline constexpr std::string_view bar_interval_name(BarInterval interval) noexcept {
  switch (interval) {
    case BarInterval::ONE_MINUTE:
      return "1m";
    case BarInterval::ONE_DAY:
      return "1d";
    case BarInterval::ONE_WEEK:
      return "1w";
    case BarInterval::ONE_MONTH:
      return "1mo";
    case BarInterval::ONE_YEAR:
      return "1y";
    case BarInterval::FIVE_MINUTES:
      return "5m";
    case BarInterval::FIFTEEN_MINUTES:
      return "15m";
    case BarInterval::THIRTY_MINUTES:
      return "30m";
    case BarInterval::ONE_HOUR:
      return "1h";
  }
  return "";
}

inline constexpr std::optional<std::chrono::seconds> bar_interval_length(BarInterval interval) noexcept {
  switch (interval) {
    case BarInterval::ONE_MINUTE:
      return std::chrono::seconds(60);
    case BarInterval::FIVE_MINUTES:
      return std::chrono::seconds(300);
    case BarInterval::FIFTEEN_MINUTES:
      return std::chrono::seconds(900);
    case BarInterval::THIRTY_MINUTES:
      return std::chrono::seconds(1800);
    case BarInterval::ONE_HOUR:
      return std::chrono::seconds(3600);
    case BarInterval::ONE_DAY:
    case BarInterval::ONE_WEEK:
    case BarInterval::ONE_MONTH:
    case BarInterval::ONE_YEAR:
      return std::nullopt;
  }
  return std::nullopt;
}
 
static_assert(
  lists_every_value(all_bar_intervals, [](BarInterval interval) { return !bar_interval_name(interval).empty(); }),
  "all_bar_intervals must list every BarInterval"
);

enum class BarStamp {
  OPEN,
  CLOSE,
};

struct Bar {
  std::chrono::system_clock::time_point timestamp_;
  std::optional<Decimal64> open_;
  Decimal64 high_;
  Decimal64 low_;
  Decimal64 close_;
  Decimal64 volume_;
  std::optional<Decimal64> traded_value_;
};

struct BarSeries {
  InstrumentId instrument_;
  BarInterval interval_{BarInterval::ONE_DAY};
  BarStamp stamp_{BarStamp::CLOSE};
  Currency currency_;
  bool adjusted_{true};
  std::vector<Bar> bars_;
  std::optional<std::string> next_cursor_;
  std::chrono::system_clock::time_point received_at_;

  bool ascending() const {
    for (std::size_t index = 1; index < bars_.size(); ++index) {
      if (!(bars_[index - 1].timestamp_ < bars_[index].timestamp_)) {
        return false;
      }
    }
    return true;
  }
};

struct DepthLevel {
  Decimal64 price_;
  Decimal64 quantity_;
};

struct DepthSnapshot {
  InstrumentId instrument_;
  std::vector<DepthLevel> bids_;
  std::vector<DepthLevel> asks_;
  Currency currency_;
  std::optional<std::chrono::system_clock::time_point> exchange_time_;
  std::chrono::system_clock::time_point received_at_;

  std::optional<DepthLevel> best_bid() const {
    return bids_.empty() ? std::nullopt : std::optional<DepthLevel>(bids_.front());
  }

  std::optional<DepthLevel> best_ask() const {
    return asks_.empty() ? std::nullopt : std::optional<DepthLevel>(asks_.front());
  }

  std::optional<Decimal64> spread() const {
    const auto bid = best_bid();
    const auto ask = best_ask();
    if (!bid || !ask) {
      return std::nullopt;
    }
    return decimal_subtract(ask->price_, bid->price_);
  }

  std::optional<Decimal64> mid() const {
    const auto bid = best_bid();
    const auto ask = best_ask();
    if (!bid || !ask) {
      return std::nullopt;
    }
    const auto sum = decimal_add(bid->price_, ask->price_);
    if (!sum) {
      return std::nullopt;
    }
    return decimal_halve(*sum);
  }
};

inline void order_depth(DepthSnapshot& book) {
  const auto by_price = [](const DepthLevel& lhs, const DepthLevel& rhs) {
    return decimal_less(lhs.price_, rhs.price_);
  };
  std::sort(book.asks_.begin(), book.asks_.end(), by_price);
  std::sort(book.bids_.begin(), book.bids_.end(), [&by_price](const auto& l, const auto& r) {
    return by_price(r, l);
  });
}

struct TradePrint {
  Decimal64 price_;
  Decimal64 quantity_;
  Currency currency_;
  std::optional<std::chrono::system_clock::time_point> exchange_time_;
};

struct PriceLimits {
  std::optional<Decimal64> upper_;
  std::optional<Decimal64> lower_;
  Currency currency_;
  std::optional<std::chrono::system_clock::time_point> exchange_time_;
};

struct BarQuery {
  InstrumentId instrument_;
  BarInterval interval_{BarInterval::ONE_DAY};
  int count_{100};
  std::optional<std::chrono::system_clock::time_point> before_;
  bool adjusted_{true};
};
 
} // namespace algotradelib