ground.hh

#pragma once
 
#include <clingo/base.hh>
#include <clingo/core.hh>
#include <clingo/stats.hh>
 
#include <clingo/ground.h>
 
namespace Clingo {
 
 
struct Part {
    constexpr Part(std::string name, SymbolVector params = {}) : name{std::move(name)}, params(std::move(params)) {
        assert(!this->name.empty());
    }
 
    std::string name;
    SymbolVector params;
};
using PartSpan = std::span<Part const>;
using PartList = std::initializer_list<Part>;
using PartVector = std::vector<Part>;
 
enum class GroundResult : clingo_ground_result_t {
    ok = clingo_ground_result_ok,                       
    unsatisfiable = clingo_ground_result_unsatisfiable, 
    interrupted = clingo_ground_result_interrupted,     
};
 
class GroundEventHandler {
  public:
    GroundEventHandler() = default;
    virtual ~GroundEventHandler() = default;
 
    auto callable(std::string_view name, size_t args) -> bool { return do_callable(name, args); }
 
    auto call(Location const &loc, std::string_view name, SymbolSpan args) -> SymbolVector {
        return do_call(loc, name, args);
    }
 
    void finish(GroundResult result) noexcept { do_finish(result); }
 
  private:
    virtual auto do_callable([[maybe_unused]] std::string_view name, [[maybe_unused]] size_t args) -> bool {
        return false;
    }
    virtual auto do_call([[maybe_unused]] Location const &loc, [[maybe_unused]] std::string_view name,
                         [[maybe_unused]] SymbolSpan args) -> SymbolVector {
        return {};
    }
    virtual void do_finish([[maybe_unused]] GroundResult result) noexcept {}
};
 
class GroundHandle {
  public:
    explicit GroundHandle(clingo_ground_handle_t *hnd) : hnd_{hnd} {}
 
    friend auto c_cast(GroundHandle const &x) -> clingo_ground_handle_t * { return x.hnd_.get(); }
 
    [[nodiscard]] auto get() const -> GroundResult {
        return GroundResult{Detail::call<clingo_ground_handle_get>(hnd_.get())};
    }
 
    void cancel() { Detail::handle_error(clingo_ground_handle_cancel(hnd_.get())); }
 
    void close() noexcept { hnd_.reset(); }
 
    [[nodiscard]] auto wait(std::optional<double> timeout) -> bool {
        return Detail::call<clingo_ground_handle_wait>(hnd_.get(), timeout.value_or(-1));
    }
 
  private:
    struct Del {
        void operator()(clingo_ground_handle_t *hnd) const noexcept { clingo_ground_handle_close(hnd); }
    };
    using Ptr = std::unique_ptr<clingo_ground_handle_t, Del>;
 
    Ptr hnd_;
};
 
 
} // namespace Clingo