symbol.hh

#pragma once
 
#include <clingo/core/number.hh>
 
#include <clingo/util/hash.hh>
#include <clingo/util/print.hh>
#include <clingo/util/unordered_set.hh>
 
#include <ostream>
#include <span>
 
namespace CppClingo {
 
 
class String {
  public:
    constexpr String() = default;
 
    void acquire() const noexcept;
    void release() const noexcept;
 
    static auto to_rep(String str) noexcept -> uint64_t { return static_cast<uint64_t>(str.rep_); }
    static auto from_rep(uint64_t rep) noexcept -> String { return String{static_cast<uintptr_t>(rep)}; }
 
    [[nodiscard]] auto c_str() const -> const char *;
    [[nodiscard]] auto view() const -> std::string_view;
    [[nodiscard]] auto data() const -> const char *;
    [[nodiscard]] auto empty() const -> bool;
    [[nodiscard]] auto size() const -> size_t;
    [[nodiscard]] auto starts_with(std::string_view prefix) const -> bool;
 
    [[nodiscard]] auto hash() const -> size_t;
 
    friend auto operator==(String a, String b) -> bool { return a.rep_ == b.rep_; }
    friend auto operator==(String a, std::string_view b) -> bool { return a.view() == b; }
    friend auto operator==(std::string_view a, String b) -> bool { return a == b.view(); }
 
    friend auto operator<=>(String a, String b) -> std::strong_ordering { return a.view() <=> b.view(); }
    friend auto operator<=>(std::string_view a, String b) -> std::strong_ordering { return a <=> b.view(); }
    friend auto operator<=>(String a, std::string_view b) -> std::strong_ordering { return a.view() <=> b; }
 
    friend auto operator<<(std::ostream &out, String const &str) -> std::ostream &;
 
    friend auto operator<<(Util::OutputBuffer &out, String const &str) -> Util::OutputBuffer &;
 
  private:
    constexpr String(uintptr_t rep) noexcept : rep_{rep} {}
    uintptr_t rep_ = 0;
};
 
using StringSet = Util::unordered_set<String>;
using StringVec = std::vector<String>;
using StringSpan = std::span<String const>;
 
class SharedString {
  public:
    constexpr SharedString() = default;
    explicit SharedString(String ref, bool acquire = true) noexcept : ref_{ref} {
        if (acquire) {
            ref.acquire();
        }
    }
    ~SharedString() { ref_.release(); }
    SharedString(SharedString const &other) noexcept : ref_{other.ref_} { ref_.acquire(); }
    SharedString(SharedString &&other) noexcept { std::swap(other.ref_, ref_); }
    auto operator=(SharedString const &other) noexcept -> SharedString & {
        if (&other != this) {
            ref_.release();
            ref_ = other.ref_;
            ref_.acquire();
        }
        return *this;
    }
    auto operator=(SharedString &&other) noexcept -> SharedString & {
        if (&other != this) {
            ref_.release();
            ref_ = other.ref_;
            other.ref_ = String::from_rep(0);
        }
        return *this;
    }
    [[nodiscard]] auto get() const -> String const & { return ref_; }
    [[nodiscard]] auto operator*() const -> String const & { return ref_; }
    [[nodiscard]] auto operator->() const -> String const * { return &ref_; }
    [[nodiscard]] static auto to_rep(SharedString sym) -> uint64_t {
        auto ret = std::exchange(sym.ref_, String{});
        return String::to_rep(ret);
    }
    [[nodiscard]] static auto from_rep(uint64_t repr) -> SharedString {
        return SharedString{String::from_rep(repr), false};
    }
 
    [[nodiscard]] auto hash() const -> size_t { return CppClingo::Util::value_hash(ref_); }
 
    friend auto operator==(SharedString const &a, SharedString const &b) -> bool { return a.ref_ == b.get(); }
    friend auto operator==(SharedString const &a, String const &b) -> bool { return a.ref_ == b; }
    friend auto operator==(String const &a, SharedString const &b) -> bool { return a == b.get(); }
    friend auto operator==(std::string_view a, SharedString const &b) -> bool { return a == b->view(); }
    friend auto operator==(SharedString const &a, std::string_view b) -> bool { return a->view() == b; }
 
