body_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 BdLitSimple : public Expression<BdLitSimple> {
  public:
    static constexpr auto attributes() { return std::tuple{a_lit = &BdLitSimple::lit_}; }
 
    BdLitSimple(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_;
};
 
class BdLitConjunction : public Expression<BdLitConjunction> {
  public:
    static constexpr auto attributes() { return std::tuple{a_lit = &BdLitConjunction::lit_}; }
 
    BdLitConjunction(CondLit lit) : lit_{std::move(lit)} {}
    [[nodiscard]] auto loc() const -> Location const & { return lit_.loc(); }
    [[nodiscard]] auto lit() const -> CondLit const & { return lit_; }
 
  private:
    CondLit lit_;
};
 
class BdLitAggregateElement : public Expression<BdLitAggregateElement> {
  public:
    static constexpr auto attributes() {
        return std::tuple{a_loc = &BdLitAggregateElement::loc_, a_tuple = &BdLitAggregateElement::tuple_,
                          a_cond = &BdLitAggregateElement::cond_};
    }
 
    explicit BdLitAggregateElement(Location loc, TermArray tuple, LitArray cond)
        : loc_{std::move(loc)}, tuple_{std::move(tuple)}, cond_{std::move(cond)} {}
    [[nodiscard]] auto loc() const -> Location const & { return loc_; }
    [[nodiscard]] auto tuple() const -> TermArray const & { return tuple_; }
    [[nodiscard]] auto cond() const -> LitArray const & { return cond_; }
 
  private:
    Location loc_;
    TermArray tuple_;
    LitArray cond_;
};
using BdLitAggregateElementArray = Util::immutable_array<BdLitAggregateElement>;
 
class BdLitAggregate : public Expression<BdLitAggregate> {
  public:
    static constexpr auto attributes() {
        return std::tuple{a_loc = &BdLitAggregate::loc_,     a_sign = &BdLitAggregate::sign_,
                          a_lhs = &BdLitAggregate::lhs_,     a_fun = &BdLitAggregate::fun_,
                          a_elems = &BdLitAggregate::elems_, a_rhs = &BdLitAggregate::rhs_};
    }
 
    explicit BdLitAggregate(Location loc, Sign sign, LGuard lhs, AggregateFunction fun,
                            BdLitAggregateElementArray elems, RGuard rhs)
        : loc_{std::move(loc)}, sign_{sign}, fun_(fun), elems_(std::move(elems)), lhs_{std::move(lhs)},
          rhs_{std::move(rhs)} {}
 
    [[nodiscard]] auto loc() const -> Location const & { return loc_; }
    [[nodiscard]] auto sign() const -> Sign { return sign_; }
    [[nodiscard]] auto fun() const -> AggregateFunction { return fun_; }
    [[nodiscard]] auto elems() const -> BdLitAggregateElementArray const & { return elems_; }
    [[nodiscard]] auto lhs() const -> LGuard const & { return lhs_; }
    [[nodiscard]] auto rhs() const -> RGuard const & { return rhs_; }
 
  private:
    Location loc_;
    Sign sign_;
    AggregateFunction fun_;
    BdLitAggregateElementArray elems_;
    LGuard lhs_;
    RGuard rhs_;
};
 
using BdLit = std::variant<BdLitSimple, BdLitConjunction, BdLitAggregate, BdLitSetAggregate, BdLitTheoryAtom>;
using BdLitArray = Util::immutable_array<BdLit>;
 
 
} // namespace CppClingo::Input