statement.hh

#pragma once
 
#include <clingo/input/body_literal.hh>
#include <clingo/input/head_literal.hh>
 
#include <utility>
 
namespace CppClingo::Input {
 
 
class StmRule : public Expression<StmRule> {
  public:
    static constexpr auto attributes() {
        return std::tuple{a_loc = &StmRule::loc_, a_head = &StmRule::head_, a_body = &StmRule::body_};
    }
 
    explicit StmRule(Location loc, HdLit head, BdLitArray body)
        : loc_{std::move(loc)}, head_{std::move(head)}, body_{std::move(body)} {}
 
    [[nodiscard]] auto loc() const -> Location const & { return loc_; }
    [[nodiscard]] auto head() const -> HdLit const & { return head_; }
    [[nodiscard]] auto body() const -> BdLitArray const & { return body_; }
 
  private:
    Location loc_;
    HdLit head_;
    BdLitArray body_;
};
 
enum class TheoryOpType : uint8_t {
    unary,       
    binary_left, 
    binary_right 
};
 
class TheoryOpDefinition : public Expression<TheoryOpDefinition> {
  public:
    static constexpr auto attributes() {
        return std::tuple{a_loc = &TheoryOpDefinition::loc_, a_op = &TheoryOpDefinition::op,
                          a_prio = &TheoryOpDefinition::prio_, a_type = &TheoryOpDefinition::type_};
    }
 
    explicit TheoryOpDefinition(Location loc, String op, int prio, TheoryOpType type)
        : loc_{std::move(loc)}, op_{op}, prio_{prio}, type_{type} {}
 
    [[nodiscard]] auto loc() const -> Location const & { return loc_; }
    [[nodiscard]] auto op() const -> String const & { return *op_; }
    [[nodiscard]] auto prio() const -> int { return prio_; }
    [[nodiscard]] auto type() const -> TheoryOpType { return type_; }
 
  private:
    Location loc_;
    SharedString op_;
    int prio_;
    TheoryOpType type_;
};
 
using TheoryOpDefinitionArray = Util::immutable_array<TheoryOpDefinition>;
 
class TheoryTermDefinition : public Expression<TheoryTermDefinition> {
  public:
    static constexpr auto attributes() {
        return std::tuple{a_loc = &TheoryTermDefinition::loc_, a_name = &TheoryTermDefinition::name,
                          a_op_defs = &TheoryTermDefinition::op_defs_};
    }
 
    explicit TheoryTermDefinition(Location loc, String name, TheoryOpDefinitionArray op_defs)
        : loc_{std::move(loc)}, name_{name}, op_defs_{std::move(op_defs)} {}
 
    [[nodiscard]] auto loc() const -> Location const & { return loc_; }
    [[nodiscard]] auto name() const -> String const & { return *name_; }
    [[nodiscard]] auto op_defs() const -> TheoryOpDefinitionArray const & { return op_defs_; }
 
  private:
    Location loc_;
    SharedString name_;
    TheoryOpDefinitionArray op_defs_;
};
 
using TheoryTermDefinitionArray = Util::immutable_array<TheoryTermDefinition>;
 
enum class TheoryAtomType : uint8_t {
    head,     
    body,     
    any,      
    directive 
};
 
class TheoryRGuardDefinition : public Expression<TheoryRGuardDefinition> {
  public:
    static constexpr auto attributes() {
        return std::tuple{a_ops = &TheoryRGuardDefinition::ops, a_term = &TheoryRGuardDefinition::term_};
    }
    explicit TheoryRGuardDefinition(StringSpan ops, String term) : ops_{ops.begin(), ops.end()}, term_{term} {}
    explicit TheoryRGuardDefinition(SharedStringArray ops, String term) : ops_{std::move(ops)}, term_{term} {}
 
    [[nodiscard]] auto ops() const -> StringSpan { return as_string_span(ops_); }
    [[nodiscard]] auto term() const -> String const & { return *term_; }
 
