head_literal.hh

#pragma once
 
#include <clingo/input/aggregate.hh>
#include <clingo/input/literal.hh>
#include <clingo/input/theory.hh>
 
#include <utility>
 
namespace CppClingo::Input {
 
 
class HdLitSimple : public Expression<HdLitSimple> {
  public:
    static constexpr auto attributes() { return std::tuple{a_lit = &HdLitSimple::lit_}; }
 
    HdLitSimple(Lit lit) : lit_{std::move(lit)} {}
    [[nodiscard]] auto loc() const -> Location const & { return location(lit_); }
    [[nodiscard]] auto lit() const -> Lit const & { return lit_; }
 
  private:
    Lit lit_;
};
 
using HdLitDisjunctionElement = std::variant<Lit, CondLit>;
using HdLitDisjunctionElementArray = Util::immutable_array<HdLitDisjunctionElement>;
 
class HdLitDisjunction : public Expression<HdLitDisjunction> {
  public:
    static constexpr auto attributes() {
        return std::tuple{a_loc = &HdLitDisjunction::loc_, a_elems = &HdLitDisjunction::elems_};
    }
 
    explicit HdLitDisjunction(Location loc, HdLitDisjunctionElementArray elems)
        : loc_{std::move(loc)}, elems_{std::move(elems)} {}
    [[nodiscard]] auto loc() const -> Location const & { return loc_; }
    [[nodiscard]] auto elems() const -> HdLitDisjunctionElementArray const & { return elems_; }
 
  private:
    Location loc_;
    HdLitDisjunctionElementArray elems_;
};
 
class HdLitAggregateElement : public Expression<HdLitAggregateElement> {
  public:
    static constexpr auto attributes() {
        return std::tuple{a_loc = &HdLitAggregateElement::loc_, a_tuple = &HdLitAggregateElement::tuple_,
                          a_lit = &HdLitAggregateElement::lit_, a_cond = &HdLitAggregateElement::cond_};
    }
 
    explicit HdLitAggregateElement(Location loc, TermArray tuple, Lit lit, LitArray cond)
        : loc_{std::move(loc)}, tuple_{std::move(tuple)}, lit_{std::move(lit)}, cond_{std::move(cond)} {}
    [[nodiscard]] auto loc() const -> Location const & { return loc_; }
    [[nodiscard]] auto tuple() const -> TermArray const & { return tuple_; }
    [[nodiscard]] auto lit() const -> Lit const & { return lit_; }
    [[nodiscard]] auto cond() const -> LitArray const & { return cond_; }
 
  private:
    Location loc_;
    TermArray tuple_;
    Lit lit_;
    LitArray cond_;
};
using HdLitAggregateElementArray = Util::immutable_array<HdLitAggregateElement>;
 
class HdLitAggregate : public Expression<HdLitAggregate> {
  public:
    static constexpr auto attributes() {
        return std::tuple{a_loc = &HdLitAggregate::loc_, a_lhs = &HdLitAggregate::lhs_, a_fun = &HdLitAggregate::fun_,
                          a_elems = &HdLitAggregate::elems_, a_rhs = &HdLitAggregate::rhs_};
    }
 
    explicit HdLitAggregate(Location loc, LGuard lhs, AggregateFunction fun, HdLitAggregateElementArray elems,
                            RGuard rhs)
        : loc_{std::move(loc)}, fun_(fun), elems_(std::move(elems)), lhs_{std::move(lhs)}, rhs_{std::move(rhs)} {}
    explicit HdLitAggregate(Location loc, AggregateFunction fun, HdLitAggregateElementArray elems)
        : HdLitAggregate{std::move(loc), std::nullopt, fun, std::move(elems), std::nullopt} {}
    explicit HdLitAggregate(Location loc, AggregateFunction fun, HdLitAggregateElementArray elems, Relation rel,
                            Term rhs)
        : HdLitAggregate{std::move(loc), std::nullopt, fun, std::move(elems), std::make_pair(rel, std::move(rhs))} {}
 
    [[nodiscard]] auto loc() const -> Location const & { return loc_; }
    [[nodiscard]] auto fun() const -> AggregateFunction { return fun_; }
    [[nodiscard]] auto elems() const -> HdLitAggregateElementArray const & { return elems_; }
    [[nodiscard]] auto lhs() const -> LGuard const & { return lhs_; }
    [[nodiscard]] auto rhs() const -> RGuard const & { return rhs_; }
 
  private:
    Location loc_;
    AggregateFunction fun_;
    HdLitAggregateElementArray elems_;
    LGuard lhs_;
    RGuard rhs_;
};
 
using HdLit = std::variant<HdLitSimple, HdLitDisjunction, HdLitAggregate, HdLitSetAggregate, HdLitTheoryAtom>;
using HdLitArray = Util::immutable_array<HdLit>;
 
 
} // namespace CppClingo::Input