instance.hpp

Go to the documentation of this file.

#pragma once

 
#if (defined(_MSVC_LANG) ? _MSVC_LANG : __cplusplus) < 201703L
#error \
    "OpenPine C++ wrapper headers require C++17 (std::optional, std::string_view)."
#endif
 
#include <cstdint>
#include <functional>
#include <memory>
#include <optional>
#include <string>
 
#include "chart.hpp"
#include "error.hpp"
#include "ffi.hpp"
#include "script_info.hpp"
#include "types.hpp"
 
namespace openpine {
 
// ---------------------------------------------------------------------------
// CandlestickStream
// ---------------------------------------------------------------------------

class CandlestickStream {
 public:
  CandlestickStream(std::string_view symbol, std::string_view timeframe,
                    int64_t from_time)
      : ptr_(ffi::candlestickStreamCreate(
            reinterpret_cast<const uint8_t*>(symbol.data()), symbol.size(),
            reinterpret_cast<const uint8_t*>(timeframe.data()),
            timeframe.size(), from_time)) {}
 
  ~CandlestickStream() {
    if (ptr_) finish();
  }
 
  CandlestickStream(const CandlestickStream&) = delete;
  CandlestickStream& operator=(const CandlestickStream&) = delete;

  void push(const CandlestickItem& item) {
    std::unique_ptr<ffi::Result, decltype(&ffi::resultDelete)> result{
        ffi::candlestickStreamPush(ptr_, &item), ffi::resultDelete};
    if (!ffi::resultIsSuccess(&*result))
      throw Error{ffi::resultErrorMessage(&*result),
                  ffi::resultErrorSpan(&*result)};
  }

  void finish() {
    if (!ptr_) return;
    std::unique_ptr<ffi::Result, decltype(&ffi::resultDelete)> result{
        ffi::candlestickStreamFinish(ptr_), ffi::resultDelete};
    // Ignore errors from finish — the stream pointer is no longer usable.
    (void)result;
    ptr_ = nullptr;
  }

  ffi::CandlestickStream* release() {
    auto* p = ptr_;
    ptr_ = nullptr;
    return p;
  }

  ffi::CandlestickStream* handle() const { return ptr_; }
 
 private:
  ffi::CandlestickStream* ptr_;
};
 
// ---------------------------------------------------------------------------
// DataProvider
// ---------------------------------------------------------------------------

class DataProvider {
 public:
  virtual ~DataProvider() = default;

  virtual PartialSymbolInfo symbolInfo(std::string_view symbol) = 0;

  virtual ffi::CandlestickStream* candlesticksOpen(std::string_view symbol,
                                                    std::string_view timeframe,
                                                    int64_t from_time) = 0;
};
 
// ---------------------------------------------------------------------------
// CreateInstanceOptions
// ---------------------------------------------------------------------------

class CreateInstanceOptions {
 public:
  CreateInstanceOptions(const std::string& source, const std::string& timeframe,
                        const std::string& symbol,
                        const std::optional<std::string>& path = std::nullopt)
      : source_(source),
        timeframe_(timeframe),
        path_(path),
        symbol_(symbol),
        background_color_(0xff),
        last_info_(std::nullopt) {}

  void setBackgroundColor(uint32_t color) { background_color_ = color; }

  void setLastInfo(const LastInfo& last_info) { last_info_ = last_info; }

  void setDataProvider(DataProvider* provider) { data_provider_ = provider; }

  void setOutputMode(ffi::COutputMode mode) { output_mode_ = mode; }
 
  friend class Instance;
 
 private:
  std::string source_;
  std::optional<std::string> path_;
  std::string timeframe_;
  std::string symbol_;
  uint32_t background_color_;
  std::optional<LastInfo> last_info_;
  DataProvider* data_provider_ = nullptr;
  ffi::COutputMode output_mode_ = ffi::COutputMode::Chart;
};
 
// ---------------------------------------------------------------------------
// Instance
// ---------------------------------------------------------------------------

class Instance {
 public:
  using RunCallback = std::function<void(const Result&)>;

  using EventCallback = std::function<void(const ffi::CEvent&)>;

  static Instance create(const CreateInstanceOptions& options);

  Chart chart() const { return Chart{ffi::instanceChart(&*p_)}; }

  ScriptInfo scriptInfo() const {
    return ScriptInfo{ffi::instanceScriptInfo(&*p_)};
  }

  void run(std::string_view symbol, std::string_view timeframe,
           int64_t from_time, RunCallback callback,
           EventCallback event_callback = nullptr);
 
  Instance(Instance&&) = default;
  Instance& operator=(Instance&&) = default;
 
 private:
  explicit Instance(ffi::Instance* p) : p_(p, ffi::instanceDelete) {}
 
  std::unique_ptr<ffi::Instance, decltype(&ffi::instanceDelete)> p_{
      nullptr, ffi::instanceDelete};
 
  // Heap-allocated trampoline that bridges C++ DataProvider virtuals to the
  // ffi::DataProvider function-pointer table.
  struct ProviderTrampoline {
    DataProvider* provider;
 
