handle.h

Go to the documentation of this file.

 
#pragma once
 
#include <neograph/api.h>
#include <neograph/program/event.h>
#include <neograph/program/replacement.h>
#include <neograph/program/result.h>
#include <neograph/program/run_record.h>
 
#include <asio/awaitable.hpp>
 
#include <cstdint>
#include <memory>
#include <optional>
#include <string>
#include <vector>
 
namespace neograph::program {
 
namespace detail {
class RunControl;
}
class ProgramRuntime;
struct ProgramResume;
struct ProgramEffectResolution;
 
struct ProgramNotice {
    std::string code;
    std::string message;
    json        witness;
 
    bool operator==(const ProgramNotice&) const = default;
};
 
class NEOGRAPH_PROGRAM_API ProgramHandle {
public:
    ProgramHandle(const ProgramHandle&) noexcept            = default;
    ProgramHandle& operator=(const ProgramHandle&) noexcept = default;
    ProgramHandle(ProgramHandle&&) noexcept                 = default;
    ProgramHandle& operator=(ProgramHandle&&) noexcept      = default;
    ~ProgramHandle();
 
    const std::string& run_id() const noexcept;
    const std::string& logical_run_id() const noexcept;
    const std::string& program_version_id() const noexcept;
    std::uint64_t      attempt() const noexcept;
 
    bool                                  cancel() noexcept;
    ProgramResult                         wait() const;
    asio::awaitable<ProgramResult>        wait_async() const;
    std::optional<ProgramResult>          try_result() const;
    std::vector<ProgramEvent>             events_after(std::uint64_t sequence) const;
    std::optional<CoreCheckpointIdentity> latest_checkpoint() const;
    std::optional<ExactProgramHandoff>    latest_handoff() const;
    ProgramHandoff                        next_handoff() const;
    asio::awaitable<ProgramHandoff>       next_handoff_async() const;
    ProgramRunRecord                      snapshot() const;
    asio::awaitable<bool>                 cancel_async();
    asio::awaitable<std::optional<ExactProgramHandoff>> latest_handoff_async() const;
    asio::awaitable<ProgramRunRecord>     snapshot_async() const;
    std::vector<ProgramNotice>            notices() const;
    ProgramHandle resume(ProgramRuntime& runtime, ProgramResume resume) const;
    ProgramHandle reconcile(ProgramRuntime& runtime,
                            ProgramEffectResolution resolution) const;
 
private:
    explicit ProgramHandle(std::shared_ptr<detail::RunControl> control);
    std::shared_ptr<detail::RunControl> control_;
 
    friend class ProgramRuntime;
};
 
}  // namespace neograph::program