stop.hpp

#pragma once
 
#include "../core/enum_values.hpp"
 
#include <array>
#include <atomic>
#include <cstdio>
#include <optional>
#include <string>
#include <string_view>
 
namespace algotradelib {
namespace runner {

enum class StopIntent {
  QUIESCE,
  WITHDRAW,
  FLATTEN,
};

inline constexpr std::array<StopIntent, 3> all_stop_intents{
  StopIntent::QUIESCE,
  StopIntent::WITHDRAW,
  StopIntent::FLATTEN,
};

inline constexpr std::string_view stop_intent_name(StopIntent intent) noexcept {
  switch (intent) {
    case StopIntent::QUIESCE:
      return "quiesce";
    case StopIntent::WITHDRAW:
      return "withdraw";
    case StopIntent::FLATTEN:
      return "flatten";
  }
  return "";
}
 
static_assert(
  lists_every_value(all_stop_intents, [](StopIntent intent) { return !stop_intent_name(intent).empty(); }),
  "all_stop_intents must list every StopIntent"
);

inline std::optional<StopIntent> stop_intent_from(std::string_view text) noexcept {
  return value_named(all_stop_intents, stop_intent_name, text);
}

inline constexpr int stop_intent_strength(StopIntent intent) noexcept {
  switch (intent) {
    case StopIntent::QUIESCE:
      return 0;
    case StopIntent::WITHDRAW:
      return 1;
    case StopIntent::FLATTEN:
      return 2;
  }
  return 0;
}

inline constexpr bool stop_intent_closes(StopIntent intent) noexcept {
  switch (intent) {
    case StopIntent::QUIESCE:
      return false;
    case StopIntent::WITHDRAW:
    case StopIntent::FLATTEN:
      return true;
  }
  return true;
}

inline constexpr bool stop_intent_closes_positions(StopIntent intent) noexcept {
  switch (intent) {
    case StopIntent::FLATTEN:
      return true;
    case StopIntent::QUIESCE:
    case StopIntent::WITHDRAW:
      return false;
  }
  return false;
}

inline constexpr bool stop_intent_covers(StopIntent held, StopIntent candidate) noexcept {
  return stop_intent_strength(held) >= stop_intent_strength(candidate);
}

class StopSource {
public:
  void request(StopIntent intent) noexcept {
    const int desired = static_cast<int>(intent);
    int current = requested_.load(std::memory_order_relaxed);
    // A failed exchange reloads `current`, so the held intent's strength is read again each time.
    while (current < 0 || stop_intent_strength(static_cast<StopIntent>(current)) < stop_intent_strength(intent)) {
      if (requested_.compare_exchange_weak(
            current, desired, std::memory_order_release, std::memory_order_relaxed)) {
        return;
      }
    }
  }

  bool requested() const noexcept {
    return requested_.load(std::memory_order_acquire) >= 0;
  }

  std::optional<StopIntent> intent() const noexcept {
    const int held = requested_.load(std::memory_order_acquire);
    if (held < 0) {
      return std::nullopt;
    }
    return static_cast<StopIntent>(held);
  }

  void clear() noexcept { requested_.store(-1, std::memory_order_release); }
 
private:
  // Negative means no request; otherwise a `StopIntent`.
  std::atomic<int> requested_{-1};
 
  // Asserted rather than assumed, because the signal-safety argument above rests entirely on it. If
  // this ever fails on some platform, `request()` is no longer callable from a handler and the
  // signal installer is unsound -- which is worth a compile error rather than a subtle deadlock in a
  // handler that fires once a month.
  static_assert(
    std::atomic<int>::is_always_lock_free,
    "StopSource requires a lock-free atomic<int> to stay signal-safe");
};

class FileStopChannel {
public:
  explicit FileStopChannel(std::string path = {}) : path_(std::move(path)) {}

  bool enabled() const noexcept { return !path_.empty(); }

  const std::string& path() const noexcept { return path_; }

  std::optional<StopIntent> poll() {
    unrecognized_.clear();
    if (path_.empty()) {
      return std::nullopt;
    }
    std::FILE* handle = std::fopen(path_.c_str(), "rb");
    if (handle == nullptr) {
      return std::nullopt;
    }
    char buffer[64] = {};
    const std::size_t read = std::fread(buffer, 1, sizeof(buffer) - 1, handle);
    std::fclose(handle);
 
    std::string_view text(buffer, read);
    const auto begin = text.find_first_not_of(" \t\r\n");
    if (begin == std::string_view::npos) {
      return std::nullopt;
    }
    text.remove_prefix(begin);
    const auto end = text.find_first_of(" \t\r\n");
    if (end != std::string_view::npos) {
      text = text.substr(0, end);
    }
 
    if (auto intent = stop_intent_from(text)) {
      return intent;
    }
    unrecognized_.assign(text);
    return std::nullopt;
  }

  const std::string& unrecognized() const noexcept { return unrecognized_; }
 
private:
  std::string path_;
  std::string unrecognized_;
};
 
} // namespace runner
} // namespace algotradelib