broker_verbs.hpp

#pragma once
 
#include "./broker_caps.hpp"
#include "./broker_session.hpp"
#include "./broker_traits.hpp"
 
#include <boost/asio/use_future.hpp>
 
#include <optional>
#include <vector>
 
namespace algotradelib {

namespace conformance {

struct PlainCallback {
  template <typename T>
  void operator()(T) const {}
};

struct MoveOnlyCallback {
  MoveOnlyCallback() = default;
  MoveOnlyCallback(MoveOnlyCallback&&) = default;
  MoveOnlyCallback& operator=(MoveOnlyCallback&&) = default;
  MoveOnlyCallback(const MoveOnlyCallback&) = delete;
  MoveOnlyCallback& operator=(const MoveOnlyCallback&) = delete;

  template <typename T>
  void operator()(T) {}
};

inline InstrumentId probe_instrument() { return InstrumentId{Country::KR, Venue::COMBINED, "000000"}; }

template <typename Client, typename Token>
void call_claimed_async_verbs(
  BrokerSession<Client>& session, const typename BrokerSession<Client>::Ref& ref
) {
  using Caps = BrokerCaps<Client>;
  session.async_quote(probe_instrument(), Token{});
  session.async_holdings(Token{});
  session.async_bars(BarQuery{}, Token{});
  session.async_place(OrderRequest{}, Token{});
  session.async_replace(ref, AmendInstruction{}, Token{});
  session.async_cancel(ref, AmendInstruction{}, Token{});
  session.async_order_history(OrderHistoryQuery{}, Token{});
  if constexpr (Caps::has_buying_power) {
    session.async_buying_power(Currency{}, Token{});
  }
  if constexpr (Caps::sellable_source == SellableSource::INQUIRY) {
    session.async_sellable_quantity(probe_instrument(), Token{});
  }
  if constexpr (Caps::has_commission_schedule) {
    session.async_commissions(Token{});
  }
  if constexpr (Caps::has_working_orders) {
    session.async_working_orders(Token{});
  }
  if constexpr (Caps::has_reference_data) {
    session.async_instrument(probe_instrument(), Token{});
  }
  if constexpr (Caps::has_calendar) {
    session.async_calendar(Country::KR, std::nullopt, Token{});
  }
  if constexpr (Caps::has_price_limits) {
    session.async_price_limits(probe_instrument(), Token{});
  }
  if constexpr (Caps::has_trade_prints) {
    session.async_trades(probe_instrument(), 1, Token{});
  }
  if constexpr (Caps::has_batch_prices) {
    session.async_prices(std::vector<InstrumentId>{probe_instrument()}, Token{});
  }
  if constexpr (Caps::has_depth) {
    session.async_depth(probe_instrument(), Token{});
  }
  if constexpr (Caps::has_order_by_id) {
    session.async_order(ref, Token{});
  }
  if constexpr (Caps::has_account_discovery) {
    async_accounts(session.client(), Token{});
  }
}

template <typename Client>
void call_claimed_blocking_verbs(
  BlockingSession<Client>& session, const typename BlockingSession<Client>::Ref& ref
) {
  using Caps = BrokerCaps<Client>;
  static_cast<void>(session.quote(probe_instrument()));
  static_cast<void>(session.holdings());
  static_cast<void>(session.bars(BarQuery{}));
  static_cast<void>(session.place(OrderRequest{}));
  static_cast<void>(session.replace(ref, AmendInstruction{}));
  static_cast<void>(session.cancel(ref, AmendInstruction{}));
  static_cast<void>(session.order_history(OrderHistoryQuery{}));
  if constexpr (Caps::has_buying_power) {
    static_cast<void>(session.buying_power(Currency{}));
  }
  if constexpr (Caps::sellable_source == SellableSource::INQUIRY) {
    static_cast<void>(session.sellable_quantity(probe_instrument()));
  }
  if constexpr (Caps::has_commission_schedule) {
    static_cast<void>(session.commissions());
  }
  if constexpr (Caps::has_working_orders) {
    static_cast<void>(session.working_orders());
  }
  if constexpr (Caps::has_reference_data) {
    static_cast<void>(session.instrument(probe_instrument()));
  }
  if constexpr (Caps::has_calendar) {
    static_cast<void>(session.calendar(Country::KR));
  }
  if constexpr (Caps::has_price_limits) {
    static_cast<void>(session.price_limits(probe_instrument()));
  }
  if constexpr (Caps::has_trade_prints) {
    static_cast<void>(session.trades(probe_instrument(), 1));
  }
  if constexpr (Caps::has_batch_prices) {
    static_cast<void>(session.prices(std::vector<InstrumentId>{probe_instrument()}));
  }
  if constexpr (Caps::has_depth) {
    static_cast<void>(session.depth(probe_instrument()));
  }
  if constexpr (Caps::has_order_by_id) {
    static_cast<void>(session.order(ref));
  }
  if constexpr (Caps::has_account_discovery) {
    static_cast<void>(session.accounts());
    static_cast<void>(list_accounts(session.client()));
  }
}

template <typename Client>
constexpr bool claimed_verbs_compile() {
  if constexpr (BrokerTraits<Client>::blocking) {
    static_cast<void>(&call_claimed_blocking_verbs<Client>);
  } else {
    static_cast<void>(&call_claimed_async_verbs<Client, PlainCallback>);
    static_cast<void>(&call_claimed_async_verbs<Client, MoveOnlyCallback>);
    static_cast<void>(&call_claimed_async_verbs<Client, boost::asio::use_future_t<>>);
  }
  return true;
}
 
} // namespace conformance

#define ATL_ASSERT_BROKER(Client)                                                        \
  static_assert(                                                                         \
    ::algotradelib::conformance::claimed_verbs_compile<Client>() &&                      \
      ::algotradelib::answers_every_capability<Client>(),                                \
    "every port verb this client's capabilities claim must compile, and every capability " \
    "must be answered"                                                                   \
  )
 
} // namespace algotradelib