concept.hpp

Go to the documentation of this file.

#pragma once
 
#include "./event.hpp"
#include "./intent.hpp"
#include "./portfolio.hpp"
 
#include <chrono>
#include <optional>
#include <string>
#include <string_view>
#include <type_traits>
#include <utility>
#include <vector>
 
namespace algotradelib {
namespace strategy {

 
namespace strategy_detail {

#define ATL_DETECT_DECLARED(NAME)                                                        \
  struct NAME##_fallback {                                                               \
    int NAME;                                                                            \
  };                                                                                     \
  template <typename S>                                                                  \
  struct NAME##_probe : S, NAME##_fallback {};                                           \
  template <typename S, typename = void>                                                 \
  struct NAME##_is_ambiguous : std::true_type {};                                        \
  template <typename S>                                                                  \
  struct NAME##_is_ambiguous<S, std::void_t<decltype(&NAME##_probe<S>::NAME)>>           \
  : std::false_type {};                                                                  \
  template <typename S>                                                                  \
  constexpr bool declares_##NAME = std::conjunction_v<                                   \
    std::is_class<S>, std::negation<std::is_final<S>>, NAME##_is_ambiguous<S>            \
  >
 
ATL_DETECT_DECLARED(on_start);
ATL_DETECT_DECLARED(on_stop);
ATL_DETECT_DECLARED(on_bar);
ATL_DETECT_DECLARED(on_bars);
ATL_DETECT_DECLARED(on_quote);
ATL_DETECT_DECLARED(on_fill);
ATL_DETECT_DECLARED(on_order_update);
ATL_DETECT_DECLARED(on_phase);
 
#undef ATL_DETECT_DECLARED

template <typename S>
constexpr bool declares_any_handler =
  declares_on_start<S> || declares_on_stop<S> || declares_on_bar<S> || declares_on_bars<S> ||
  declares_on_quote<S> || declares_on_fill<S> || declares_on_order_update<S> || declares_on_phase<S>;

template <typename S>
constexpr bool names_can_be_read = std::is_class_v<S> && !std::is_final_v<S>;

template <typename S>
void require_readable_names() {
  static_assert(
    names_can_be_read<S>,
    "a final strategy cannot be checked for a handler the runner would skip, because its member names "
    "cannot be looked up; remove `final` from the strategy class"
  );
}

template <typename S>
void require_one_bar_handler() {
  static_assert(
    !(declares_on_bar<S> && declares_on_bars<S>),
    "a strategy declares on_bar or on_bars, not both: on_bar receives each bar, on_bars every "
    "instrument's bar of a period at once; keep the one this strategy decides with"
  );
}
 
} // namespace strategy_detail

namespace dispatch {

template <typename S, typename Ctx>
void start(S& strategy, Ctx& context) {
  strategy_detail::require_readable_names<S>();
  if constexpr (strategy_detail::declares_on_start<S>) {
    strategy.on_start(context);
  } else {
    static_cast<void>(strategy);
    static_cast<void>(context);
  }
}

template <typename S, typename Ctx>
void stop(S& strategy, Ctx& context) {
  strategy_detail::require_readable_names<S>();
  if constexpr (strategy_detail::declares_on_stop<S>) {
    strategy.on_stop(context);
  } else {
    static_cast<void>(strategy);
    static_cast<void>(context);
  }
}

template <typename S, typename Ctx>
void bar(S& strategy, Ctx& context, const BarEvent& event) {
  strategy_detail::require_readable_names<S>();
  strategy_detail::require_one_bar_handler<S>();
  static_assert(
    strategy_detail::declares_on_bar<S> || !strategy_detail::declares_on_bars<S>,
    "this strategy declares on_bars, so its bars are delivered in slices: feed it through "
    "Runner::record and Runner::feed(const BarSlice&), not one BarEvent at a time"
  );
  if constexpr (strategy_detail::declares_on_bar<S>) {
    strategy.on_bar(context, event);
  } else {
    static_cast<void>(strategy);
    static_cast<void>(context);
    static_cast<void>(event);
  }
}

template <typename S, typename Ctx>
void bars(S& strategy, Ctx& context, const BarSlice& slice) {
  strategy_detail::require_readable_names<S>();
  strategy_detail::require_one_bar_handler<S>();
  if constexpr (strategy_detail::declares_on_bars<S>) {
    strategy.on_bars(context, slice);
  } else {
    static_cast<void>(strategy);
    static_cast<void>(context);
    static_cast<void>(slice);
  }
}

template <typename S, typename Ctx>
void quote(S& strategy, Ctx& context, const QuoteEvent& event) {
  strategy_detail::require_readable_names<S>();
  if constexpr (strategy_detail::declares_on_quote<S>) {
    strategy.on_quote(context, event);
  } else {
    static_cast<void>(strategy);
    static_cast<void>(context);
    static_cast<void>(event);
  }
}

template <typename S, typename Ctx>
void fill(S& strategy, Ctx& context, const Fill& event) {
  strategy_detail::require_readable_names<S>();
  if constexpr (strategy_detail::declares_on_fill<S>) {
    strategy.on_fill(context, event);
  } else {
    static_cast<void>(strategy);
    static_cast<void>(context);
    static_cast<void>(event);
  }
}

template <typename S, typename Ctx>
void order_update(S& strategy, Ctx& context, const OrderSnapshot& event) {
  strategy_detail::require_readable_names<S>();
  if constexpr (strategy_detail::declares_on_order_update<S>) {
    strategy.on_order_update(context, event);
  } else {
    static_cast<void>(strategy);
    static_cast<void>(context);
    static_cast<void>(event);
  }
}

template <typename S, typename Ctx>
void phase(S& strategy, Ctx& context, const MarketPhase& event) {
  strategy_detail::require_readable_names<S>();
  if constexpr (strategy_detail::declares_on_phase<S>) {
    strategy.on_phase(context, event);
  } else {
    static_cast<void>(strategy);
    static_cast<void>(context);
    static_cast<void>(event);
  }
}
 
} // namespace dispatch
 
namespace strategy_detail {

template <typename S, typename Ctx>
void call_every_handler(
  S& strategy, Ctx& context, const BarEvent& bar, const BarSlice& slice, const QuoteEvent& quote,
  const Fill& fill, const OrderSnapshot& order, const MarketPhase& phase
) {
  dispatch::start(strategy, context);
  dispatch::stop(strategy, context);
  // The bar route the runner takes: slices for a strategy declaring `on_bars`, single bars otherwise.
  if constexpr (declares_on_bars<S>) {
    static_cast<void>(bar);
    dispatch::bars(strategy, context, slice);
  } else {
    static_cast<void>(slice);
    dispatch::bar(strategy, context, bar);
  }
  dispatch::quote(strategy, context, quote);
  dispatch::fill(strategy, context, fill);
  dispatch::order_update(strategy, context, order);
  dispatch::phase(strategy, context, phase);
}

template <typename S, typename Ctx>
constexpr bool compiles_every_handler_call() {
  if constexpr (names_can_be_read<S>) {
    static_cast<void>(&call_every_handler<S, Ctx>);
  }
  return true;
}
 
} // namespace strategy_detail

struct NoCaps {
  static constexpr bool has_account_discovery = false;
  static constexpr bool has_client_order_id = false;
  static constexpr bool has_trigger_price = false;
  static constexpr bool data_only = false;
  static constexpr bool has_working_orders = false;
  static constexpr bool working_orders_state_terminal = false;
  static constexpr bool has_amendable_quantity = false;
  static constexpr bool has_order_by_id = false;
  static constexpr bool has_partial_cancel = false;
  static constexpr bool history_requires_range = false;
  static constexpr bool has_history_cursor = false;
  static constexpr bool has_history_limit = false;
  static constexpr bool has_history_symbol_filter = false;
  static constexpr bool has_depth = false;
  static constexpr bool has_price_limits = false;
  static constexpr bool has_trade_prints = false;
  static constexpr bool has_batch_prices = false;
  static constexpr bool has_reference_data = false;
  static constexpr bool has_batch_reference_data = false;
  static constexpr bool has_calendar = false;
  static constexpr bool has_calendar_range = false;
  static constexpr bool has_calendar_sessions = false;
  static constexpr bool has_buying_power = false;
  static constexpr bool has_buying_power_quantity = false;
  static constexpr bool has_commission_schedule = false;
  static constexpr SellableSource sellable_source = SellableSource::NONE;
  static constexpr SellableBasis sellable_inquiry_basis{};
  static constexpr bool supports_interval(BarInterval) { return false; }
};

struct AllCaps {
  static constexpr bool has_account_discovery = true;
  static constexpr bool has_client_order_id = true;
  static constexpr bool has_trigger_price = true;
  static constexpr bool data_only = false;
  static constexpr bool has_working_orders = true;
  static constexpr bool working_orders_state_terminal = true;
  static constexpr bool has_amendable_quantity = true;
  static constexpr bool has_order_by_id = true;
  static constexpr bool has_partial_cancel = true;
  static constexpr bool history_requires_range = true;
  static constexpr bool has_history_cursor = true;
  static constexpr bool has_history_limit = true;
  static constexpr bool has_history_symbol_filter = true;
  static constexpr bool has_depth = true;
  static constexpr bool has_price_limits = true;
  static constexpr bool has_trade_prints = true;
  static constexpr bool has_batch_prices = true;
  static constexpr bool has_reference_data = true;
  static constexpr bool has_batch_reference_data = true;
  static constexpr bool has_calendar = true;
  static constexpr bool has_calendar_range = true;
  static constexpr bool has_calendar_sessions = true;
  static constexpr bool has_buying_power = true;
  static constexpr bool has_buying_power_quantity = true;
  static constexpr bool has_commission_schedule = true;
  static constexpr SellableSource sellable_source = SellableSource::INQUIRY;
  static constexpr SellableBasis sellable_inquiry_basis{
    SellableBasis::Coverage::WHOLE_HOLDING,
    SellableBasis::RestingTreatment::DEDUCT,
    false,
  };

