term.hh

#pragma once
 
#include <clingo/input/attributes.hh>
 
#include <clingo/core/fstring.hh>
#include <clingo/core/location.hh>
#include <clingo/core/symbol.hh>
 
#include <clingo/util/hash.hh>
#include <clingo/util/immutable_array.hh>
#include <clingo/util/immutable_value.hh>
#include <clingo/util/optional.hh>
#include <clingo/util/ordered_set.hh>
 
#include <utility>
#include <variant>
 
namespace CppClingo::Input {
 
 
using VariableSet = StringSet;
using VariableVec = StringVec;
 
using CppClingo::location;
 
class TermVariable;
class TermSymbol;
class TermTuple;
class TermFunction;
class TermAbs;
class TermUnary;
class TermBinary;
class TermFormatString;
 
using Sig = std::tuple<String, size_t, bool>;
using SharedSig = std::tuple<SharedString, size_t, bool>;
using SharedSigSet = Util::ordered_set<SharedSig>;
 
using Term =
    std::variant<TermVariable, TermSymbol, TermTuple, TermFunction, TermAbs, TermUnary, TermBinary, TermFormatString>;
 
using TermArray = Util::immutable_array<Term>;
 
class Projection : public Expression<Projection> {
  public:
    static constexpr auto attributes() { return std::tuple{a_loc = &Projection::loc_}; }
 
    explicit Projection(Location loc) : loc_{std::move(loc)} {}
    [[nodiscard]] auto loc() const -> Location const & { return loc_; }
 
  private:
    Location loc_;
};
 
using Argument = std::variant<Projection, Term>;
using ArgumentArray = Util::immutable_array<Argument>;
 
class ArgumentTuple : public RecursiveExpression<ArgumentTuple> {
  public:
    static constexpr auto attributes() { return std::tuple{a_elems = &ArgumentTuple::elems_}; }
 
    ArgumentTuple(ArgumentArray elems);
 
    [[nodiscard]] auto elems() const -> ArgumentArray const & { return elems_; }
 
  private:
    ArgumentArray elems_;
};
 
using PoolArray = Util::immutable_array<ArgumentTuple>;
 
class TermVariable : public Expression<TermVariable> {
  public:
    static constexpr auto attributes() {
        return std::tuple{a_loc = &TermVariable::loc_, a_name = &TermVariable::name,
                          a_anonymous = &TermVariable::anonymous_};
    }
 
    explicit TermVariable(Location loc, String name, bool is_anonymous = false)
        : loc_{std::move(loc)}, name_{name}, anonymous_{is_anonymous} {}
 
    [[nodiscard]] auto loc() const -> Location const & { return loc_; }
    [[nodiscard]] auto name() const -> String const & { return *name_; }
    [[nodiscard]] auto anonymous() const -> bool { return anonymous_; }
 
  private:
    Location loc_;
    SharedString name_;
    bool anonymous_;
};
 
class TermSymbol : public Expression<TermSymbol> {
  public:
    static constexpr auto attributes() { return std::tuple{a_loc = &TermSymbol::loc_, a_value = &TermSymbol::value}; }
 
    explicit TermSymbol(Location loc, Symbol value) : loc_{std::move(loc)}, value_{value} {}
 
    [[nodiscard]] auto loc() const -> Location const & { return loc_; }
    [[nodiscard]] auto value() const -> Symbol const & { return *value_; }
 
  private:
    Location loc_;
    SharedSymbol value_;
};
 
class FormatFieldExpression : public RecursiveExpression<FormatFieldExpression> {
  public:
    static constexpr auto attributes() {
        return std::tuple{a_loc = &FormatFieldExpression::loc_, a_lhs = &FormatFieldExpression::lhs_,
                          a_rhs = &FormatFieldExpression::rhs_};
    }
 
    explicit FormatFieldExpression(Location loc, Util::immutable_value<Term> lhs, FormatSpec rhs);
 
    [[nodiscard]] auto loc() const -> Location const & { return loc_; }
    [[nodiscard]] auto lhs() const -> Util::immutable_value<Term> const & { return lhs_; }
    [[nodiscard]] auto rhs() const -> FormatSpec const & { return rhs_; }
    [[nodiscard]] auto rhs_str() const -> std::string_view {
        if (rhs_view_ == "i") {
            Util::OutputBuffer out;
            out << rhs_;
            rhs_view_ = out.str();
        }
        return rhs_view_;
    }
 
