strategy_plugin.hpp

Go to the documentation of this file.

#pragma once
 
#include <pineforge/pineforge.h>
 
#include <filesystem>
#include <string>
 
namespace pineforge {
namespace hpo {
 
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 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;
 
    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 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 ReportFreeFn = void (*)(pf_report_t*);
    using AbiVersionFn = int (*)();
 
    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;
    RunBacktestFullFn run_backtest_full_ = nullptr;
    StrategyGetLastErrorFn strategy_get_last_error_ = nullptr;
    ReportFreeFn report_free_ = nullptr;
    AbiVersionFn pf_abi_version_ = nullptr;
};
 
}  // namespace hpo
}  // namespace pineforge