config.hh

#pragma once
 
#include <clingo/core.hh>
 
#include <clingo/config.h>
 
namespace Clingo {
 
 
enum class ConfigType : clingo_config_type_bitset_t {
    value = clingo_config_type_value,
    array = clingo_config_type_array,
    map = clingo_config_type_map,
};
CLINGO_ENABLE_BITSET_ENUM(ConfigType);
 
class ConstConfigArray;
class ConfigArray;
class ConstConfigMap;
class ConfigMap;
 
class ConstConfig {
  public:
    explicit ConstConfig(clingo_config_t const *stats, ProgramId key) : cfg_{stats}, key_{key} {}
 
    friend auto c_cast(ConstConfig const &stats) -> clingo_config_t const * { return stats.cfg_; }
 
    [[nodiscard]] auto type() const -> ConfigType {
        return static_cast<ConfigType>(Detail::call<clingo_config_type>(cfg_, key_));
    }
 
    [[nodiscard]] auto array() const -> ConstConfigArray;
 
    [[nodiscard]] auto at(size_t index) const -> ConstConfig;
 
    [[nodiscard]] auto operator[](size_t index) const -> ConstConfig { return at(index); }
 
    [[nodiscard]] auto map() const -> ConstConfigMap;
 
    [[nodiscard]] auto get(std::string_view name) const -> ConstConfig;
 
    [[nodiscard]] auto operator[](std::string_view name) const -> ConstConfig { return get(name); }
 
    [[nodiscard]] auto value() const -> std::optional<std::string_view> {
        if (intersects(type(), ConfigType::value)) {
            clingo_string_t value;
            bool assigned = false;
            Detail::handle_error(clingo_config_value_get(cfg_, key_, &value, &assigned));
            if (assigned) {
                return std::string_view{value.data, value.size};
            }
            return std::nullopt;
        }
        throw std::logic_error{"not a value"};
    }
 
    [[nodiscard]] auto operator*() const -> std::optional<std::string_view> { return value(); }
 
    [[nodiscard]] auto description() const -> std::string_view {
        auto [data, size] = Detail::call<clingo_config_description>(cfg_, key_);
        return {data, size};
    }
 
    [[nodiscard]] auto to_string() const -> std::string {
        auto bld = StringBuilder{};
        Detail::handle_error(clingo_config_to_string(cfg_, key_, c_cast(bld)));
        return std::string{bld.str()};
    }
 
  private:
    friend class Config;
 
    clingo_config_t const *cfg_;
    clingo_id_t key_;
};
 
class Config : public ConstConfig {
  public:
    explicit Config(clingo_config_t *stats, ProgramId key) : ConstConfig{stats, key} {}
 
    friend auto c_cast(Config const &stats) -> clingo_config_t * { return stats.cfg_(); }
 
    [[nodiscard]] auto array() const -> ConfigArray;
    [[nodiscard]] auto at(size_t index) const -> Config;
    [[nodiscard]] auto operator[](size_t index) const -> Config { return at(index); }
    [[nodiscard]] auto map() const -> ConfigMap;
    [[nodiscard]] auto get(std::string_view name) const -> Config;
    [[nodiscard]] auto operator[](std::string_view name) const -> Config { return get(name); }
    using ConstConfig::value;
    void value(std::string_view value) const {
        if (intersects(type(), ConfigType::value)) {
            Detail::handle_error(clingo_config_value_set(cfg_(), key_, value.data(), value.size()));
        } else {
            throw std::logic_error{"not a value"};
        }
    }
    auto operator=(std::string_view value) const -> Config { // NOLINT
        this->value(value);
        return *this;
    }
 
