window_plan.hpp

Go to the documentation of this file.

#pragma once
 
#include <pineforge/selected_window_plan.h>
 
#include <cstddef>
#include <cstdint>
#include <filesystem>
#include <functional>
#include <string>
 
namespace pineforge::hpo {
 
namespace detail {
struct WindowPlanTestAccess;
}  // namespace detail
 
enum class PlanStatus : std::int32_t {
    Ok = 0,                   
    RequestInvalid = 1,       
    CalendarUnsupported = 2,  
    BoundaryUnaligned = 3,    
    FeedRangeInvalid = 4,     
    RowsUnordered = 5,        
    InternalError = 6         
};
 
struct PlanRequest {
    std::int64_t start_ms = 0;
    std::int64_t end_ms = 0;
    std::int64_t fed_start_ms = 0;
    std::uint32_t preroll_bars = 0;
    std::string input_tf;
    std::string script_tf;
    std::string chart_timezone;
    std::string engine_timezone;
    std::string session;
    bool feed_tolerant = true;
};
 
struct PlanResult {
    pf_selected_plan_result_v1 raw{};
 
    PlanStatus status() const noexcept { return static_cast<PlanStatus>(raw.status); }
    bool ok() const noexcept { return status() == PlanStatus::Ok; }
};
 
class WindowPlanHelper final {
public:
    static WindowPlanHelper load(const std::filesystem::path& absolute_path,
                                 const std::string& expected_sha256_hex,
                                 const std::filesystem::path& private_run_directory);
 
    ~WindowPlanHelper();
    WindowPlanHelper(const WindowPlanHelper&) = delete;
    WindowPlanHelper& operator=(const WindowPlanHelper&) = delete;
    WindowPlanHelper(WindowPlanHelper&& other) noexcept;
    WindowPlanHelper& operator=(WindowPlanHelper&& other) noexcept;
 
    PlanResult plan_selected_primary(const pf_bar_t* rows, std::size_t count,
                                     const PlanRequest& request) const;
 
    std::uint32_t version() const noexcept { return version_; }
    const std::filesystem::path& source_path() const noexcept { return source_path_; }
    std::uint64_t source_device() const noexcept { return source_device_; }
    std::uint64_t source_inode() const noexcept { return source_inode_; }
    std::uint64_t source_size() const noexcept { return source_size_; }
    const std::filesystem::path& snapshot_path() const noexcept { return snapshot_path_; }
    const std::string& sha256() const noexcept { return sha256_; }
    static constexpr const char* self_test_id() noexcept {
        return "selected-plan-utc-six-hours/v1";
    }
 
private:
    friend struct detail::WindowPlanTestAccess;
    using VersionFn = decltype(&::pf_selected_plan_version);
    using PlanFn = decltype(&::pf_plan_selected_primary_v1);
 
    WindowPlanHelper() = default;
    static WindowPlanHelper load_impl(const std::filesystem::path& absolute_path,
                                      const std::string& expected_sha256_hex,
                                      const std::filesystem::path& private_run_directory,
                                      const std::function<void()>& after_source_open,
                                      const std::function<void(const std::filesystem::path&)>&
                                          after_snapshot_close);
    static VersionFn bind_version(void* library);
    static PlanFn bind_plan(void* library);
    void self_test() const;
    void close() noexcept;
 
    std::filesystem::path source_path_;
    std::filesystem::path snapshot_path_;
    std::string sha256_;
    void* library_ = nullptr;
    PlanFn plan_ = nullptr;
    std::uint32_t version_ = 0;
    std::uint64_t source_device_ = 0;
    std::uint64_t source_inode_ = 0;
    std::uint64_t source_size_ = 0;
};
 
}  // namespace pineforge::hpo