    friend auto operator<=>(SharedString const &a, SharedString const &b) -> std::strong_ordering {
        return a.get() <=> b.get();
    }
    friend auto operator<=>(SharedString const &a, String const &b) -> std::strong_ordering { return a.get() <=> b; }
    friend auto operator<=>(String const &a, SharedString const &b) -> std::strong_ordering { return a <=> b.get(); }
    friend auto operator<=>(std::string_view a, SharedString const &b) -> std::strong_ordering {
        return a <=> b->view();
    }
    friend auto operator<=>(SharedString const &a, std::string_view b) -> std::strong_ordering {
        return a->view() <=> b;
    }
 
  private:
    String ref_;
};
 
using SharedStringSet = Util::unordered_set<SharedString>;
using SharedStringVec = std::vector<SharedString>;
using SharedStringArray = Util::immutable_array<SharedString>;
using SharedStringSpan = std::span<SharedString const>;
 
inline auto as_string_ptr(SharedString const *ptr) -> String const * {
    // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
    return reinterpret_cast<String const *>(ptr);
}
 
template <class T> inline auto as_string_span(T const &vec) -> StringSpan {
    return {as_string_ptr(vec.data()), vec.size()};
}
 
inline auto as_shared_string_ptr(String const *ptr) -> SharedString const * {
    // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
    return reinterpret_cast<SharedString const *>(ptr);
}
 
template <class T> inline auto as_shared_string_span(T const &vec) -> SharedStringSpan {
    return {as_shared_string_ptr(vec.data()), vec.size()};
}
 
enum class SymbolType : uint8_t { number, sup, inf, string, tuple, function };
 
class Symbol;
using SymbolSpan = std::span<Symbol const>;
using SymbolVec = std::vector<Symbol>;
using Assignment = std::vector<std::optional<Symbol>>;
 
class Symbol {
  public:
    constexpr Symbol() = default;
    [[nodiscard]] auto type() const noexcept -> SymbolType;
    [[nodiscard]] auto num() const noexcept -> Number const &;
    [[nodiscard]] auto str() const noexcept -> String;
    [[nodiscard]] auto name() const noexcept -> String;
    [[nodiscard]] auto args() const noexcept -> SymbolSpan;
    [[nodiscard]] auto flip_classical_sign() const -> std::optional<Symbol>;
    [[nodiscard]] auto has_sign() const -> bool;
    [[nodiscard]] auto has_classical_sign() const -> bool;
 
    [[nodiscard]] auto hash() const -> size_t { return CppClingo::Util::value_hash(rep_); }
 
    [[nodiscard]] auto signature() const -> std::optional<std::tuple<String, size_t, bool>>;
 
    friend auto compare(Symbol const &a, Symbol const &b) -> int;
    friend auto compare(Number const &a, Symbol const &b) -> int;
    friend auto compare(Symbol const &a, Number const &b) -> int;
 
    friend auto operator==(Symbol const &a, Symbol const &b) -> bool { return a.rep_ == b.rep_; }
    friend auto operator==(Number const &a, Symbol const &b) -> bool { return Number::to_repr(a) == b.rep_; }
    friend auto operator==(Symbol const &a, Number const &b) -> bool { return a.rep_ == Number::to_repr(b); }
 
    friend auto operator<=>(Symbol const &a, Symbol const &b) -> std::strong_ordering { return compare(a, b) <=> 0; }
    friend auto operator<=>(Number const &a, Symbol const &b) -> std::strong_ordering { return compare(a, b) <=> 0; }
    friend auto operator<=>(Symbol const &a, Number const &b) -> std::strong_ordering { return compare(a, b) <=> 0; }
 
    static auto to_rep(Symbol sym) noexcept -> uint64_t { return sym.rep_; }
    static auto from_rep(uint64_t rep) noexcept -> Symbol { return Symbol{rep}; }
 
    void acquire() const noexcept;
    void release() const noexcept;
 
    friend auto operator<<(std::ostream &out, Symbol const &sym) -> std::ostream &;
 
    friend auto operator<<(Util::OutputBuffer &out, Symbol const &sym) -> Util::OutputBuffer &;
 