    template <class Handler> void add(std::string_view name, std::string_view description, Handler &&handler) const {
        using HandlerType = std::remove_cvref_t<Handler>;
 
        static constexpr auto has_get = requires { handler.get(); };
        static constexpr auto has_array_get = requires { handler.get(std::optional<size_t>{}); };
        static constexpr auto has_set = requires { std::declval<HandlerType>().set(std::string_view{}); };
        static constexpr auto has_array_set =
            requires { std::declval<HandlerType>().set(std::optional<size_t>{}, std::string_view{}); };
        static constexpr auto is_array = requires { handler.size(); };
 
        static_assert(!has_get || !has_array_get, "entry cannot have both get with and without index");
        static_assert(!has_set || !has_array_set, "entry cannot have both set with and without index");
 
        static constexpr auto c_entry = clingo_config_entry_t{
            has_get || has_array_get ? +[](size_t const *index, void *data, clingo_string_t *value, bool *has_value) -> bool {
                CLINGO_TRY {
                    auto *self = static_cast<HandlerType *>(data);
                    thread_local std::optional<std::string> str;
                    if constexpr (has_array_get) {
                        str = self->get(index != nullptr ? std::optional{*index} : std::nullopt);
                    }
                    if constexpr (has_get) {
                        if (index != nullptr) {
                            throw std::logic_error{"cannot get array value"};
                        }
                        str = self->get();
                    }
                    if (str.has_value() && value != nullptr) {
                        value->data = str->data();
                        value->size = str->size();
                    }
                    if (has_value != nullptr) {
                        *has_value = str.has_value();
                    }
                }
                CLINGO_CATCH;
            } : nullptr,
            has_set || has_array_set ? +[](size_t const *index, char const *value, size_t size, void *data) -> bool {
                CLINGO_TRY {
                    auto *self = static_cast<HandlerType *>(data);
                    if constexpr (has_array_set) {
                        self->set(index != nullptr ? std::optional{*index} : std::nullopt,
                                  std::string_view{value, size});
                    }
                    if constexpr (has_set) {
                        if (index != nullptr) {
                            throw std::logic_error{"cannot set array value"};
                        }
                        self->set(std::string_view{value, size});
                    }
                }
                CLINGO_CATCH;
            } : nullptr,
            is_array ? +[](void *data, size_t *size, bool *has_size) -> bool {
                CLINGO_TRY {
                    auto *self = static_cast<HandlerType *>(data);
                    if constexpr (is_array) {
                        if (size != nullptr) {
                            *size = self->size();
                        }
                    }
                    if (has_size != nullptr) {
                        *has_size = is_array;
                    }
                }
                CLINGO_CATCH;
            } : nullptr,
            [](void *data) { std::unique_ptr<HandlerType>{static_cast<HandlerType *>(data)}; },
        };
 
        auto copy = std::make_unique<HandlerType>(std::forward<Handler>(handler));
        Detail::handle_error(clingo_config_add(cfg_(), key_, name.data(), name.size(), description.data(),
                                               description.size(), &c_entry, copy.release()));
    }
 
    void add(std::string_view name, std::string_view description) const {
        Detail::handle_error(clingo_config_add(cfg_(), key_, name.data(), name.size(), description.data(),
                                               description.size(), nullptr, nullptr));
    }
 
  private:
    [[nodiscard]] auto cfg_() const -> clingo_config_t * {
        // NOLINTNEXTLINE
        return const_cast<clingo_config_t *>(ConstConfig::cfg_);
    }
};
 
class ConstConfigArray {
  public:
    using value_type = ConstConfig;
    using size_type = std::size_t;
    using difference_type = std::ptrdiff_t;
    using reference = value_type;
    using pointer = Detail::ArrowProxy<value_type>;
    using iterator = Detail::RandomAccessIterator<ConstConfigArray>;
 
    explicit ConstConfigArray(clingo_config_t const *stats, ProgramId key) : cfg_{stats}, key_{key} {}
 
    [[nodiscard]] auto at(size_t index) const -> ConstConfig { return ConstConfig{cfg_, at_(index)}; }
    [[nodiscard]] auto operator[](size_t index) const -> ConstConfig { return at(index); }
    [[nodiscard]] auto size() const -> size_t { return Detail::call<clingo_config_array_size>(cfg_, key_); }
    [[nodiscard]] auto begin() const -> iterator { return iterator{*this, 0}; }
    [[nodiscard]] auto end() const -> iterator { return iterator{*this, size()}; }
 
  private:
    friend class ConfigArray;
    [[nodiscard]] auto at_(size_t index) const -> clingo_id_t {
        return Detail::call<clingo_config_array_at>(cfg_, key_, index);
    }
 
    clingo_config_t const *cfg_;
    clingo_id_t key_;
};
 
inline auto ConstConfig::array() const -> ConstConfigArray {
    if (intersects(type(), ConfigType::array)) {
        return ConstConfigArray{cfg_, key_};
    }
    throw std::logic_error{"not an array"};
}
 
inline auto ConstConfig::at(size_t index) const -> ConstConfig {
    return array().at(index);
}
 
class ConfigArray : public ConstConfigArray {
  public:
    using value_type = Config;
    using size_type = std::size_t;
    using difference_type = std::ptrdiff_t;
    using reference = value_type;
    using pointer = Detail::ArrowProxy<value_type>;
    using iterator = Detail::RandomAccessIterator<ConfigArray>;
 
    explicit ConfigArray(clingo_config_t *stats, ProgramId key) : ConstConfigArray{stats, key} {}
 
    [[nodiscard]] auto at(size_t index) const -> Config { return Config{cfg_(), at_(index)}; }
    [[nodiscard]] auto operator[](size_t index) const -> Config { return at(index); }
    [[nodiscard]] auto begin() const -> iterator { return iterator{*this, 0}; }
    [[nodiscard]] auto end() const -> iterator { return iterator{*this, size()}; }
 
