data_only_traits.hpp

#pragma once
 
#include "./broker_traits.hpp"
#include "./types.hpp"
 
#include "../network/rate_limit.hpp"
 
#include <boost/asio/associated_executor.hpp>
#include <boost/asio/bind_executor.hpp>
#include <boost/asio/post.hpp>
#include <boost/asio/system_executor.hpp>
 
#include <optional>
#include <type_traits>
#include <utility>
 
namespace algotradelib {
 
namespace net = boost::asio;

namespace data_only {

struct NoAccount {};
struct NoAck {};
struct NoAmendment {};
struct NoHistoryQuery {};
struct NoWorkingOrders {};

inline BrokerError refusal() {
  BrokerError error;
  error.category_ = ErrorCategory::INVALID_ARGUMENT;
  error.reached_broker_ = false;
  error.broker_code_ = "data_only";
  error.message_ = "a market-data source holds no account and takes no order";
  return error;
}

namespace detail {

template <typename Executor, typename = void>
struct postable : std::false_type {};
 
template <typename Executor>
struct postable<
  Executor, std::void_t<decltype(net::post(std::declval<const Executor&>(), std::declval<void (*)()>()))>
> : std::true_type {};
 
} // namespace detail

template <typename Out, typename Handler>
void post_refusal(Handler&& handler) {
  auto executor = net::get_associated_executor(handler, net::system_executor());
  auto complete = [handler = std::forward<Handler>(handler)]() mutable {
    std::move(handler)(Result<Out>(refusal()));
  };
  if constexpr (detail::postable<decltype(executor)>::value) {
    net::post(executor, std::move(complete));
  } else {
    net::post(net::system_executor(), net::bind_executor(executor, std::move(complete)));
  }
}
 
} // namespace data_only

template <typename Tag>
struct DataOnlyTraits {
  using BrokerTag = Tag;
  using Account = data_only::NoAccount;
  using PlaceAck = data_only::NoAck;
  using Amendment = data_only::NoAmendment;
  using HistoryQuery = data_only::NoHistoryQuery;
  using WorkingOrdersResult = data_only::NoWorkingOrders;

  static constexpr bool data_only = true;

  // Every capability is false until the vendor's own specialization says otherwise.
  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 has_working_orders = 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_buying_power = false;
  static constexpr bool has_buying_power_quantity = false;
  static constexpr SellableSource sellable_source = SellableSource::NONE;
  static constexpr bool has_commission_schedule = 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;

  template <typename Client>
  static const network::RateLimitStats* rate_limit_stats(const Client&) {
    return nullptr;
  }

  static std::optional<BrokerError> validate_place(const OrderRequest&) { return data_only::refusal(); }

  static Result<PlacedOrder<Tag>> normalize_place(Result<PlaceAck> raw) {
    return Result<PlacedOrder<Tag>>(raw ? data_only::refusal() : std::move(raw.error()));
  }

  static Result<Amendment> to_replacement(const OrderRef<Tag>&, const AmendInstruction&) {
    return Result<Amendment>(data_only::refusal());
  }

  static Result<Amendment> to_cancellation(const OrderRef<Tag>&, const AmendInstruction&) {
    return Result<Amendment>(data_only::refusal());
  }

  static Result<HistoryQuery> to_history_query(const Account&, const OrderHistoryQuery&) {
    return Result<HistoryQuery>(data_only::refusal());
  }

  template <typename Client>
  static Result<HoldingsSnapshot> holdings(Client&, Account&) {
    return Result<HoldingsSnapshot>(data_only::refusal());
  }

  template <typename Client, typename Handler>
  static void holdings(Client&, Account&, Handler&& handler) {
    data_only::post_refusal<HoldingsSnapshot>(std::forward<Handler>(handler));
  }

  template <typename Client>
  static Result<PlaceAck> place_order(Client&, Account&, OrderRequest) {
    return Result<PlaceAck>(data_only::refusal());
  }

  template <typename Client, typename Handler>
  static void place_order(Client&, Account&, OrderRequest, Handler&& handler) {
    data_only::post_refusal<PlaceAck>(std::forward<Handler>(handler));
  }

  template <typename Client>
  static Result<PlaceAck> replace_order(Client&, Account&, Amendment) {
    return Result<PlaceAck>(data_only::refusal());
  }

  template <typename Client, typename Handler>
  static void replace_order(Client&, Account&, Amendment, Handler&& handler) {
    data_only::post_refusal<PlaceAck>(std::forward<Handler>(handler));
  }

  template <typename Client>
  static Result<PlaceAck> cancel_order(Client&, Account&, Amendment) {
    return Result<PlaceAck>(data_only::refusal());
  }

  template <typename Client, typename Handler>
  static void cancel_order(Client&, Account&, Amendment, Handler&& handler) {
    data_only::post_refusal<PlaceAck>(std::forward<Handler>(handler));
  }

  template <typename Client>
  static Result<OrderPage> order_history(Client&, Account&, HistoryQuery) {
    return Result<OrderPage>(data_only::refusal());
  }

  template <typename Client, typename Handler>
  static void order_history(Client&, Account&, HistoryQuery, Handler&& handler) {
    data_only::post_refusal<OrderPage>(std::forward<Handler>(handler));
  }
};
 
} // namespace algotradelib