literal.hh

#pragma once
 
#include <clingo/input/term.hh>
 
#include <clingo/core/core.hh>
 
#include <utility>
 
namespace CppClingo::Input {
 
 
class Signed {
  public:
    explicit Signed(Sign sign) : sign_{sign} {}
    [[nodiscard]] auto sign() const -> Sign { return sign_; };
 
    friend auto operator==(Signed const &a, Signed const &b) -> bool = default;
    friend auto operator<=>(Signed const &a, Signed const &b) -> std::strong_ordering = default;
 
  private:
    Sign sign_;
};
 
class Unsigned {
    friend auto operator==(Unsigned const &a, Unsigned const &b) -> bool = default;
    friend auto operator<=>(Unsigned const &a, Unsigned const &b) -> std::strong_ordering = default;
};
 
using Guard = std::pair<Relation, Term>;
using GuardArray = Util::immutable_array<Guard>;
 
class LitBool : public Expression<LitBool> {
  public:
    static constexpr auto attributes() {
        return std::tuple{a_loc = &LitBool::loc_, a_sign = &LitBool::sign_, a_value = &LitBool::value_};
    }
 
    explicit LitBool(Location loc, Sign sign, bool value) : loc_{std::move(loc)}, sign_(sign), value_(value) {}
 
    [[nodiscard]] auto loc() const -> Location const & { return loc_; }
    [[nodiscard]] auto sign() const -> Sign { return sign_; }
    [[nodiscard]] auto value() const -> bool { return value_; }
 
  private:
    Location loc_;
    Sign sign_;
    bool value_;
};
 
class LitComparison : public Expression<LitComparison> {
  public:
    static constexpr auto attributes() {
        return std::tuple{a_loc = &LitComparison::loc_, a_sign = &LitComparison::sign_, a_lhs = &LitComparison::lhs_,
                          a_rhs = &LitComparison::rhs_};
    }
 
    explicit LitComparison(Location loc, Sign sign, Term lhs, GuardArray rhs)
        : loc_{std::move(loc)}, sign_(sign), 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 lhs() const -> Term const & { return lhs_; }
    [[nodiscard]] auto rhs() const -> GuardArray const & { return rhs_; }
 
  private:
    Location loc_;
    Sign sign_;
    Term lhs_;
    GuardArray rhs_;
};
 
class LitSymbolic : public Expression<LitSymbolic> {
  public:
    static constexpr auto attributes() {
        return std::tuple{a_loc = &LitSymbolic::loc_, a_sign = &LitSymbolic::sign_, a_term = &LitSymbolic::term_};
    }
 
    explicit LitSymbolic(Location loc, Sign sign, Term term)
        : loc_{std::move(loc)}, sign_(sign), term_(std::move(term)) {}
 
    [[nodiscard]] auto loc() const -> Location const & { return loc_; }
    [[nodiscard]] auto sign() const -> Sign { return sign_; }
    [[nodiscard]] auto term() const -> Term const & { return term_; }
 
  private:
    Location loc_;
    Sign sign_;
    Term term_;
};
 
using Lit = std::variant<LitBool, LitComparison, LitSymbolic>;
 
using LitArray = Util::immutable_array<Lit>;
 
class CondLit : public Expression<CondLit> {
  public:
    static constexpr auto attributes() {
        return std::tuple{a_loc = &CondLit::loc_, a_lit = &CondLit::lit_, a_cond = &CondLit::cond_};
    }
 
    explicit CondLit(Location loc, Lit lit, LitArray cond)
        : loc_{std::move(loc)}, lit_{std::move(lit)}, cond_{std::move(cond)} {}
    [[nodiscard]] auto loc() const -> Location const & { return loc_; }
    [[nodiscard]] auto lit() const -> Lit const & { return lit_; }
    [[nodiscard]] auto cond() const -> LitArray const & { return cond_; }
 
  private:
    Location loc_;
    Lit lit_;
    LitArray cond_;
};
 
 
} // namespace CppClingo::Input