  private:
    SharedStringArray ops_;
    SharedString term_;
};
 
class TheoryAtomDefinition : public Expression<TheoryAtomDefinition> {
  public:
    static constexpr auto attributes() {
        return std::tuple{a_loc = &TheoryAtomDefinition::loc_,     a_name = &TheoryAtomDefinition::name,
                          a_arity = &TheoryAtomDefinition::arity_, a_term = &TheoryAtomDefinition::term,
                          a_rhs = &TheoryAtomDefinition::rhs_,     a_type = &TheoryAtomDefinition::type_};
    }
 
    explicit TheoryAtomDefinition(Location loc, String name, int arity, String term,
                                  std::optional<TheoryRGuardDefinition> rhs, TheoryAtomType type)
        : loc_{std::move(loc)}, name_(name), arity_(arity), term_(term), rhs_(std::move(rhs)), type_(type) {}
 
    [[nodiscard]] auto loc() const -> Location const & { return loc_; }
    [[nodiscard]] auto name() const -> String const & { return *name_; }
    [[nodiscard]] auto arity() const -> int { return arity_; }
    [[nodiscard]] auto term() const -> String const & { return *term_; }
    [[nodiscard]] auto rhs() const -> std::optional<TheoryRGuardDefinition> const & { return rhs_; }
    [[nodiscard]] auto type() const -> TheoryAtomType { return type_; }
 
  private:
    Location loc_;
    SharedString name_;
    int arity_;
    SharedString term_;
    std::optional<TheoryRGuardDefinition> rhs_;
    TheoryAtomType type_;
};
 
using TheoryAtomDefinitionArray = Util::immutable_array<TheoryAtomDefinition>;
 
class StmTheory : public Expression<StmTheory> {
  public:
    static constexpr auto attributes() {
        return std::tuple{a_loc = &StmTheory::loc_, a_name = &StmTheory::name, a_term_defs = &StmTheory::term_defs_,
                          a_atom_defs = &StmTheory::atom_defs};
    }
 
    explicit StmTheory(Location loc, String name, TheoryTermDefinitionArray term_defs,
                       TheoryAtomDefinitionArray atom_defs)
        : loc_{std::move(loc)}, name_{name}, term_defs_{std::move(term_defs)}, atom_defs_{std::move(atom_defs)} {}
 
    [[nodiscard]] auto loc() const -> Location const & { return loc_; }
    [[nodiscard]] auto name() const -> String const & { return *name_; }
    [[nodiscard]] auto term_defs() const -> TheoryTermDefinitionArray const & { return term_defs_; }
    [[nodiscard]] auto atom_defs() const -> TheoryAtomDefinitionArray const & { return atom_defs_; }
 
  private:
    Location loc_;
    SharedString name_;
    TheoryTermDefinitionArray term_defs_;
    TheoryAtomDefinitionArray atom_defs_;
};
 
enum class OptimizeType : uint8_t { minimize, maximize };
 
class OptimizeTuple : public Expression<OptimizeTuple> {
  public:
    static constexpr auto attributes() {
        return std::tuple{a_weight = &OptimizeTuple::weight_, a_prio = &OptimizeTuple::prio_,
                          a_terms = &OptimizeTuple::terms_};
    }
 
    explicit OptimizeTuple(Term weight, std::optional<Term> priority, TermArray terms)
        : weight_{std::move(weight)}, prio_{std::move(priority)}, terms_{std::move(terms)} {}
 
    [[nodiscard]] auto weight() const -> Term const & { return weight_; }
    [[nodiscard]] auto prio() const -> std::optional<Term> const & { return prio_; }
    [[nodiscard]] auto terms() const -> TermArray const & { return terms_; }
 
  private:
    Term weight_;
    std::optional<Term> prio_;
    TermArray terms_;
};
 
class OptimizeElement : public Expression<OptimizeElement> {
  public:
    static constexpr auto attributes() {
        return std::tuple{a_tuple = &OptimizeElement::tuple_, a_cond = &OptimizeElement::cond_};
    }
 
    explicit OptimizeElement(OptimizeTuple tuple, LitArray cond) : tuple_{std::move(tuple)}, cond_{std::move(cond)} {}
 