  static constexpr bool supports_interval(BarInterval) { return true; }
};

struct ProbeBroker {
  static constexpr std::string_view name = "probe";
};

template <typename CapsType>
class ProbeContextT {
public:
  using Broker = ProbeBroker;
  using caps = CapsType;

  ProbeContextT() = default;
  ProbeContextT(const ProbeContextT&) = delete;
  ProbeContextT& operator=(const ProbeContextT&) = delete;
  ProbeContextT(ProbeContextT&&) = default;
  ProbeContextT& operator=(ProbeContextT&&) = default;

  class Log {
  public:
    void note(std::string_view message) { lines_.emplace_back(message); }
    const std::vector<std::string>& lines() const noexcept { return lines_; }
 
  private:
    std::vector<std::string> lines_;
  };

  std::chrono::system_clock::time_point now() const noexcept { return now_; }

  MarketPhase phase() const noexcept { return phase_; }

  const TradingCalendar& calendar() const noexcept { return calendar_; }

  const Portfolio<ProbeBroker>& portfolio() const noexcept { return portfolio_; }

  std::optional<Instrument> instrument(const InstrumentId& id) const {
    for (const auto& known : instruments_) {
      if (known.id_ == id) {
        return known;
      }
    }
    return std::nullopt;
  }

  void submit(OrderIntent intent) { submitted_.push_back(std::move(intent)); }