  private:
    Location loc_;
    Util::immutable_value<Term> lhs_;
    FormatSpec rhs_;
    mutable std::string rhs_view_ = "i";
};
 
class FormatFieldLiteral : public Expression<FormatFieldLiteral> {
  public:
    explicit FormatFieldLiteral(Location loc, SharedString value) : loc_{std::move(loc)}, value_{std::move(value)} {}
 
    static constexpr auto attributes() {
        return std::tuple{a_loc = &FormatFieldLiteral::loc_, a_value = &FormatFieldLiteral::value_};
    }
 
    [[nodiscard]] auto loc() const -> Location const & { return loc_; }
    [[nodiscard]] auto value() const -> String const & { return *value_; }
 
  private:
    Location loc_;
    SharedString value_;
};
 
using FormatField = std::variant<FormatFieldLiteral, FormatFieldExpression>;
 
using FormatFieldArray = Util::immutable_array<FormatField>;
 
class TermFormatString : public Expression<TermFormatString> {
  public:
    static constexpr auto attributes() {
        return std::tuple{a_loc = &TermFormatString::loc_, a_elems = &TermFormatString::elems};
    }
 
    explicit TermFormatString(Location loc, FormatFieldArray elems) : loc_{std::move(loc)}, elems_{std::move(elems)} {}
    [[nodiscard]] auto loc() const -> Location const & { return loc_; }
    [[nodiscard]] auto elems() const -> FormatFieldArray const & { return elems_; }
 
  private:
    Location loc_;
    FormatFieldArray elems_;
};
 
using TupleElement = std::variant<ArgumentTuple, Term>;
using TupleElementArray = Util::immutable_array<TupleElement>;
 
class TermTuple : public RecursiveExpression<TermTuple> {
  public:
    static constexpr auto attributes() { return std::tuple{a_loc = &TermTuple::loc_, a_pool = &TermTuple::pool_}; }
 
    explicit TermTuple(Location loc, TupleElementArray pool);
 
    [[nodiscard]] auto loc() const -> Location const & { return loc_; }
    [[nodiscard]] auto pool() const -> TupleElementArray const & { return pool_; }
 
  private:
    Location loc_;
    TupleElementArray pool_;
};
 
class TermFunction : public RecursiveExpression<TermFunction> {
  public:
    static constexpr auto attributes() {
        return std::tuple{a_loc = &TermFunction::loc_, a_name = &TermFunction::name, a_pool = &TermFunction::pool_,
                          a_external = &TermFunction::external_};
    }
 
    explicit TermFunction(Location loc, String name, PoolArray pool, bool external);
 
    [[nodiscard]] auto loc() const -> Location const & { return loc_; }
    [[nodiscard]] auto name() const -> String const & { return *name_; }
    [[nodiscard]] auto pool() const -> PoolArray const & { return pool_; }
    [[nodiscard]] auto external() const -> bool { return external_; }
 
  private:
    Location loc_;
    SharedString name_;
    PoolArray pool_;
    bool external_;
};
 
class TermAbs : public RecursiveExpression<TermAbs> {
  public:
    static constexpr auto attributes() { return std::tuple{a_loc = &TermAbs::loc_, a_pool = &TermAbs::pool_}; }
 
    explicit TermAbs(Location loc, TermArray pool);
 
    [[nodiscard]] auto loc() const -> Location const & { return loc_; }
    [[nodiscard]] auto pool() const -> TermArray const & { return pool_; }
 
    friend auto operator==(TermAbs const &a, TermAbs const &b) -> bool;
    friend auto operator<=>(TermAbs const &a, TermAbs const &b) -> std::strong_ordering;
 
  private:
    Location loc_;
    TermArray pool_;
};
 
enum class UnaryOperator : uint8_t {
    minus,  
    negate, 
};
 
class TermUnary : public RecursiveExpression<TermUnary> {
  public:
    static constexpr auto attributes() {
        return std::tuple{a_loc = &TermUnary::loc_, a_op = &TermUnary::op_, a_rhs = &TermUnary::rhs_};
    }
 
    explicit TermUnary(Location loc, UnaryOperator op, Util::immutable_value<Term> rhs);
 
    [[nodiscard]] auto loc() const -> Location const & { return loc_; }
    [[nodiscard]] auto op() const -> UnaryOperator { return op_; }
    [[nodiscard]] auto rhs() const -> Util::immutable_value<Term> const & { return rhs_; }
 