    [[nodiscard]] auto tuple() const -> OptimizeTuple const & { return tuple_; }
    [[nodiscard]] auto cond() const -> LitArray const & { return cond_; }
 
  private:
    OptimizeTuple tuple_;
    LitArray cond_;
};
using OptimizeElementArray = Util::immutable_array<OptimizeElement>;
 
class StmOptimize : public Expression<StmOptimize> {
  public:
    static constexpr auto attributes() {
        return std::tuple{a_loc = &StmOptimize::loc_, a_type = &StmOptimize::type_, a_elems = &StmOptimize::elems_};
    }
 
    explicit StmOptimize(Location loc, OptimizeType type, OptimizeElementArray elems)
        : loc_{std::move(loc)}, type_{type}, elems_{std::move(elems)} {}
 
    [[nodiscard]] auto loc() const -> Location const & { return loc_; }
    [[nodiscard]] auto type() const -> OptimizeType { return type_; }
    [[nodiscard]] auto elems() const -> OptimizeElementArray const & { return elems_; }
 
  private:
    Location loc_;
    OptimizeType type_;
    OptimizeElementArray elems_;
};
 
class StmWeakConstraint : public Expression<StmWeakConstraint> {
  public:
    static constexpr auto attributes() {
        return std::tuple{a_loc = &StmWeakConstraint::loc_, a_body = &StmWeakConstraint::body_,
                          a_tuple = &StmWeakConstraint::tuple_};
    }
 
    explicit StmWeakConstraint(Location loc, BdLitArray body, OptimizeTuple tuple)
        : loc_{std::move(loc)}, body_{std::move(body)}, tuple_{std::move(tuple)} {}
 
    [[nodiscard]] auto loc() const -> Location const & { return loc_; }
    [[nodiscard]] auto body() const -> BdLitArray const & { return body_; }
    [[nodiscard]] auto tuple() const -> OptimizeTuple const & { return tuple_; }
 
  private:
    Location loc_;
    BdLitArray body_;
    OptimizeTuple tuple_;
};
 
class StmShow : public Expression<StmShow> {
  public:
    static constexpr auto attributes() {
        return std::tuple{a_loc = &StmShow::loc_, a_term = &StmShow::term_, a_body = &StmShow::body_};
    }
 
    explicit StmShow(Location loc, Term term, BdLitArray body)
        : loc_{std::move(loc)}, term_(std::move(term)), body_(std::move(body)) {}
 
    [[nodiscard]] auto loc() const -> Location const & { return loc_; }
    [[nodiscard]] auto term() const -> Term const & { return term_; }
    [[nodiscard]] auto body() const -> BdLitArray const & { return body_; }
 
  private:
    Location loc_;
    Term term_;
    BdLitArray body_;
};
 
class StmShowSig : public Expression<StmShowSig> {
  public:
    static constexpr auto attributes() {
        return std::tuple{a_loc = &StmShowSig::loc_, a_name = &StmShowSig::name, a_sign = &StmShowSig::sign_,
                          a_arity = &StmShowSig::arity_};
    }
 
    explicit StmShowSig(Location loc, bool sign, String name, int arity)
        : loc_{std::move(loc)}, name_{name}, arity_{arity}, sign_{sign} {}
 
    [[nodiscard]] auto loc() const -> Location const & { return loc_; }
    [[nodiscard]] auto sign() const -> bool { return sign_; }
    [[nodiscard]] auto name() const -> String const & { return *name_; }
    [[nodiscard]] auto arity() const -> int { return arity_; }
 
  private:
    Location loc_;
    SharedString name_;
    int arity_;
    bool sign_;
};
 
class StmShowNothing : public Expression<StmShowNothing> {
  public:
    static constexpr auto attributes() { return std::tuple{a_loc = &StmShowNothing::loc_}; }
 
    explicit StmShowNothing(Location loc) : loc_{std::move(loc)} {}
 
    [[nodiscard]] auto loc() const -> Location const & { return loc_; }
 