    static const char* symbol_info_fn(void* ctx, const uint8_t* sym,
                                       size_t sym_len,
                                       ffi::PartialSymbolInfo* out) {
      auto* t = static_cast<ProviderTrampoline*>(ctx);
      std::string_view sv(reinterpret_cast<const char*>(sym), sym_len);
      try {
        *out = t->provider->symbolInfo(sv);
        return nullptr;
      } catch (const std::exception& e) {
        static thread_local std::string buf;
        buf = e.what();
        return buf.c_str();
      }
    }
 
    static ffi::CandlestickStream* candlesticks_open_fn(
        void* ctx, const uint8_t* sym, size_t sym_len, const uint8_t* tf,
        size_t tf_len, int64_t from_time) {
      auto* t = static_cast<ProviderTrampoline*>(ctx);
      std::string_view sv(reinterpret_cast<const char*>(sym), sym_len);
      std::string_view tfv(reinterpret_cast<const char*>(tf), tf_len);
      try {
        return t->provider->candlesticksOpen(sv, tfv, from_time);
      } catch (...) {
        return nullptr;
      }
    }
  };
 
  std::unique_ptr<ProviderTrampoline> trampoline_;
  std::optional<ffi::DataProvider> ffi_provider_;
};
 
// ---------------------------------------------------------------------------
// Instance::create  (inline definition)
// ---------------------------------------------------------------------------
 
inline Instance Instance::create(const CreateInstanceOptions& options) {
  const ffi::PineStringRef* path_ptr = nullptr;
  ffi::PineStringRef ffi_path;
  if (options.path_) {
    ffi_path = {reinterpret_cast<const uint8_t*>(options.path_->data()),
                options.path_->size()};
    path_ptr = &ffi_path;
  }
  ffi::PineStringRef source{
      reinterpret_cast<const uint8_t*>(options.source_.data()),
      options.source_.size()};
  ffi::PineStringRef timeframe{
      reinterpret_cast<const uint8_t*>(options.timeframe_.data()),
      options.timeframe_.size()};
  ffi::PineStringRef symbol{
      reinterpret_cast<const uint8_t*>(options.symbol_.data()),
      options.symbol_.size()};
 
  Instance inst(nullptr);
 
  const ffi::DataProvider* provider_ptr = nullptr;
  if (options.data_provider_) {
    inst.trampoline_ = std::make_unique<ProviderTrampoline>();
    inst.trampoline_->provider = options.data_provider_;
    inst.ffi_provider_ = ffi::DataProvider{
        static_cast<void*>(inst.trampoline_.get()),
        ProviderTrampoline::symbol_info_fn,
        ProviderTrampoline::candlesticks_open_fn,
    };
    provider_ptr = &*inst.ffi_provider_;
  }
 
  ffi::CreateInstanceOptions ffi_opts{source,
                                       path_ptr,
                                       timeframe,
                                       symbol,
                                       &options.background_color_,
                                       options.last_info_
                                           ? &*options.last_info_
                                           : nullptr,
                                       provider_ptr,
                                       options.output_mode_};
 
  ffi::Instance* raw = nullptr;
  std::unique_ptr<ffi::Result, decltype(&ffi::resultDelete)> result{
      ffi::instanceCreate(&ffi_opts, &raw), ffi::resultDelete};
  if (!ffi::resultIsSuccess(&*result))
    throw Error{ffi::resultErrorMessage(&*result),
                ffi::resultErrorSpan(&*result)};
 
  inst.p_.reset(raw);
  return inst;
}
 
// ---------------------------------------------------------------------------
// Instance::run  (inline definition)
// ---------------------------------------------------------------------------
 
inline void Instance::run(std::string_view symbol, std::string_view timeframe,
                           int64_t from_time, RunCallback callback,
                           EventCallback event_callback) {
  // Pack both callbacks into a single heap-allocated struct so they can be
  // passed through the C ABI as a single void* user_data pointer.
  struct Callbacks {
    RunCallback run;
    EventCallback event;
  };
  auto* cbs = new Callbacks{std::move(callback), std::move(event_callback)};
 
  auto c_callback = [](const ffi::Result* result, void* ud) noexcept {
    auto* cbs = static_cast<Callbacks*>(ud);
    try {
      cbs->run(Result{result});
    } catch (...) {
    }
    delete cbs;
  };
 
  // C-level event trampoline — only set when EventCallback is non-null.
  ffi::InstanceEventCallback c_event_callback = nullptr;
  if (cbs->event) {
    c_event_callback = [](const ffi::CEvent* event, void* ud) noexcept {
      auto* cbs = static_cast<Callbacks*>(ud);
      try {
        cbs->event(*event);
      } catch (...) {
      }
    };
  }
 
  std::unique_ptr<ffi::Result, decltype(&ffi::resultDelete)> start_result{
      ffi::instanceRun(
          &*p_,
          reinterpret_cast<const uint8_t*>(symbol.data()), symbol.size(),
          reinterpret_cast<const uint8_t*>(timeframe.data()), timeframe.size(),
          from_time, c_event_callback, c_callback, cbs),
      ffi::resultDelete};
 
  if (!ffi::resultIsSuccess(&*start_result)) {
    delete cbs;
    throw Error{ffi::resultErrorMessage(&*start_result),
                ffi::resultErrorSpan(&*start_result)};
  }
}
 
}  // namespace openpine