  private:
    Location loc_;
    UnaryOperator op_;
    Util::immutable_value<Term> rhs_;
};
 
enum class BinaryOperator : uint8_t {
    and_,  
    div,   
    minus, 
    mod,   
    times, 
    or_,   
    plus,  
    pow,   
    xor_,  
    dots,  
};
 
class TermBinary : public RecursiveExpression<TermBinary> {
  public:
    static constexpr auto attributes() {
        return std::tuple{a_loc = &TermBinary::loc_, a_lhs = &TermBinary::lhs_, a_op = &TermBinary::op_,
                          a_rhs = &TermBinary::rhs_};
    }
 
    explicit TermBinary(Location loc, Util::immutable_value<Term> lhs, BinaryOperator op,
                        Util::immutable_value<Term> rhs);
 
    [[nodiscard]] auto loc() const -> Location const & { return loc_; }
    [[nodiscard]] auto lhs() const -> Util::immutable_value<Term> const & { return lhs_; }
    [[nodiscard]] auto rhs() const -> Util::immutable_value<Term> const & { return rhs_; }
    [[nodiscard]] auto op() const -> BinaryOperator { return op_; }
 
  private:
    Location loc_;
    Util::immutable_value<Term> lhs_;
    Util::immutable_value<Term> rhs_;
    BinaryOperator op_;
};
 
 
// FormatField
 
inline FormatFieldExpression::FormatFieldExpression(Location loc, Util::immutable_value<Term> lhs, FormatSpec rhs)
    : loc_{std::move(loc)}, lhs_{std::move(lhs)}, rhs_{std::move(rhs)} {
}
 
inline auto operator==(FormatFieldExpression const &a, FormatFieldExpression const &b) -> bool {
    return a.equal(b);
}
 
inline auto operator<=>(FormatFieldExpression const &a, FormatFieldExpression const &b) -> std::strong_ordering {
    return a.compare(b);
}
 
// ArgumentTuple
 
inline ArgumentTuple::ArgumentTuple(ArgumentArray elems) : elems_{std::move(elems)} {
}
 
inline auto operator==(ArgumentTuple const &a, ArgumentTuple const &b) -> bool {
    return a.equal(b);
}
 
inline auto operator<=>(ArgumentTuple const &a, ArgumentTuple const &b) -> std::strong_ordering {
    return a.compare(b);
}
 
// TermTuple
 
inline TermTuple::TermTuple(Location loc, TupleElementArray pool) : loc_{std::move(loc)}, pool_{std::move(pool)} {
}
 
inline auto operator==(TermTuple const &a, TermTuple const &b) -> bool {
    return a.equal(b);
}
 
inline auto operator<=>(TermTuple const &a, TermTuple const &b) -> std::strong_ordering {
    return a.compare(b);
}
 
// TermFunction
 
inline TermFunction::TermFunction(Location loc, String name, PoolArray pool, bool external)
    : loc_{std::move(loc)}, name_(name), pool_{std::move(pool)}, external_{external} {
}
 
inline auto operator==(TermFunction const &a, TermFunction const &b) -> bool {
    return a.equal(b);
}
 
inline auto operator<=>(TermFunction const &a, TermFunction const &b) -> std::strong_ordering {
    return a.compare(b);
}
 
// TermAbs
 
inline TermAbs::TermAbs(Location loc, TermArray pool) : loc_{std::move(loc)}, pool_{std::move(pool)} {
}
 
inline auto operator==(TermAbs const &a, TermAbs const &b) -> bool {
    return a.equal(b);
}
 
inline auto operator<=>(TermAbs const &a, TermAbs const &b) -> std::strong_ordering {
    return a.compare(b);
}
 
// TermUnary
 
inline TermUnary::TermUnary(Location loc, UnaryOperator op, Util::immutable_value<Term> rhs)
    : loc_{std::move(loc)}, op_{op}, rhs_{std::move(rhs)} {
}
 
inline auto operator==(TermUnary const &a, TermUnary const &b) -> bool {
    return a.equal(b);
}
 
inline auto operator<=>(TermUnary const &a, TermUnary const &b) -> std::strong_ordering {
    return a.compare(b);
}
 
// TermBinary
 
inline TermBinary::TermBinary(Location loc, Util::immutable_value<Term> lhs, BinaryOperator op,
                              Util::immutable_value<Term> rhs)
    : loc_{std::move(loc)}, lhs_{std::move(lhs)}, rhs_{std::move(rhs)}, op_{op} {
}
 
inline auto operator==(TermBinary const &a, TermBinary const &b) -> bool {
    return a.equal(b);
}
 
inline auto operator<=>(TermBinary const &a, TermBinary const &b) -> std::strong_ordering {
    return a.compare(b);
}
 
} // namespace CppClingo::Input