timed_liquidation.hpp

#pragma once
 
#include "../event.hpp"
#include "../intent.hpp"
 
#include <algotradelib/core>
 
#include <cstddef>
#include <string>
#include <vector>
 
namespace algotradelib {
namespace strategy {
namespace vanilla {

struct TimedLiquidation {
  struct Params {
    std::vector<MarketPhase> hold_through_{MarketPhase::OPEN, MarketPhase::PRE_OPEN};
    std::string tag_{"timed-liquidation"};
  };

  Params params_;

  static constexpr std::size_t warmup_bars = 0;

  template <class Ctx>
  void on_phase(Ctx& ctx, MarketPhase phase) {
    if (!holds_through(phase)) {
      flatten(ctx);
    }
  }
 
private:
  // Whether `phase` is one this strategy may hold through.
  bool holds_through(MarketPhase phase) const {
    for (const auto allowed : params_.hold_through_) {
      if (allowed == phase) {
        return true;
      }
    }
    return false;
  }
 
  // Targets zero in every instrument held, once per instrument (a holding may span several rows,
  // and duplicate targets would each plan a sell). Working orders are left to reconciliation.
  template <class Ctx>
  void flatten(Ctx& ctx) {
    std::vector<InstrumentId> targeted;
    for (const auto& position : ctx.portfolio().positions_) {
      if (position.quantity_.coefficient() == 0) {
        continue;
      }
      bool seen = false;
      for (const auto& already : targeted) {
        if (already == position.instrument_) {
          seen = true;
          break;
        }
      }
      if (seen) {
        continue;
      }
      targeted.push_back(position.instrument_);
 
      TargetPosition target;
      target.instrument_ = position.instrument_;
      target.target_quantity_ = Decimal64::parse("0");
      target.tag_ = params_.tag_;
      ctx.submit(target);
    }
  }
};
 
} // namespace vanilla
} // namespace strategy
} // namespace algotradelib