config.hh

#pragma once
 
#include <clingo/util/enum.hh>
#include <clingo/util/print.hh>
 
#include <clasp/cli/clasp_options.h>
 
#include <map>
#include <sstream>
 
namespace CppClingo::Control {
 
class ClingoConfig {
  public:
    using KeyType = Clasp::Cli::ClaspCliConfig::KeyType;
    using IndexType = KeyType;
    enum class ValueFlags : uint8_t {
        none = 0, 
        get = 1,  //<! The entry can be read.
        set = 2,  
    };
    CLINGO_ENABLE_BITSET_ENUM(ValueFlags, friend);
 
    class Entry {
      public:
        using ValueFlags = ClingoConfig::ValueFlags;
        using KeyType = ClingoConfig::KeyType;
 
        Entry() = default;
        Entry(Entry &&other) = delete;
        auto operator=(Entry &&other) -> Entry & = delete;
        virtual ~Entry() = default;
 
        [[nodiscard]] auto value_info() -> ValueFlags { return do_value_type(); }
        auto get_value(std::optional<IndexType> index, std::string &value) -> bool {
            return do_get_value(index, value);
        }
        void set_value(std::optional<KeyType> index, std::string_view value) { do_set_value(index, value); }
        auto size_array() -> std::optional<int> { return do_array_size(); }
 
      private:
        virtual auto do_value_type() -> ValueFlags { return ValueFlags::none; }
        virtual auto do_get_value([[maybe_unused]] std::optional<KeyType> index, [[maybe_unused]] std::string &value)
            -> bool {
            error_("cannot get value");
            return false;
        }
        virtual void do_set_value([[maybe_unused]] std::optional<KeyType> index,
                                  [[maybe_unused]] std::string_view value) {
            error_("cannot set value");
        }
        virtual auto do_array_size() -> std::optional<int> { return std::nullopt; }
    };
 
    ClingoConfig(Clasp::Cli::ClaspCliConfig &config) : config_{&config} {}
 
    static auto key_root() -> KeyType { return Clasp::Cli::ClaspCliConfig::key_root; }
 
    void key_info(KeyType key, int *n_children, int *array_info, ValueFlags *value_info) const;
 
    auto description(KeyType key) const -> std::string_view;
 
    [[nodiscard]] auto array_at(KeyType key, KeyType index) const -> KeyType;
 
    [[nodiscard]] auto map_at(KeyType key, std::string_view path) const -> std::optional<KeyType>;
 
    [[nodiscard]] auto map_nth(KeyType key, KeyType index) const -> std::string_view;
 
    [[nodiscard]] auto get_value(KeyType key) const -> std::optional<std::string_view>;
 
    void set_value(KeyType key, std::string_view value);
 
    void add_entry(KeyType key, std::string_view name, std::string_view description,
                   std::unique_ptr<Entry> entry = nullptr);
 
    void str(Util::OutputBuffer &out, KeyType key) const;
 
    [[nodiscard]] auto clasp() const -> Clasp::Cli::ClaspCliConfig & { return *config_; }
 
  private:
    static constexpr KeyType Bits = sizeof(KeyType) * 8;
    static constexpr KeyType BitsIndex = 8;
    static constexpr KeyType BitsKeyId = Bits - BitsIndex - 1;
 
    static constexpr KeyType MaskClingo = KeyType{1} << (Bits - 1);
    static constexpr KeyType MaskKeyId = ((KeyType{1} << BitsKeyId) - 1) << BitsIndex;
    static constexpr KeyType MaskIndex = (KeyType{1} << BitsIndex) - 1;
 
    static auto index_invalid() -> KeyType { return KeyType(-1); }
    static auto key_invalid() -> KeyType { return Clasp::Cli::ClaspCliConfig::key_invalid; }
 
    struct FromRep {};
    [[maybe_unused]] static constexpr FromRep from_rep{};
 
    static auto check_(KeyType key) -> KeyType {
        if (key == key_invalid()) {
            error_("invalid key");
        }
        return key;
    }
 
    template <class... T> static void error_(T const &...args) {
        std::ostringstream oss;
        oss << "configuration error: ";
        (oss << ... << args); // NOLINT
        throw std::runtime_error{oss.str()};
    }
 
    template <class P> static void init_(P *val, P def) {
        if (val != nullptr) {
            *val = def;
        }
    }
 
    class Key {
      public:
        explicit Key(KeyType key_id, std::optional<KeyType> index = std::nullopt)
            : rep_{MaskClingo | encode_key_id(key_id) | encode_array(index)} {}
 
        explicit Key([[maybe_unused]] FromRep tag, KeyType value) : rep_{value} {
            if ((rep_ & MaskIndex) == MaskIndex || (rep_ & MaskClingo) == 0) {
                error_("invalid key");
            }
        }
 
        [[nodiscard]] auto key_id() const -> KeyType;
        [[nodiscard]] auto index() const -> std::optional<KeyType>;
        [[nodiscard]] auto subkey(Key child) const -> Key;
        [[nodiscard]] auto rep() const -> KeyType;
 
        [[nodiscard, maybe_unused]] friend auto operator==(Key const &a, Key const &b) -> bool = default;
        [[nodiscard, maybe_unused]] friend auto operator<=>(Key const &a, Key const &b)
            -> std::strong_ordering = default;
 
      private:
        static auto encode_array(std::optional<KeyType> index) -> KeyType;
        static auto encode_key_id(KeyType key_id) -> KeyType;
 
        KeyType rep_;
    };
 
    class Node {
      public:
        explicit Node(std::string_view description, std::unique_ptr<Entry> entry)
            : entry_{std::move(entry)}, description_{description} {}
 
        [[nodiscard]] auto description() const -> std::string_view;
        [[nodiscard]] auto entries() const -> int;
 
        [[nodiscard]] auto map_at(Key key, std::string_view name) const -> std::optional<Key>;
        [[nodiscard]] auto map_nth(KeyType index) const -> std::optional<std::string_view>;
        [[nodiscard]] auto array_at(Key key, KeyType index) const -> Key;
        auto get_value(std::optional<KeyType> index, std::string &value) const -> bool;
        void set_value(std::optional<KeyType> index, std::string_view value);
        void info(Key key, int *n_children, int *array_info, ValueFlags *value_info) const;
        void add_subkey(std::string_view name, Key parent, Key child);
 
      private:
        std::unique_ptr<Entry> entry_;
        std::map<std::string, Key, std::less<>> subkeys_;
        std::string description_;
    };
 
    static auto parse_name_(std::string_view &name) -> std::optional<IndexType>;
 
    auto parse_path_(Key key, std::string_view path) const -> std::optional<Key>;
    // Checks if this key is a clasp key.
    //
    // Returns true if the upper bit is not set.
    [[nodiscard]] static auto is_clasp(KeyType key) -> bool;
 
    // Checks if this key is a clingo key.
    //
    // Returns the key if the upper bit is set and thows an exception for the
    // invalid key.
    [[nodiscard]] static auto is_clingo(KeyType key) -> std::optional<Key>;
 
    // Get the string representation of the configuration tree under the given key.
    void str_(Util::OutputBuffer &out, KeyType key, size_t first_indent, size_t indent) const;
 
    Clasp::Cli::ClaspCliConfig *config_;
    std::string mutable buf_;
    std::vector<Node> nodes_;
};
 
} // namespace CppClingo::Control