  private:
    Location loc_;
};
 
class StmProject : public Expression<StmProject> {
  public:
    static constexpr auto attributes() {
        return std::tuple{a_loc = &StmProject::loc_, a_atom = &StmProject::atom_, a_body = &StmProject::body_};
    }
 
    explicit StmProject(Location loc, Term atom, BdLitArray body)
        : loc_{std::move(loc)}, atom_(std::move(atom)), body_(std::move(body)) {}
 
    [[nodiscard]] auto loc() const -> Location const & { return loc_; }
    [[nodiscard]] auto atom() const -> Term const & { return atom_; }
    [[nodiscard]] auto body() const -> BdLitArray const & { return body_; }
 
  private:
    Location loc_;
    Term atom_;
    BdLitArray body_;
};
 
class StmProjectSig : public Expression<StmProjectSig> {
  public:
    static constexpr auto attributes() {
        return std::tuple{a_loc = &StmProjectSig::loc_, a_name = &StmProjectSig::name, a_sign = &StmProjectSig::sign_,
                          a_arity = &StmProjectSig::arity_};
    }
 
    explicit StmProjectSig(Location loc, bool sign, String name, int arity)
        : loc_{std::move(loc)}, sign_{sign}, name_{name}, arity_{arity} {}
 
    [[nodiscard]] auto loc() const -> Location const & { return loc_; }
    [[nodiscard]] auto sign() const -> bool { return sign_; }
    [[nodiscard]] auto name() const -> String const & { return *name_; }
    [[nodiscard]] auto arity() const -> int { return arity_; }
 
  private:
    Location loc_;
    bool sign_;
    SharedString name_;
    int arity_;
};
 
class StmDefined : public Expression<StmDefined> {
  public:
    static constexpr auto attributes() {
        return std::tuple{a_loc = &StmDefined::loc_, a_name = &StmDefined::name, a_sign = &StmDefined::sign_,
                          a_arity = &StmDefined::arity_};
    }
 
    explicit StmDefined(Location loc, bool sign, String name, int arity)
        : loc_{std::move(loc)}, sign_{sign}, name_{name}, arity_{arity} {}
 
    [[nodiscard]] auto loc() const -> Location const & { return loc_; }
    [[nodiscard]] auto sign() const -> bool { return sign_; }
    [[nodiscard]] auto name() const -> String const & { return *name_; }
    [[nodiscard]] auto arity() const -> int { return arity_; }
 
  private:
    Location loc_;
    bool sign_;
    SharedString name_;
    int arity_;
};
 
class StmExternal : public Expression<StmExternal> {
  public:
    static constexpr auto attributes() {
        return std::tuple{a_loc = &StmExternal::loc_, a_atom = &StmExternal::atom_, a_body = &StmExternal::body_,
                          a_type = &StmExternal::type_};
    }
 
    explicit StmExternal(Location loc, Term atom, BdLitArray body, std::optional<Term> type = std::nullopt)
        : loc_{std::move(loc)}, atom_(std::move(atom)), body_(std::move(body)), type_{std::move(type)} {}
 
    [[nodiscard]] auto loc() const -> Location const & { return loc_; }
    [[nodiscard]] auto atom() const -> Term const & { return atom_; }
    [[nodiscard]] auto body() const -> BdLitArray const & { return body_; }
    [[nodiscard]] auto type() const -> std::optional<Term> const & { return type_; }
 
  private:
    Location loc_;
    Term atom_;
    BdLitArray body_;
    std::optional<Term> type_;
};
 
class Edge : public Expression<Edge> {
  public:
    static constexpr auto attributes() { return std::tuple{a_src = &Edge::src_, a_dst = &Edge::dst_}; }
 
    explicit Edge(Term src, Term dst) : src_{std::move(src)}, dst_{std::move(dst)} {}
 
    [[nodiscard]] auto src() const -> Term const & { return src_; }
    [[nodiscard]] auto dst() const -> Term const & { return dst_; }
 