  private:
    Symbol(uint64_t repr) noexcept : rep_{repr} {}
    uint64_t rep_ = 0;
};
 
class SharedSymbol {
  public:
    constexpr SharedSymbol() noexcept = default;
    explicit SharedSymbol(Symbol sym, bool acquire = true) noexcept : ref_{sym} {
        if (acquire) {
            ref_.acquire();
        }
    }
    ~SharedSymbol() { ref_.release(); }
    SharedSymbol(SharedSymbol const &sym) noexcept : ref_{sym.ref_} { ref_.acquire(); }
    SharedSymbol(SharedSymbol &&sym) noexcept { std::swap(sym.ref_, ref_); }
    auto operator=(SharedSymbol const &sym) noexcept -> SharedSymbol & {
        if (&sym != this) {
            ref_.release();
            ref_ = sym.ref_;
            ref_.acquire();
        }
        return *this;
    }
    auto operator=(SharedSymbol &&sym) noexcept -> SharedSymbol & {
        if (&sym != this) {
            ref_.release();
            ref_ = sym.ref_;
            sym.ref_ = Symbol::from_rep(0);
        }
        return *this;
    }
    [[nodiscard]] auto get() const -> Symbol const & { return ref_; }
    [[nodiscard]] auto operator*() const -> Symbol const & { return ref_; }
    [[nodiscard]] auto operator->() const -> Symbol const * { return &ref_; }
    [[nodiscard]] static auto to_rep(SharedSymbol const &sym) -> uint64_t {
        sym.ref_.acquire();
        return Symbol::to_rep(sym.ref_);
    }
    [[nodiscard]] static auto from_rep(uint64_t repr) -> SharedSymbol {
        auto ret = SharedSymbol();
        ret.ref_ = Symbol::from_rep(repr);
        return ret;
    }
 
    [[nodiscard]] auto hash() const -> size_t { return CppClingo::Util::value_hash(ref_); }
 
    friend auto compare(SharedSymbol const &a, SharedSymbol const &b) -> int { return compare(a.get(), b.get()); }
 
    friend auto operator==(SharedSymbol const &a, SharedSymbol const &b) -> bool { return a.get() == b.get(); }
 
    friend auto operator==(SharedSymbol const &a, Symbol const &b) -> bool { return a.get() == b; }
 
    friend auto operator==(Symbol const &a, SharedSymbol const &b) -> bool { return a == b.get(); }
 
    friend auto operator<=>(SharedSymbol const &a, SharedSymbol const &b) -> std::strong_ordering {
        return compare(a, b) <=> 0;
    }
 
    friend auto operator<=>(SharedSymbol const &a, Symbol const &b) -> std::strong_ordering {
        return compare(*a, b) <=> 0;
    }
 
    friend auto operator<=>(Symbol const &a, SharedSymbol const &b) -> std::strong_ordering {
        return compare(a, *b) <=> 0;
    }
 
  private:
    Symbol ref_ = Symbol::from_rep(0);
};
 
using SharedSymbolSpan = std::span<SharedSymbol const>;
using SharedSymbolVec = std::vector<SharedSymbol>;
 
inline auto as_symbol_ptr(SharedSymbol const *ptr) -> Symbol const * {
    // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
    return reinterpret_cast<Symbol const *>(ptr);
}
 
template <class T> inline auto as_symbol_span(T const &vec) -> SymbolSpan {
    return {as_symbol_ptr(vec.data()), vec.size()};
}
 
inline auto as_shared_symbol_ptr(Symbol const *ptr) -> SharedSymbol const * {
    // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
    return reinterpret_cast<SharedSymbol const *>(ptr);
}
 
template <class T> inline auto as_shared_symbol_span(T const &vec) -> SharedSymbolSpan {
    return {as_shared_symbol_ptr(vec.data()), vec.size()};
}
 
class SymbolCollector {
  public:
    void mark(Symbol const &sym);
    void mark(String const &str);
 
  private:
    std::vector<Symbol> stack_;
};
 
class SymbolOwner {
  public:
    virtual ~SymbolOwner() = default;
    virtual void mark(SymbolCollector &gc) const = 0;
};
 
class SymbolStore {
  public:
    virtual ~SymbolStore() noexcept = default;
 
