strategy_plugin.hpp

Go to the documentation of this file.

#pragma once
 
#include <pineforge/pineforge.h>
#include <pineforge/execution_observer.h>
#include <pineforge/selected_window.h>
#include <pineforge/hpo/symbol_feeds.hpp>
 
#include <cstddef>
#include <cstdint>
#include <filesystem>
#include <optional>
#include <string>
 
namespace pineforge {
namespace hpo {
 
struct EngineVersion {
    std::uint32_t major = 0;
    std::uint32_t minor = 0;
    std::uint32_t patch = 0;
    std::string full;
    std::string commit_sha;
};
 
EngineVersion validate_selected_engine_version(
    const std::optional<pf_version_t>& numbers,
    const std::optional<std::string>& full,
    const std::optional<std::string>& expected_manifest_version = std::nullopt);
 
struct SymbolInfo {
    std::optional<double> mintick;
    std::optional<double> pointvalue;
    std::optional<double> mincontract;
    std::string timezone;
    std::string session;
    std::optional<std::int64_t> series_origin_ms = std::nullopt;
};
 
class StrategyPlugin final {
public:
    explicit StrategyPlugin(std::filesystem::path path);
    ~StrategyPlugin();
 
    StrategyPlugin(const StrategyPlugin&) = delete;
    StrategyPlugin& operator=(const StrategyPlugin&) = delete;
    StrategyPlugin(StrategyPlugin&& other) noexcept;
    StrategyPlugin& operator=(StrategyPlugin&& other) noexcept;
 
    const std::filesystem::path& path() const noexcept { return path_; }
    int abi_version() const noexcept { return abi_version_value_; }
 
    pf_strategy_t create_strategy() const;
 
    void free_strategy(pf_strategy_t strategy) const noexcept;
 
    void set_input(pf_strategy_t strategy, const std::string& key, const std::string& value) const;
 
    void set_override(pf_strategy_t strategy,
                      const std::string& key,
                      const std::string& value) const;
 
    void set_chart_timezone(pf_strategy_t strategy, const std::string& timezone) const;
 
    void set_symbol_info(pf_strategy_t strategy, const SymbolInfo& info) const;
 
    void set_symbol_feeds(pf_strategy_t strategy, const SymbolFeeds& symbols) const;
 
    void set_scratch_tables_bounded_default(pf_strategy_t strategy) const;
 
    void require_scratch_arena(pf_strategy_t strategy) const;
 
    void run_backtest_full(pf_strategy_t strategy,
                           const pf_bar_t* bars,
                           int bar_count,
                           const std::string& input_timeframe,
                           const std::string& script_timeframe,
                           bool bar_magnifier,
                           int magnifier_samples,
                           pf_magnifier_distribution_t magnifier_distribution,
                           pf_report_t* report) const;
    std::string last_error(pf_strategy_t strategy) const;
 
    std::optional<std::string> last_error_code(pf_strategy_t strategy) const;
    std::optional<std::string> last_error_args(pf_strategy_t strategy) const;
    std::optional<std::int32_t> last_run_status(pf_strategy_t strategy) const;
 
    bool selected_window_available() const noexcept;
 
    void require_selected_window(
        const std::optional<std::string>& expected_manifest_version = std::nullopt) const;
 
    EngineVersion engine_version(
        const std::optional<std::string>& expected_manifest_version = std::nullopt) const;
 
    void set_selected_window(pf_strategy_t strategy, std::int64_t start_ms,
                             std::int64_t end_ms) const;
    void clear_selected_window(pf_strategy_t strategy) const;
    pf_selected_window_counts_v1 selected_window_counts(pf_strategy_t strategy) const;
    void set_execution_observer(pf_strategy_t strategy,
                                const pf_execution_observer_v1* observer) const;
    pf_execution_observation_v1 execution_observation(pf_strategy_t strategy) const;
    std::optional<std::string> effective_settings(pf_strategy_t strategy) const;
 