  private:
    [[nodiscard]] auto cfg_() const -> clingo_config_t * {
        // NOLINTNEXTLINE
        return const_cast<clingo_config_t *>(ConstConfigArray::cfg_);
    }
};
 
[[nodiscard]] inline auto Config::array() const -> ConfigArray {
    if (intersects(type(), ConfigType::array)) {
        return ConfigArray{cfg_(), key_};
    }
    throw std::logic_error{"not an array"};
}
 
inline auto Config::at(size_t index) const -> Config {
    return array().at(index);
}
 
class ConstConfigMap {
  public:
    using key_type = std::string_view;
    using mapped_type = ConstConfig;
    using value_type = std::pair<key_type, mapped_type>;
    using size_type = std::size_t;
    using difference_type = std::ptrdiff_t;
    using reference = value_type;
    using pointer = Detail::ArrowProxy<value_type>;
    using iterator = Detail::RandomAccessIterator<ConstConfigMap>;
 
    explicit ConstConfigMap(clingo_config_t const *stats, ProgramId key) : cfg_{stats}, key_{key} {}
 
    [[nodiscard]] auto size() const -> size_t { return Detail::call<clingo_config_map_size>(cfg_, key_); }
 
    [[nodiscard]] auto at(size_t index) const -> value_type {
        auto [name, subkey] = at_(index);
        return {name, ConstConfig{cfg_, subkey}};
    }
 
    [[nodiscard]] auto get(std::string_view name) const -> ConstConfig { return ConstConfig{cfg_, at_(name)}; }
 
    [[nodiscard]] auto operator[](std::string_view name) const -> ConstConfig { return get(name); }
 
    [[nodiscard]] auto contains(std::string_view name) const -> bool {
        return Detail::call<clingo_config_map_at>(cfg_, key_, name.data(), name.size(), nullptr);
    }
 
    [[nodiscard]] auto begin() const -> iterator { return iterator{*this, 0}; }
 
    [[nodiscard]] auto end() const -> iterator { return iterator{*this, size()}; }
 
  private:
    friend class ConfigMap;
 
    [[nodiscard]] auto at_(std::string_view name) const -> clingo_id_t {
        bool has_subkey = false;
        clingo_id_t subkey = 0;
        Detail::handle_error(clingo_config_map_at(cfg_, key_, name.data(), name.size(), &subkey, &has_subkey));
        if (!has_subkey) {
            throw std::out_of_range{"subkey not found"};
        }
        return subkey;
    }
 
    [[nodiscard]] auto at_(size_t index) const -> std::pair<std::string_view, clingo_id_t> {
        auto [data, size] = Detail::call<clingo_config_map_subkey_name>(cfg_, key_, index);
        auto str = std::string_view{data, size};
        return {str, at_(str)};
    }
 
    clingo_config_t const *cfg_;
    clingo_id_t key_;
};
 
inline auto ConstConfig::map() const -> ConstConfigMap {
    if (intersects(type(), ConfigType::map)) {
        return ConstConfigMap{cfg_, key_};
    }
    throw std::logic_error{"not a map"};
}
 
inline auto ConstConfig::get(std::string_view name) const -> ConstConfig {
    return map().get(name);
}
 
class ConfigMap : public ConstConfigMap {
  public:
    using key_type = std::string_view;
    using mapped_type = Config;
    using value_type = std::pair<key_type, mapped_type>;
    using size_type = std::size_t;
    using difference_type = std::ptrdiff_t;
    using reference = value_type;
    using pointer = Detail::ArrowProxy<value_type>;
    using iterator = Detail::RandomAccessIterator<ConfigMap>;
 
    explicit ConfigMap(clingo_config_t *stats, ProgramId key) : ConstConfigMap{stats, key} {}
 
    [[nodiscard]] auto at(size_t index) const -> value_type {
        auto [name, subkey] = at_(index);
        return {name, Config{cfg_(), subkey}};
    }
    [[nodiscard]] auto get(std::string_view name) const -> Config { return Config{cfg_(), at_(name)}; }
    [[nodiscard]] auto operator[](std::string_view name) const -> Config { return get(name); }
    [[nodiscard]] auto begin() const -> iterator { return iterator{*this, 0}; }
    [[nodiscard]] auto end() const -> iterator { return iterator{*this, size()}; }
 
  private:
    [[nodiscard]] auto cfg_() const -> clingo_config_t * {
        // NOLINTNEXTLINE
        return const_cast<clingo_config_t *>(ConstConfigMap::cfg_);
    }
};
 
inline auto Config::map() const -> ConfigMap {
    if (intersects(type(), ConfigType::map)) {
        return ConfigMap{cfg_(), key_};
    }
    throw std::logic_error{"not a map"};
}
 
inline auto Config::get(std::string_view name) const -> Config {
    return map().get(name);
}
 
 
} // namespace Clingo