broker_caps.hpp

#pragma once
 
#include "./broker_traits.hpp"
#include "./market_data.hpp"
#include "./types.hpp"
 
namespace algotradelib {
 
namespace caps_detail {

template <typename T>
constexpr bool terminal_working_state() {
  if constexpr (T::has_working_orders) {
    return T::working_orders_state_terminal;
  } else {
    return false;
  }
}

template <typename T>
constexpr SellableBasis inquiry_basis() {
  if constexpr (T::sellable_source == SellableSource::INQUIRY) {
    return T::sellable_inquiry_basis;
  } else {
    return SellableBasis{};
  }
}
 
}  // namespace caps_detail

template <typename Client>
struct BrokerCaps {
  using Traits = BrokerTraits<Client>;

  static constexpr bool has_account_discovery = Traits::has_account_discovery;

  static constexpr bool has_client_order_id = Traits::has_client_order_id;

  static constexpr bool has_working_orders = Traits::has_working_orders;

  static constexpr bool has_amendable_quantity = Traits::has_amendable_quantity;

  static constexpr bool working_orders_state_terminal = caps_detail::terminal_working_state<Traits>();

  static constexpr bool has_trigger_price = Traits::has_trigger_price;

  static constexpr bool data_only = Traits::data_only;

  static constexpr bool has_order_by_id = Traits::has_order_by_id;

  static constexpr bool has_partial_cancel = Traits::has_partial_cancel;

  static constexpr bool history_requires_range = Traits::history_requires_range;

  static constexpr bool has_history_cursor = Traits::has_history_cursor;

  static constexpr bool has_history_limit = Traits::has_history_limit;

  static constexpr bool has_history_symbol_filter = Traits::has_history_symbol_filter;

  static constexpr bool has_depth = Traits::has_depth;

  static constexpr bool has_price_limits = Traits::has_price_limits;

  static constexpr bool has_trade_prints = Traits::has_trade_prints;

  static constexpr bool has_batch_prices = Traits::has_batch_prices;

  static constexpr bool has_buying_power = Traits::has_buying_power;

  static constexpr bool has_buying_power_quantity = Traits::has_buying_power_quantity;

  static constexpr SellableSource sellable_source = Traits::sellable_source;

  static constexpr SellableBasis sellable_inquiry_basis = caps_detail::inquiry_basis<Traits>();

  static constexpr bool has_commission_schedule = Traits::has_commission_schedule;

  static constexpr bool has_reference_data = Traits::has_reference_data;

  static constexpr bool has_batch_reference_data = Traits::has_batch_reference_data;

  static constexpr bool has_calendar = Traits::has_calendar;

  static constexpr bool has_calendar_range = Traits::has_calendar_range;

  static constexpr bool has_calendar_sessions = Traits::has_calendar_sessions;

  static constexpr bool supports_interval(BarInterval interval) {
    return Traits::supports_interval(interval);
  }
};

// A constant added to `BrokerCaps` must be added here.
template <typename Caps>
constexpr bool reads_every_capability() {
  constexpr bool read[] = {
    Caps::has_account_discovery,
    Caps::has_client_order_id,
    Caps::has_working_orders,
    Caps::has_amendable_quantity,
    Caps::working_orders_state_terminal,
    Caps::has_trigger_price,
    Caps::data_only,
    Caps::has_order_by_id,
    Caps::has_partial_cancel,
    Caps::history_requires_range,
    Caps::has_history_cursor,
    Caps::has_history_limit,
    Caps::has_history_symbol_filter,
    Caps::has_depth,
    Caps::has_price_limits,
    Caps::has_trade_prints,
    Caps::has_batch_prices,
    Caps::has_buying_power,
    Caps::has_buying_power_quantity,
    Caps::sellable_source == SellableSource::INQUIRY,
    Caps::sellable_inquiry_basis.coverage_ == SellableBasis::Coverage::UNESTABLISHED,
    Caps::has_commission_schedule,
    Caps::has_reference_data,
    Caps::has_batch_reference_data,
    Caps::has_calendar,
    Caps::has_calendar_range,
    Caps::has_calendar_sessions,
  };
  static_cast<void>(read);
  // Named, not called: the predicate need not be usable in a constant expression to be conforming.
  static_cast<void>(&Caps::supports_interval);
  return true;
}

template <typename Client>
constexpr bool answers_every_capability() {
  return reads_every_capability<BrokerCaps<Client>>();
}
 
} // namespace algotradelib