    [[nodiscard]] auto string(std::string_view str) -> SharedString;
 
    [[nodiscard]] static auto sup() noexcept -> Symbol;
    [[nodiscard]] static auto inf() noexcept -> Symbol;
    //
    [[nodiscard]] static auto str(SharedString str) noexcept -> SharedSymbol;
    [[nodiscard]] static auto str(String str) noexcept -> SharedSymbol;
    [[nodiscard]] auto num(Number num) noexcept -> SharedSymbol;
    [[nodiscard]] static auto num(int32_t num) noexcept -> SharedSymbol;
    [[nodiscard]] auto tup(SharedSymbolSpan args) -> SharedSymbol;
    [[nodiscard]] auto tup(SymbolSpan args) -> SharedSymbol;
    [[nodiscard]] auto fun(SharedString const &name, SharedSymbolSpan args, bool sign) -> SharedSymbol;
    [[nodiscard]] auto fun(String name, SymbolSpan args, bool sign) -> SharedSymbol;
 
    // interface to create floating references
 
    [[nodiscard]] auto string_ref(std::string_view str) -> String;
 
    [[nodiscard]] static auto str_ref(String str) noexcept -> Symbol;
    [[nodiscard]] auto num_ref(Number num) noexcept -> Symbol;
    [[nodiscard]] static auto num_ref(int32_t num) noexcept -> Symbol;
    [[nodiscard]] auto tup_ref(SymbolSpan args) -> Symbol;
    [[nodiscard]] auto fun_ref(String name, SymbolSpan args, bool sign) -> Symbol;
 
    void gc_block() noexcept { do_gc_block(true); }
    void gc_unblock() noexcept { do_gc_block(false); }
    void gc_add_owner(SymbolOwner const &owner) { do_gc_add_owner(owner); }
    void gc_del_owner(SymbolOwner const &owner) noexcept { do_gc_del_owner(owner); }
    auto gc() -> std::tuple<size_t, size_t, size_t> { return do_gc(); }
 
  private:
    [[nodiscard]] virtual auto do_tup(SymbolSpan args, bool referenced) -> Symbol = 0;
    [[nodiscard]] virtual auto do_fun(String str, SymbolSpan args, bool sign, bool referenced) -> Symbol = 0;
    [[nodiscard]] virtual auto do_string(std::string_view str, bool referenced) -> String = 0;
    [[nodiscard]] virtual auto do_num(Number num) noexcept -> Symbol = 0;
 
    virtual void do_gc_block(bool block) noexcept = 0;
    virtual void do_gc_add_owner(SymbolOwner const &owner) = 0;
    virtual void do_gc_del_owner(SymbolOwner const &owner) noexcept = 0;
    virtual auto do_gc() -> std::tuple<size_t, size_t, size_t> = 0;
};
 
using USymbolStore = std::unique_ptr<SymbolStore>;
 
class GCLock {
  public:
    GCLock(SymbolStore &store) : store_{&store} { store_->gc_block(); }
    ~GCLock() { store_->gc_unblock(); }
 
  private:
    SymbolStore *store_;
};
 
void init_default_symbol_store(USymbolStore store);
 
auto default_symbol_store() -> SymbolStore &;
 
auto make_symbol_store(bool slotted, bool shared) -> USymbolStore;
 
class NameGen {
  public:
    NameGen(SymbolStore &store, StringSet names, char const *prefix)
        : store_{store}, names_{names.begin(), names.end()}, prefix_{prefix} {}
    NameGen(NameGen &&) noexcept = delete;
    void init(StringSet names, char const *prefix) {
        num_ = 0;
        names_.insert(names.begin(), names.end());
        prefix_ = prefix;
    }
    [[nodiscard]] auto add_name(String name) -> bool { return names_.emplace(name).second; }
    [[nodiscard]] auto new_name() -> String;
    [[nodiscard]] auto store() const -> SymbolStore & { return store_; }
 
  private:
    SymbolStore &store_;
    SharedStringSet names_;
    char const *prefix_;
    size_t num_ = 0;
};
 
 
} // namespace CppClingo