bind.hpp

Go to the documentation of this file.

#pragma once
 
#include "./session_executor.hpp"
 
#include "../runner/journal.hpp"
#include "../runner/runner.hpp"
 
#include <cstddef>
#include <utility>
 
namespace algotradelib {
namespace live {


inline constexpr std::size_t default_series_capacity = 512;

template <typename Strategy, typename Session>
using BoundRunner = runner::Runner<
  Strategy,
  typename Session::Caps,
  typename Session::BrokerTag,
  SessionExecutor<Session>
>;

template <typename Strategy, typename Session>
using ObservingRunner = runner::Runner<
  Strategy,
  typename Session::Caps,
  typename Session::BrokerTag,
  runner::RecordingExecutor<typename Session::BrokerTag>
>;

template <typename Strategy, typename Session>
BoundRunner<Strategy, Session> bind(
  Session& session,
  Strategy strategy,
  strategy::RiskLimits limits = {},
  std::size_t series_capacity = default_series_capacity,
  Venue default_route = Venue::UNSPECIFIED
) {
  BoundRunner<Strategy, Session> bound(
    std::move(strategy),
    std::move(limits),
    series_capacity,
    SessionExecutor<Session>(session, default_route)
  );
  // **A runner that can reach a broker requires an account it has actually read** -- and that is not
  // arranged here. It comes from `SessionExecutor::reaches_a_broker`, so a runner assembled by hand
  // carries it too: `doxygen/vignettes/binding-a-broker.md` shows exactly that, and a rule this
  // factory installed would hold for its own callers and for nobody else. A run that genuinely reads
  // no holdings says `allow_absent_portfolio()` on the runner.
  return bound;
}

template <typename Strategy, typename Session, typename Journal, typename Clock = runner::SteadyClock>
using JournaledRunner = runner::Runner<
  Strategy,
  typename Session::Caps,
  typename Session::BrokerTag,
  runner::JournalingExecutor<SessionExecutor<Session>, Journal, Clock>
>;

template <typename Strategy, typename Session, typename Journal, typename Clock = runner::SteadyClock>
JournaledRunner<Strategy, Session, Journal, Clock> bind_journaled(
  Session& session,
  Journal& journal,
  Strategy strategy,
  strategy::RiskLimits limits = {},
  std::size_t series_capacity = default_series_capacity,
  Venue default_route = Venue::UNSPECIFIED,
  Clock clock = {}
) {
  JournaledRunner<Strategy, Session, Journal, Clock> bound(
    std::move(strategy),
    std::move(limits),
    series_capacity,
    runner::JournalingExecutor<SessionExecutor<Session>, Journal, Clock>(
      SessionExecutor<Session>(session, default_route), journal, std::move(clock)
    )
  );
  // As in `bind`: the requirement travels with the executor, not with this factory.
  return bound;
}

template <typename Strategy, typename Session>
ObservingRunner<Strategy, Session> bind_observer(
  Session& session,
  Strategy strategy,
  strategy::RiskLimits limits = {},
  std::size_t series_capacity = default_series_capacity
) {
  (void)session;
  return ObservingRunner<Strategy, Session>(
    std::move(strategy), std::move(limits), series_capacity, {}
  );
}
 
} // namespace live
} // namespace algotradelib