session_executor.hpp

#pragma once
 
#include "../runner/execution.hpp"
#include "../strategy/reconcile.hpp"
 
#include <algotradelib/broker>
 
#include <optional>
#include <string>
#include <utility>
 
namespace algotradelib {
namespace live {

template <typename Session>
class SessionExecutor {
public:

  static constexpr bool reaches_a_broker = true;
  using Caps = typename Session::Caps;
  using BrokerTag = typename Session::BrokerTag;
 
  static_assert(
    !Caps::data_only,
    "SessionExecutor sends orders, and this session's client is a market-data source (DataOnlyTraits) "
    "that takes none: bind a broker's session here, and give the data source to SessionSource as its "
    "market-data session"
  );

  explicit SessionExecutor(Session& session, Venue default_route = Venue::UNSPECIFIED)
  : session_(&session), default_route_(default_route) {}

  Venue default_route() const noexcept { return default_route_; }

  Venue requested_route(Venue asked) const noexcept {
    return asked == Venue::UNSPECIFIED ? default_route_ : asked;
  }

  Venue effective_route(Venue asked) const noexcept {
    return traits_route<Session>(requested_route(asked), 0);
  }

  runner::SendOutcome place(const strategy::PlannedOrder& order) {
    if (order.client_order_id_) {
      if constexpr (!Caps::has_client_order_id) {
        last_error_ = BrokerError{};
        last_error_->category_ = ErrorCategory::INVALID_ARGUMENT;
        last_error_->reached_broker_ = false;
        last_error_->message_ =
          "this broker accepts no idempotency key; the intent asked for one";
        // Refused here, not by the broker: nothing was sent, so nothing may be counted against the
        // rate limit. Reporting this as a broker rejection spent budget for a request nobody made.
        return runner::SendOutcome::REFUSED_LOCALLY;
      }
    }
 
    OrderRequest request;
    request.instrument_ = order.instrument_;
    request.side_ = order.side_;
    request.type_ = order.type_;
    request.time_in_force_ = order.time_in_force_;
    // All three, every time. A fact not copied here never reaches the wire, so
    // the order placed is not the order the caller planned -- and it fails
    // silently, because a default is a valid value rather than an empty one.
    request.session_ = order.session_;
    // The runner has already written the route in; applied again for an executor driven by hand.
    request.venue_ = requested_route(order.venue_);
    request.quantity_ = order.quantity_;
    request.price_ = order.price_;
    // A broker whose `has_trigger_price` is false is refused it by the session before its adapter runs,
    // which `outcome_of` reports as a local refusal: nothing was sent.
    request.trigger_price_ = order.trigger_price_;
    if constexpr (Caps::has_client_order_id) {
      request.client_order_id_ = order.client_order_id_;
    }
 
    auto result = session_->place(std::move(request));
    if (result) {
      last_ref_ = result.value().ref_;
      last_error_.reset();
      return runner::SendOutcome::ACCEPTED;
    }
    last_error_ = result.error();
    return runner::outcome_of(*last_error_);
  }

  runner::SendOutcome cancel(const WorkingOrder<BrokerTag>& working) {
    if (working.ref_.primary_.empty()) {
      // **A reference naming nothing addresses nothing at a broker.** A row can reach here with an
      // empty one: a runner reserves an order it has just sent so that later limits count it, and
      // an executor that could not report what the broker issued leaves the reference blank.
      // Sending that is a request which can only fail while looking like an attempt, and a
      // cancellation failure is the one this library must not manufacture noise around. Refused as
      // an answer rather than as an outage, because nothing is in doubt: the order was never
      // addressed, so there is nothing to reconcile.
      //
      // The check is here and not in the runner because a reference is only meaningful to a
      // broker. A replay's engine matches a cancellation on instrument and side, and refusing one
      // there would leave a queued order to fill that the caller asked to withdraw.
      last_error_ = BrokerError{};
      last_error_->category_ = ErrorCategory::INVALID_ARGUMENT;
      last_error_->reached_broker_ = false;
      last_error_->message_ =
        "no broker reference for this order; it cannot be withdrawn until a listing supplies one";
      return runner::SendOutcome::REFUSED_LOCALLY;
    }
    auto result = session_->cancel(working.ref_, cancel_all(working));
    if (result) {
      last_error_.reset();
      return runner::SendOutcome::ACCEPTED;
    }
    last_error_ = result.error();
    return runner::outcome_of(*last_error_);
  }

  std::optional<Decimal64> sellable_quantity(const InstrumentId& instrument) {
    if constexpr (Caps::sellable_source == SellableSource::INQUIRY) {
      auto result = session_->sellable_quantity(instrument);
      if (!result) {
        last_error_ = result.error();
        return std::nullopt;
      }
      last_error_.reset();
      return result.value();
    } else {
      static_cast<void>(instrument);
      return std::nullopt;
    }
  }

  static constexpr bool inquires_sellable = Caps::sellable_source == SellableSource::INQUIRY;

  static constexpr SellableBasis sellable_inquiry_basis() {
    // Read through the same gate as `BrokerCaps`, because `Caps` is a caller's type parameter and need
    // not be `BrokerCaps`: a hand-written capability set that makes the inquiry states its basis.
    return caps_detail::inquiry_basis<Caps>();
  }

  const std::optional<OrderRef<BrokerTag>>& last_ref() const noexcept { return last_ref_; }

  const std::optional<BrokerError>& last_error() const noexcept { return last_error_; }
 
private:
  // Asks the session's traits where `requested` goes, where they say.
  template <typename S>
  static constexpr auto traits_route(Venue requested, int) noexcept
    -> decltype(S::Traits::effective_route(requested)) {
    return S::Traits::effective_route(requested);
  }
 
  // The fallback, for traits that do not say: the requested route is the most that is known.
  template <typename S>
  static constexpr Venue traits_route(Venue requested, long) noexcept { return requested; }
 
  Session* session_;
  Venue default_route_;
  std::optional<OrderRef<BrokerTag>> last_ref_;
  std::optional<BrokerError> last_error_;
};
 
} // namespace live
} // namespace algotradelib