  void submit(TargetPosition target) { targets_.push_back(std::move(target)); }

  void cancel(const OrderRef<ProbeBroker>& ref) {
    canceled_.push_back(CancelIntent<ProbeBroker>{ref, {}});
  }

  Log& log() noexcept { return log_; }

  const std::vector<OrderIntent>& submitted() const noexcept { return submitted_; }
  const std::vector<TargetPosition>& targets() const noexcept { return targets_; }
  const std::vector<CancelIntent<ProbeBroker>>& canceled() const noexcept { return canceled_; }

  std::chrono::system_clock::time_point now_{};
  MarketPhase phase_{MarketPhase::OPEN};
  TradingCalendar calendar_;
  Portfolio<ProbeBroker> portfolio_;
  std::vector<Instrument> instruments_;
 
private:
  std::vector<OrderIntent> submitted_;
  std::vector<TargetPosition> targets_;
  std::vector<CancelIntent<ProbeBroker>> canceled_;
  Log log_;
};

using MinimalContext = ProbeContextT<NoCaps>;

using FullContext = ProbeContextT<AllCaps>;

template <typename S, typename Ctx>
struct StrategyConformance {
  // A strategy's handler names are looked up through a class derived from it, which a `final` class does
  // not allow; read any other way, a handler the runner cannot call could be skipped in silence.
  static_assert(
    strategy_detail::names_can_be_read<S>,
    "a final strategy cannot be checked for a handler the runner would skip, because its member names "
    "cannot be looked up; remove `final` from the strategy class"
  );
  // A handler taking its context by value would submit to a copy, and what it submitted would be lost.
  // Every context this library hands a strategy is move-only; a caller's own must be too -- from the
  // mutable lvalue `dispatch` passes as well as from a `const` one, since a copy constructor may take either.
  static_assert(
    !std::is_copy_constructible_v<Ctx> && !std::is_constructible_v<Ctx, Ctx&>,
    "a strategy context must not be copyable, so that a handler taking it by value does not compile "
    "(what it submitted would go to the copy and be lost); delete the context's copy constructor"
  );
  static_assert(
    strategy_detail::declares_any_handler<S>,
    "This type declares no strategy handler. Expected at least one of on_start, on_bar, on_bars, "
    "on_quote, on_fill, on_order_update, on_phase, or on_stop"
  );
  static_assert(
    !(strategy_detail::declares_on_bar<S> && strategy_detail::declares_on_bars<S>),
    "a strategy declares on_bar or on_bars, not both: on_bar receives each bar, on_bars every "
    "instrument's bar of a period at once; keep the one this strategy decides with"
  );

  static constexpr bool value = strategy_detail::compiles_every_handler_call<S, Ctx>();
};

#define ATL_ASSERT_STRATEGY(S, Ctx)                                                      \
  static_assert(                                                                         \
    ::algotradelib::strategy::StrategyConformance<S, Ctx>::value,                         \
    "Strategy does not satisfy the algotradelib strategy surface; see the messages above" \
  )
 
} // namespace strategy
} // namespace algotradelib