scheduler.h

Go to the documentation of this file.

 
#pragma once
 
#include <neograph/api.h>
#include <neograph/graph/types.h>
 
#include <map>
#include <memory>
#include <optional>
#include <set>
#include <vector>
 
namespace neograph::graph {
 
class GraphState;
class GraphRegistry;
 
struct StepRouting {
    std::string node_name;
    std::optional<std::string> command_goto;
};
 
struct NextStepPlan {
    std::vector<std::string> ready;
    bool hit_end = false;
    bool hit_explicit_end = false;
    std::optional<std::string> winning_command_goto;
};
 
using BarrierState = std::map<std::string, std::set<std::string>>;
 
using BarrierSpecs = std::map<std::string, std::set<std::string>>;
 
struct JoinSpec {
    std::vector<std::set<std::string>> slots;
 
    bool operator==(const JoinSpec&) const = default;
};
 
using JoinSpecs = std::map<std::string, JoinSpec>;
 
class NEOGRAPH_API Scheduler {
public:
    Scheduler(const std::vector<Edge>& edges,
              const std::vector<ConditionalEdge>& conditional_edges,
              BarrierSpecs barrier_specs = {});
 
    Scheduler(const std::vector<Edge>&             edges,
              const std::vector<ConditionalEdge>&  conditional_edges,
              BarrierSpecs                         barrier_specs,
              std::shared_ptr<const GraphRegistry> registry);
 
    Scheduler(const std::vector<Edge>&             edges,
              const std::vector<ConditionalEdge>&  conditional_edges,
              BarrierSpecs                         barrier_specs,
              JoinSpecs                            join_specs,
              std::shared_ptr<const GraphRegistry> registry);
 
    Scheduler(const std::vector<Edge>&             edges,
              const std::vector<ConditionalEdge>&  conditional_edges,
              BarrierSpecs                         barrier_specs,
              JoinSpecs                            join_specs,
              std::map<std::string, std::string>   failure_targets,
              std::shared_ptr<const GraphRegistry> registry);
 
    std::vector<std::string> resolve_next_nodes(
        const std::string& current, const GraphState& state) const;
 
    std::vector<std::string> plan_start_step() const;
 
    NextStepPlan plan_next_step(const std::vector<StepRouting>& routings,
                                const GraphState& state) const;
 
    NextStepPlan plan_next_step(const std::vector<std::string>& just_ran,
                                const std::vector<NodeResult>& results,
                                const GraphState& state) const;
 
    NextStepPlan plan_next_step(const std::vector<StepRouting>& routings,
                                const GraphState& state,
                                BarrierState& barrier_state) const;
 
    NextStepPlan plan_next_step(const std::vector<std::string>& just_ran,
                                const std::vector<NodeResult>& results,
                                const GraphState& state,
                                BarrierState& barrier_state) const;
 
    NextStepPlan plan_next_step(const std::vector<StepRouting>& routings,
                                const GraphState& state,
                                BarrierState& barrier_state,
                                const std::vector<bool>& failed) const;
 
    const std::string* failure_target(const std::string& node) const;
 
    bool ends_implicitly(const std::string& node) const;
 
    const BarrierSpecs& barrier_specs() const { return barrier_specs_; }
 
    const JoinSpecs& join_specs() const { return join_specs_; }
 
private:
    const std::vector<Edge>& edges_;
    const std::vector<ConditionalEdge>& conditional_edges_;
    BarrierSpecs barrier_specs_;
    JoinSpecs join_specs_;
    std::shared_ptr<const GraphRegistry> registry_;
    std::map<std::string, std::string> failure_targets_;
};
 
} // namespace neograph::graph