  private:
    Term src_;
    Term dst_;
};
using EdgeArray = Util::immutable_array<Edge>;
 
class StmEdge : public Expression<StmEdge> {
  public:
    static constexpr auto attributes() {
        return std::tuple{a_loc = &StmEdge::loc_, a_edges = &StmEdge::edges_, a_body = &StmEdge::body_};
    }
 
    explicit StmEdge(Location loc, EdgeArray edges, BdLitArray body = {})
        : loc_{std::move(loc)}, edges_{std::move(edges)}, body_{std::move(body)} {}
 
    [[nodiscard]] auto loc() const -> Location const & { return loc_; }
    [[nodiscard]] auto edges() const -> EdgeArray const & { return edges_; }
    [[nodiscard]] auto body() const -> BdLitArray const & { return body_; }
 
  private:
    Location loc_;
    EdgeArray edges_;
    BdLitArray body_;
};
 
class StmHeuristic : public Expression<StmHeuristic> {
  public:
    static constexpr auto attributes() {
        return std::tuple{a_loc = &StmHeuristic::loc_,   a_atom = &StmHeuristic::atom_,
                          a_body = &StmHeuristic::body_, a_weight = &StmHeuristic::weight_,
                          a_prio = &StmHeuristic::prio_, a_type = &StmHeuristic::type_};
    }
 
    explicit StmHeuristic(Location loc, Term atom, BdLitArray body, Term weight, std::optional<Term> prio, Term type)
        : loc_{std::move(loc)}, atom_{std::move(atom)}, body_{std::move(body)}, weight_(std::move(weight)),
          prio_(std::move(prio)), type_(std::move(type)) {}
    explicit StmHeuristic(Location loc, Term atom, BdLitArray body, Term weight, Term prio, Term type)
        : StmHeuristic{
              std::move(loc), std::move(atom), std::move(body), std::move(weight), std::make_optional(std::move(prio)),
              std::move(type)} {}
    explicit StmHeuristic(Location loc, Term atom, BdLitArray body, Term weight, Term type)
        : StmHeuristic{std::move(loc),    std::move(atom), std::move(body),
                       std::move(weight), std::nullopt,    std::move(type)} {}
 
    [[nodiscard]] auto loc() const -> Location const & { return loc_; }
    [[nodiscard]] auto atom() const -> Term const & { return atom_; }
    [[nodiscard]] auto body() const -> BdLitArray const & { return body_; }
    [[nodiscard]] auto weight() const -> Term const & { return weight_; }
    [[nodiscard]] auto prio() const -> std::optional<Term> const & { return prio_; }
    [[nodiscard]] auto type() const -> Term const & { return type_; }
 
  private:
    Location loc_;
    Term atom_;
    BdLitArray body_;
    Term weight_;
    std::optional<Term> prio_;
    Term type_;
};
 
class StmScript : public Expression<StmScript> {
  public:
    static constexpr auto attributes() {
        return std::tuple{a_loc = &StmScript::loc_, a_type = &StmScript::type, a_value = &StmScript::value};
    }
 
    explicit StmScript(Location loc, String type, String value) : loc_{std::move(loc)}, type_(type), value_(value) {}
 
    [[nodiscard]] auto loc() const -> Location const & { return loc_; }
    [[nodiscard]] auto type() const -> String const & { return *type_; }
    [[nodiscard]] auto value() const -> String const & { return *value_; }
 
  private:
    Location loc_;
    SharedString type_;
    SharedString value_;
};
 
enum class IncludeType : uint8_t {
    system,  
    inbuild, 
};
 
class StmInclude : public Expression<StmInclude> {
  public:
    static constexpr auto attributes() {
        return std::tuple{a_loc = &StmInclude::loc_, a_type = &StmInclude::type_, a_value = &StmInclude::value};
    }
 
    explicit StmInclude(Location loc, IncludeType type, String value)
        : loc_{std::move(loc)}, type_(type), value_(value) {}
 
    [[nodiscard]] auto loc() const -> Location const & { return loc_; }
    [[nodiscard]] auto type() const -> IncludeType { return type_; }
    [[nodiscard]] auto value() const -> String const & { return *value_; }
 
