plan.h

Go to the documentation of this file.

 
#pragma once
 
#include <neograph/api.h>
#include <neograph/json.h>
 
#include <cstdint>
#include <memory>
#include <optional>
#include <string>
#include <string_view>
#include <vector>
 
namespace neograph::program {
 
enum class ProgramOperationKind : std::uint8_t {
    CallCore,
    Sequence,
    Branch,
    Loop,
    Retry,
    Parallel,
    Race,
    Quorum,
    Map,
    Spawn,
    Await,
    Emit,
    Checkpoint,
    Cancel,
    Return,
    ParallelMap,
    ExpandTaskGraph,
};
 
enum class ProgramTaskGraphFailurePolicy : std::uint8_t {
    FailFast,
    Collect,
};
 
enum class ProgramParallelMapItemSource : std::uint8_t {
    Literal,
    InputField,
};
 
enum class ProgramParallelMapFailurePolicy : std::uint8_t {
    FailFast,
    Collect,
};
 
struct NEOGRAPH_PROGRAM_API ProgramParallelMapSpec {
    ProgramParallelMapItemSource    item_source = ProgramParallelMapItemSource::Literal;
    json                            literal_items = json::array();
    std::string                     input_field;
    std::string                     child_binding;
    std::string                     input_from_field;
    std::string                     input_to_field;
    std::string                     output_from_field;
    std::uint64_t                   max_items = 0;
    std::uint32_t                   max_in_flight = 0;
    std::uint64_t                   max_output_bytes = 0;
    ProgramParallelMapFailurePolicy failure_policy = ProgramParallelMapFailurePolicy::FailFast;
 
    bool operator==(const ProgramParallelMapSpec&) const = default;
};
 
struct NEOGRAPH_PROGRAM_API ProgramExpandTaskGraphSpec {
    json                          proposal_source = json::object();
    std::uint64_t                 max_tasks = 0;
    std::uint64_t                 max_edges = 0;
    std::uint64_t                 max_depth = 0;
    std::uint64_t                 max_dynamic_compiles = 0;
    std::uint64_t                 max_total_children = 0;
    std::uint32_t                 max_concurrency = 0;
    ProgramTaskGraphFailurePolicy failure_policy = ProgramTaskGraphFailurePolicy::FailFast;
 
    bool operator==(const ProgramExpandTaskGraphSpec&) const = default;
};
 
NEOGRAPH_PROGRAM_API std::string_view to_string(ProgramOperationKind kind) noexcept;
NEOGRAPH_PROGRAM_API ProgramOperationKind
program_operation_kind_from_string(std::string_view value);
 
struct NEOGRAPH_PROGRAM_API ProgramPlanDispatchDescriptor {
    ProgramOperationKind          operation = ProgramOperationKind::CallCore;
    std::string                   source_pointer;
    std::vector<std::string>      children;
    std::optional<std::string>    then_id;
    std::optional<std::string>    else_id;
    std::optional<std::string>    body;
    std::optional<std::string>    child_binding;
    std::vector<std::string>      branches;
    bool operator==(const ProgramPlanDispatchDescriptor&) const = default;
};
 
using ProgramPlanDispatch = ProgramPlanDispatchDescriptor;
 
class NEOGRAPH_PROGRAM_API ProgramPlanNode final {
public:
    ProgramPlanNode(const ProgramPlanNode&)            = default;
    ProgramPlanNode& operator=(const ProgramPlanNode&) = default;
    ProgramPlanNode(ProgramPlanNode&&) noexcept        = default;
    ProgramPlanNode& operator=(ProgramPlanNode&&) noexcept = default;
    ~ProgramPlanNode();
 
    const std::string& id() const noexcept;
    ProgramOperationKind operation() const noexcept;
    const ProgramPlanDispatchDescriptor& dispatch() const noexcept;
    const ProgramPlanDispatchDescriptor& dispatch_descriptor() const noexcept;
    const std::string& source_pointer() const noexcept;
    const std::optional<std::string>& core() const noexcept;
    const std::vector<std::string>& children() const noexcept;
    const std::optional<std::string>& then_id() const noexcept;
    const std::optional<std::string>& else_id() const noexcept;
    const std::optional<std::string>& body() const noexcept;
    const std::optional<std::string>& child_binding() const noexcept;
    const std::vector<std::string>& branches() const noexcept;
    const std::optional<std::uint64_t>& max_iterations() const noexcept;
    const std::optional<std::uint64_t>& max_attempts() const noexcept;
    const std::optional<std::uint64_t>& min_success() const noexcept;
    const std::optional<std::uint64_t>& timeout_ms() const noexcept;
    const std::optional<std::string>& scope() const noexcept;
    const std::optional<ProgramParallelMapSpec>& parallel_map() const noexcept;
    const std::optional<ProgramExpandTaskGraphSpec>& expand_task_graph() const noexcept;
    const std::optional<std::string>& reason() const noexcept;
    json condition() const;
    json value() const;
    json items() const;
 
    json to_json() const;
 
private:
    struct Impl;
    explicit ProgramPlanNode(std::shared_ptr<const Impl> impl);
    std::shared_ptr<const Impl> impl_;
 
    friend class ProgramPlan;
};
 
class NEOGRAPH_PROGRAM_API ProgramPlan final {
public:
    static constexpr std::uint32_t SCHEMA_VERSION = 1;
 
    ProgramPlan(const ProgramPlan&)            = default;
    ProgramPlan& operator=(const ProgramPlan&) = default;
    ProgramPlan(ProgramPlan&&) noexcept        = default;
    ProgramPlan& operator=(ProgramPlan&&) noexcept = default;
    ~ProgramPlan();
 
    static ProgramPlan from_json(const json& plan);
 
    std::uint32_t schema_version() const noexcept;
    const std::string& root_id() const noexcept;
    const std::vector<ProgramPlanNode>& nodes() const noexcept;
    const ProgramPlanNode& root() const;
    const ProgramPlanNode* find(std::string_view id) const noexcept;
    json to_json() const;
 
private:
    struct Impl;
    explicit ProgramPlan(std::shared_ptr<const Impl> impl);
    std::shared_ptr<const Impl> impl_;
};
 
struct NEOGRAPH_PROGRAM_API ProgramStaticBudgetRequirements {
    std::uint64_t max_program_operations = 0;
    std::uint32_t max_concurrency        = 0;
    std::uint64_t max_core_steps         = 0;
    std::uint64_t max_core_invocations   = 0;
    std::uint32_t max_child_depth        = 0;
    std::uint64_t max_total_children     = 0;
    std::uint64_t max_dynamic_compiles   = 0;
 
    bool operator==(const ProgramStaticBudgetRequirements&) const = default;
};
 
NEOGRAPH_PROGRAM_API ProgramStaticBudgetRequirements
derive_static_budget_requirements(const ProgramPlan& plan);
 
}  // namespace neograph::program