optional.hh

#pragma once
 
#include <clingo/util/algorithm.hh>
#include <clingo/util/immutable_array.hh>
 
#include <functional>
#include <optional>
#include <vector>
 
namespace CppClingo::Util {
 
namespace Detail {
 
template <class T, class F> using transform_result = std::optional<std::remove_cv_t<std::invoke_result_t<F, T>>>;
 
template <class T, class F>
using and_then_result = std::remove_cv_t<std::remove_reference_t<std::invoke_result_t<F, T>>>;
 
template <class T, class F>
using transform_vec_result = std::optional<std::vector<typename transform_result<T, F>::value_type>>;
 
} // namespace Detail
 
 
template <class T, class F> constexpr auto transform(std::optional<T> &x, F &&f) -> Detail::transform_result<T &, F> {
    if (x.has_value()) {
        return std::invoke(std::forward<F>(f), *x);
    }
    return std::nullopt;
}
 
template <class T, class F>
constexpr auto transform(std::optional<T> const &x, F &&f) -> Detail::transform_result<T const &, F> {
    if (x.has_value()) {
        return std::invoke(std::forward<F>(f), *x);
    }
    return std::nullopt;
}
 
template <class T, class F> constexpr auto transform(std::optional<T> &&x, F &&f) -> Detail::transform_result<T, F> {
    if (x.has_value()) {
        return std::invoke(std::forward<F>(f), *std::move(x));
    }
    return std::nullopt;
}
 
template <class T, class F>
constexpr auto transform(std::optional<T> const &&x, F &&f) -> Detail::transform_result<T const, F> {
    if (x.has_value()) {
        return std::invoke(std::forward<F>(f), *std::move(x));
    }
    return std::nullopt;
}
 
template <class T, class F> constexpr auto and_then(std::optional<T> &x, F &&f) -> Detail::and_then_result<T &, F> {
    if (x) {
        return std::invoke(std::forward<F>(f), *x);
    }
    return std::remove_cv_t<std::remove_reference_t<std::invoke_result_t<F, T &>>>{};
}
 
template <class T, class F>
constexpr auto and_then(std::optional<T> const &x, F &&f) -> Detail::and_then_result<T const &, F> {
    if (x) {
        return std::invoke(std::forward<F>(f), *x);
    }
    return std::remove_cv_t<std::remove_reference_t<std::invoke_result_t<F, T const &>>>{};
}
 
template <class T, class F> constexpr auto and_then(std::optional<T> &&x, F &&f) -> Detail::and_then_result<T, F> {
    if (x) {
        return std::invoke(std::forward<F>(f), *std::move(x));
    }
    return std::remove_cv_t<std::remove_reference_t<std::invoke_result_t<F, T>>>{};
}
 
template <class T, class F>
constexpr auto and_then(std::optional<T> const &&x, F &&f) -> Detail::and_then_result<T const, F> {
    if (x) {
        return std::invoke(std::forward<F>(f), *std::move(x));
    }
    return std::remove_cv_t<std::remove_reference_t<std::invoke_result_t<F, T const>>>{};
}
 
template <class T, class F>
auto transform_vec(std::optional<std::vector<T>> const &vec, F const &f)
    -> Detail::transform_vec_result<T const &, F const &> {
    return transform(vec, [&f](auto const &vec) {
        typename Detail::transform_vec_result<T const &, F const &>::value_type ret;
        ret.reserve(vec.size());
        for (auto const &elem : vec) {
            ret.emplace_back(std::invoke(f, elem));
        }
        return ret;
    });
}
 
template <class T, class F>
// NOLINTNEXTLINE(cppcoreguidelines-rvalue-reference-param-not-moved)
auto transform_vec(std::optional<std::vector<T>> &&vec, F const &f) -> Detail::transform_vec_result<T, F const &> {
    return transform(vec, [&f](auto &vec) {
        typename Detail::transform_vec_result<T, F const &>::value_type ret;
        ret.reserve(vec.size());
        for (auto &elem : vec) {
            ret.emplace_back(std::invoke(f, std::move(elem)));
        }
        return ret;
    });
}
 
template <class E, class S = bool> struct ResultState {
    ResultState(S state = S{}, std::optional<E> value = std::nullopt)
        : state{std::move(state)}, value{std::move(value)} {}
    template <class F> ResultState(ResultState<F, S> const &res) : state{res.state}, value{res.value} {}
    template <class F>
    // NOLINTNEXTLINE(cppcoreguidelines-rvalue-reference-param-not-moved)
    ResultState(ResultState<F, S> &&res) : state{std::move(res.state)}, value{std::move(res.value)} {}
 
    S state = S{};
    std::optional<E> value = std::nullopt;
};
 
template <class T, bool UseSpan = true> class ResultVec {
  public:
    using ValueType = T;
    using Span = std::span<ValueType const>;
    using Array = Util::immutable_array<ValueType>;
    using Vector = std::vector<ValueType>;
    using Source = std::conditional_t<UseSpan, Span, Array const &>;
    using Iterator = std::conditional_t<UseSpan, typename Span::iterator, typename Array::const_iterator>;
    using Result = std::conditional_t<UseSpan, Vector, Array>;
 
    ResultVec(Source source) : source_{source}, current_{source_.begin()} {}
 
    [[nodiscard]] auto current() const -> ValueType const & { return *current_; }
 
    void keep() {
        if (result_) {
            result_->emplace_back(*current_);
        }
        ++current_;
    }
    void keep_all() {
        if (result_) {
            result_->insert(result_->end(), current_, source_.end());
        }
        current_ = source_.end();
    }
    void remove() {
        if (!result_) {
            result_ = Util::copy_n(source_, std::distance(source_.begin(), current_));
        }
        ++current_;
    }
    template <class... Args> void replace(Args &&...args) {
        if (!result_) {
            result_ = Util::copy_n(source_, std::distance(source_.begin(), current_));
        }
        result_->emplace_back(std::forward<Args>(args)...);
        ++current_;
    }
    void update(std::optional<ValueType> value) {
        if (!value.has_value()) {
            keep();
        } else {
            replace(*std::move(value));
        }
    }
    template <class... Args> void append(Args &&...args) {
        if (!result_) {
            result_ = Util::copy_n(source_, std::distance(source_.begin(), current_));
        }
        result_->emplace_back(std::forward<Args>(args)...);
    }
    template <class It> void extend(It begin, It end) {
        if (!result_) {
            result_ = Util::copy_n(source_, std::distance(source_.begin(), current_));
        }
        result_->insert(result_->end(), begin, end);
    }
    [[nodiscard]] auto value() const & -> Span {
        if (result_) {
            return *result_;
        }
        return source_;
    }
    [[nodiscard]] auto value() && -> Result {
        if (result_) {
            return *std::move(result_);
        }
        if constexpr (UseSpan) {
            return {source_.begin(), source_.end()};
        } else {
            return source_;
        }
    }
    [[nodiscard]] auto has_value() const -> bool { return result_.has_value(); }
    [[nodiscard]] auto as_optional() & -> std::optional<Vector> & { return result_; }
    [[nodiscard]] auto as_optional() && -> std::optional<Vector> { return std::move(result_); }
 
    [[nodiscard]] auto operator*() const & -> Span { return value(); }
    [[nodiscard]] auto operator*() && -> Result { return std::move(*this).value(); }
    explicit operator bool() const { return has_value(); }
    [[nodiscard]] auto complete() const { return current_ == source_.end(); }
 
  private:
    Source source_;
    std::optional<Vector> result_;
    Iterator current_;
};
 
template <class T> ResultVec(std::vector<T> const &) -> ResultVec<T, true>;
 
template <class T> ResultVec(std::span<T const> const &) -> ResultVec<T, true>;
 
template <class T> ResultVec(immutable_array<T> const &) -> ResultVec<T, false>;
 
 
} // namespace CppClingo::Util