    void free_report(pf_report_t* report) const noexcept;
 
private:
    using StrategyCreateFn = pf_strategy_t (*)(const char*);
    using StrategyFreeFn = void (*)(pf_strategy_t);
    using StrategySetInputFn = void (*)(pf_strategy_t, const char*, const char*);
    using StrategySetOverrideFn = void (*)(pf_strategy_t, const char*, const char*);
    using StrategySetChartTimezoneFn = void (*)(pf_strategy_t, const char*);
    using StrategySetSymbolDoubleFn = void (*)(pf_strategy_t, double);
    using StrategySetSymbolMetadataFn = void (*)(pf_strategy_t, const char*, double);
    using StrategySetSymbolStringFn = void (*)(pf_strategy_t, const char*);
    using StrategySetSymbolFactsFn = int (*)(pf_strategy_t, const char*, const char*, const char*);
    using StrategySetSymbolFeedFn = int (*)(pf_strategy_t, const char*, const char*,
                                           const pf_bar_t*, const std::int64_t*, std::int32_t);
    // Mirror the additive C descriptor without requiring its declaration in older engine headers.
    struct ScratchTablesV1 {
        std::uint32_t struct_size;
        std::uint32_t version;
        std::uint32_t backend;
        std::uint32_t reserved;
        std::uint64_t maxima[11];
    };
    using StrategySetScratchTablesFn = int (*)(pf_strategy_t, const ScratchTablesV1*);
    using StrategyRequireScratchArenaFn = int (*)(pf_strategy_t);
    using RunBacktestFullFn = void (*)(pf_strategy_t,
                                       pf_bar_t*,
                                       int,
                                       const char*,
                                       const char*,
                                       int,
                                       int,
                                       pf_magnifier_distribution_t,
                                       pf_report_t*);
    using StrategyGetLastErrorFn = const char* (*)(pf_strategy_t);
    using StrategyLastRunStatusFn = int (*)(pf_strategy_t);
    using StrategyCreateCheckedFn = int (*)(const char*, pf_strategy_t*, char*, std::size_t);
    using StrategySetCheckedFn =
        int (*)(pf_strategy_t, const char*, const char*, char*, std::size_t);
    using ReportFreeFn = void (*)(pf_report_t*);
    using AbiVersionFn = int (*)();
    using ProtocolVersionFn = std::uint32_t (*)();
    using SetSelectedWindowFn = int (*)(pf_strategy_t, const pf_selected_window_config_v1*);
    using SelectedWindowCountsFn = int (*)(pf_strategy_t, pf_selected_window_counts_v1*);
    using SetExecutionObserverFn = int (*)(pf_strategy_t, const pf_execution_observer_v1*);
    using ExecutionObservationFn = int (*)(pf_strategy_t, pf_execution_observation_v1*);
    using VersionGetFn = pf_version_t (*)();
    using VersionStringFn = const char* (*)();
    using EffectiveSettingsFn =
        int (*)(pf_strategy_t, char*, std::size_t, std::size_t*, char*, std::size_t);
 
    void close() noexcept;
 
    std::filesystem::path path_;
    void* library_handle_ = nullptr;
    int abi_version_value_ = 0;
    StrategyCreateFn strategy_create_ = nullptr;
    StrategyFreeFn strategy_free_ = nullptr;
    StrategySetInputFn strategy_set_input_ = nullptr;
    StrategySetOverrideFn strategy_set_override_ = nullptr;
    StrategySetChartTimezoneFn strategy_set_chart_timezone_ = nullptr;
    StrategySetSymbolDoubleFn strategy_set_syminfo_mintick_ = nullptr;
    StrategySetSymbolDoubleFn strategy_set_syminfo_pointvalue_ = nullptr;
    StrategySetSymbolMetadataFn strategy_set_syminfo_metadata_ = nullptr;
    StrategySetSymbolStringFn strategy_set_syminfo_timezone_ = nullptr;
    StrategySetSymbolStringFn strategy_set_syminfo_session_ = nullptr;
    StrategySetSymbolFactsFn strategy_set_symbol_facts_ = nullptr;
    StrategySetSymbolFeedFn strategy_set_symbol_feed_ = nullptr;
    StrategySetScratchTablesFn strategy_set_scratch_tables_v1_ = nullptr;
    StrategyRequireScratchArenaFn strategy_require_report_scratch_arena_v1_ = nullptr;
    RunBacktestFullFn run_backtest_full_ = nullptr;
    StrategyGetLastErrorFn strategy_get_last_error_ = nullptr;
    StrategyGetLastErrorFn strategy_get_last_error_code_ = nullptr;
    StrategyGetLastErrorFn strategy_get_last_error_args_ = nullptr;
    StrategyLastRunStatusFn strategy_last_run_status_ = nullptr;
    StrategyCreateCheckedFn strategy_create_checked_ = nullptr;
    StrategySetCheckedFn strategy_set_input_checked_ = nullptr;
    StrategySetCheckedFn strategy_set_override_checked_ = nullptr;
    ReportFreeFn report_free_ = nullptr;
    AbiVersionFn pf_abi_version_ = nullptr;
    ProtocolVersionFn pf_selected_window_version_ = nullptr;
    SetSelectedWindowFn strategy_set_selected_window_v1_ = nullptr;
    SelectedWindowCountsFn strategy_selected_window_counts_v1_ = nullptr;
    ProtocolVersionFn pf_execution_observer_version_ = nullptr;
    SetExecutionObserverFn strategy_set_execution_observer_v1_ = nullptr;
    ExecutionObservationFn strategy_execution_observation_v1_ = nullptr;
    VersionGetFn pf_version_get_ = nullptr;
    VersionStringFn pf_version_string_ = nullptr;
    EffectiveSettingsFn strategy_get_effective_settings_ = nullptr;
};
 
}  // namespace hpo
}  // namespace pineforge