intent.hpp

Go to the documentation of this file.

#pragma once
 
#include <algotradelib/core>
 
#include <optional>
#include <stdexcept>
#include <string>
#include <utility>
 
namespace algotradelib {
namespace strategy {


class Price {
public:
  static std::optional<Price> checked(Decimal64 value, const PriceRule& rule) {
    const auto aligned = rule.on_tick(value);
    if (!aligned || !*aligned) {
      return std::nullopt;
    }
    return Price(std::move(value));
  }

  static std::optional<Price> rounded(
    const Decimal64& value,
    const PriceRule& rule,
    OrderSide side
  ) {
    auto moved = rule.round_to_tick(value, side);
    if (!moved) {
      return std::nullopt;
    }
    return Price(std::move(*moved));
  }

  const Decimal64& value() const noexcept { return value_; }

  std::string str() const { return value_.str(); }

  friend bool operator==(const Price& lhs, const Price& rhs) {
    return lhs.value_ == rhs.value_;
  }

  friend bool operator!=(const Price& lhs, const Price& rhs) { return !(lhs == rhs); }
 
private:
  explicit Price(Decimal64 value) : value_(std::move(value)) {}
 
  Decimal64 value_;
};

enum class SizeKind {
  QUANTITY,
  NOTIONAL,
  TARGET_WEIGHT,
};

inline constexpr bool size_kind_is_target(SizeKind kind) noexcept {
  switch (kind) {
    case SizeKind::TARGET_WEIGHT:
      return true;
    case SizeKind::QUANTITY:
    case SizeKind::NOTIONAL:
      return false;
  }
  return false;
}

class SizeSpec {
public:
  SizeSpec() = default;

  static SizeSpec quantity(Decimal64 amount) {
    SizeSpec size;
    size.kind_ = SizeKind::QUANTITY;
    size.quantity_ = std::move(amount);
    return size;
  }

  static SizeSpec notional(Money amount) {
    SizeSpec size;
    size.kind_ = SizeKind::NOTIONAL;
    size.notional_ = std::move(amount);
    return size;
  }

  static SizeSpec target_weight(Decimal64 fraction) {
    SizeSpec size;
    size.kind_ = SizeKind::TARGET_WEIGHT;
    size.weight_ = std::move(fraction);
    return size;
  }

  SizeKind kind() const noexcept { return kind_; }

  const Decimal64& as_quantity() const {
    require(SizeKind::QUANTITY, "quantity");
    return quantity_;
  }

  const Money& as_notional() const {
    require(SizeKind::NOTIONAL, "notional");
    return notional_;
  }

  const Decimal64& as_target_weight() const {
    require(SizeKind::TARGET_WEIGHT, "target weight");
    return weight_;
  }
 
private:
  void require(SizeKind wanted, const char* name) const {
    if (kind_ != wanted) {
      throw std::logic_error(std::string("order size is not a ") + name);
    }
  }
 
  SizeKind kind_{SizeKind::QUANTITY};
  Decimal64 quantity_;
  Money notional_;
  Decimal64 weight_;
};

class OrderIntent {
public:
  static OrderIntent limit(
    InstrumentId instrument,
    OrderSide side,
    SizeSpec size,
    Price limit,
    TimeInForce time_in_force = TimeInForce::DAY
  ) {
    OrderIntent intent;
    intent.instrument_ = std::move(instrument);
    intent.side_ = side;
    intent.type_ = OrderType::LIMIT;
    intent.time_in_force_ = time_in_force;
    intent.size_ = std::move(size);
    intent.limit_ = std::move(limit);
    return intent;
  }

  static OrderIntent stop_limit(
    InstrumentId instrument,
    OrderSide side,
    SizeSpec size,
    Price trigger,
    Price limit,
    TimeInForce time_in_force = TimeInForce::DAY
  ) {
    OrderIntent intent;
    intent.instrument_ = std::move(instrument);
    intent.side_ = side;
    intent.type_ = OrderType::STOP_LIMIT;
    intent.time_in_force_ = time_in_force;
    intent.size_ = std::move(size);
    intent.limit_ = std::move(limit);
    intent.trigger_ = std::move(trigger);
    return intent;
  }

  static OrderIntent market(
    InstrumentId instrument,
    OrderSide side,
    SizeSpec size,
    TimeInForce time_in_force = TimeInForce::DAY
  ) {
    OrderIntent intent;
    intent.instrument_ = std::move(instrument);
    intent.side_ = side;
    intent.type_ = OrderType::MARKET;
    intent.time_in_force_ = time_in_force;
    intent.size_ = std::move(size);
    return intent;
  }

  OrderIntent with_tag(std::string tag) const {
    OrderIntent copy = *this;
    copy.tag_ = std::move(tag);
    return copy;
  }

  OrderIntent with_client_order_id(std::string key) const {
    OrderIntent copy = *this;
    copy.client_order_id_ = std::move(key);
    return copy;
  }

  const InstrumentId& instrument() const noexcept { return instrument_; }

  OrderSide side() const noexcept { return side_; }

  OrderType type() const noexcept { return type_; }

  TimeInForce time_in_force() const noexcept { return time_in_force_; }

  const SizeSpec& size() const noexcept { return size_; }

  const std::optional<Price>& limit() const noexcept { return limit_; }

  const std::optional<Price>& trigger() const noexcept { return trigger_; }

  const std::string& tag() const noexcept { return tag_; }

  const std::optional<std::string>& client_order_id() const noexcept {
    return client_order_id_;
  }
 
private:
  OrderIntent() = default;
 
  InstrumentId instrument_;
  OrderSide side_{OrderSide::BUY};
  OrderType type_{OrderType::LIMIT};
  TimeInForce time_in_force_{TimeInForce::DAY};
  SizeSpec size_;
  std::optional<Price> limit_;
  std::optional<Price> trigger_;
  std::string tag_;
  std::optional<std::string> client_order_id_;
};

struct TargetPosition {
  InstrumentId instrument_;
  Decimal64 target_quantity_;
  std::optional<Price> limit_;
  std::string tag_;
};

template <typename Broker>
struct CancelIntent {
  OrderRef<Broker> ref_;
  std::string tag_;
};
 
} // namespace strategy
} // namespace algotradelib