  private:
    Location loc_;
    IncludeType type_;
    SharedString value_;
};
 
class StmProgram : public Expression<StmProgram> {
  public:
    static constexpr auto attributes() {
        return std::tuple{a_loc = &StmProgram::loc_, a_name = &StmProgram::name, a_args = &StmProgram::args};
    }
 
    explicit StmProgram(Location loc, String name, StringSpan args)
        : loc_{std::move(loc)}, name_(name), args_{args.begin(), args.end()} {}
    explicit StmProgram(Location loc, String name, SharedStringArray args)
        : loc_{std::move(loc)}, name_(name), args_{std::move(args)} {}
 
    [[nodiscard]] auto loc() const -> Location const & { return loc_; }
    [[nodiscard]] auto name() const -> String const & { return *name_; }
    [[nodiscard]] auto args() const -> StringSpan { return as_string_span(args_); }
 
  private:
    Location loc_;
    SharedString name_;
    SharedStringArray args_;
};
 
enum class Precedence : uint8_t {
    default_, 
    override_ 
};
 
class StmConst : public Expression<StmConst> {
  public:
    static constexpr auto attributes() {
        return std::tuple{a_loc = &StmConst::loc_, a_type = &StmConst::type_, a_name = &StmConst::name,
                          a_value = &StmConst::value_};
    }
 
    explicit StmConst(Location loc, Precedence type, String name, Term value)
        : loc_{std::move(loc)}, type_(type), name_(name), value_(std::move(value)) {}
 
    [[nodiscard]] auto loc() const -> Location const & { return loc_; }
    [[nodiscard]] auto type() const -> Precedence const & { return type_; }
    [[nodiscard]] auto name() const -> String const & { return *name_; }
    [[nodiscard]] auto value() const -> Term const & { return value_; }
 
  private:
    Location loc_;
    Precedence type_;
    SharedString name_;
    Term value_;
};
 
using ProgramParam = std::pair<SharedString, std::vector<SharedSymbol>>;
using ProgramParamVec = std::vector<ProgramParam>;
 
class StmParts : public Expression<StmParts> {
  public:
    static constexpr auto attributes() {
        return std::tuple{a_loc = &StmParts::loc_, a_type = &StmParts::type_, a_elems = &StmParts::elems_};
    }
 
    explicit StmParts(Location loc, Precedence type, ProgramParamVec elems)
        : loc_{std::move(loc)}, type_(type), elems_(std::move(elems)) {}
 
    [[nodiscard]] auto loc() const -> Location const & { return loc_; }
    [[nodiscard]] auto type() const -> Precedence const & { return type_; }
    [[nodiscard]] auto elems() const -> ProgramParamVec const & { return elems_; }
 
  private:
    Location loc_;
    Precedence type_;
    ProgramParamVec elems_;
};
 
enum class CommentType : uint8_t {
    line,  
    block, 
};
 
class StmComment : public Expression<StmComment> {
  public:
    static constexpr auto attributes() {
        return std::tuple{a_loc = &StmComment::loc_, a_type = &StmComment::type_, a_value = &StmComment::value};
    }
 
    explicit StmComment(Location loc, CommentType type, String value)
        : loc_{std::move(loc)}, type_{type}, value_{value} {}
 
    [[nodiscard]] auto loc() const -> Location const & { return loc_; }
    [[nodiscard]] auto type() const -> CommentType { return type_; }
    [[nodiscard]] auto value() const -> String const & { return *value_; }
 
  private:
    Location loc_;
    CommentType type_;
    SharedString value_;
};
 
using Stm = std::variant<StmRule, StmTheory, StmOptimize, StmWeakConstraint, StmShow, StmShowNothing, StmShowSig,
                         StmProject, StmProjectSig, StmDefined, StmExternal, StmEdge, StmHeuristic, StmScript,
                         StmInclude, StmProgram, StmConst, StmParts, StmComment>;
using StmVec = std::vector<Stm>;
 
 
} // namespace CppClingo::Input