flagwork.hpp

Go to the documentation of this file.

#pragma once
#include <optional>
#include <string_view>
#include "../../detect.hpp"
#include "urlparser.hpp"

#define SUBQ_LIFT(mem_fn)                                                                                                                            \
    [&](auto&&... args) noexcept(noexcept(mem_fn(std::forward<decltype(args)>(args)...))) -> decltype(                                               \
                                                                                              mem_fn(std::forward<decltype(args)>(args)...)) {       \
        return mem_fn(std::forward<decltype(args)>(args)...);                                                                                        \
    }

template <class F, class = std::enable_if_t<!std::is_same_v<F, Empty>>>
constexpr auto target_get_composable_flag(const TargetParser& target, std::string_view tag) noexcept -> std::optional<F> {
    auto flags = F{};
    if (auto csv = target[tag]; !csv.empty()) {
        for (CSVIterator state_it{csv}; state_it != state_it.end(); ++state_it) {
            const auto v = F::from_string(*state_it);
            if (!v)
                return std::nullopt;
            if constexpr (test_sfinae([](auto f, auto g) { return f | g; }, F{}, F{}))
                flags |= *v;
            else
                return v;
        }
    }
    return {flags};
}

template <class... Fcns> constexpr auto parameterized_depends_scope(Fcns&&... depends) noexcept((std::is_nothrow_move_constructible_v<Fcns> && ...)) {
    using Arr = std::tuple<Fcns...>; // pray for vectorisation; wait for expansion statements
    return [&](auto&&... args) -> DependsOutcome {
        DependsOutcome ret = DependsOutcome::SKIPPED;
        visit(Arr{std::forward<Fcns>(depends)...}, [&](auto&& f) {
            if (ret != DependsOutcome::SKIPPED)
                return;
            if (const auto ao = std::forward<decltype(f)>(f)(args...); ao != DependsOutcome::SKIPPED) {
                ret = ao;
            }
        });
        return ret;
    };
};

namespace subq_impl {

template <class T, class A> using ToJson = decltype(to_json(std::declval<T&&>(), std::declval<A&>()));
template <class T, class A> using GetToJson = decltype(get_to_json(std::declval<T&&>(), std::declval<A&>()));

template <class T, class A> constexpr decltype(auto) auto_serialize(T&& v, A& al) {
    using Value = std::remove_reference_t<T>;
    using Alloc = std::remove_reference_t<A>;
    if constexpr (nstd::is_detected_v<ToJson, Value, Alloc>)
        return to_json(std::move(v), al);
    else if constexpr (nstd::is_detected_v<GetToJson, Value, Alloc>)
        return get_to_json(std::move(v), al);
    else
        static_assert(std::is_void_v<Value>, "T is not auto-serializable");
    UNREACHABLE;
}

template <class TI, class F, class VC, class TJ>
auto subquery(std::string_view name, std::string_view opt_tag, [[maybe_unused]] TI ti, F&& lifted, VC&& valid_check, TJ&& to_json) noexcept(
    std::is_nothrow_move_constructible_v<F>&& std::is_nothrow_move_constructible_v<VC>&& std::is_nothrow_move_constructible_v<TJ>) {
    return [name, opt_tag, lifted = std::forward<F>(lifted), valid_check = std::forward<VC>(valid_check), to_json = std::forward<TJ>(to_json)](
               int sq_lev, const TargetParser& target, auto& res_val, auto& allocator, auto&& error) -> DependsOutcome {
        if (target.getPathParts()[sq_lev] == name) {
            using Flag = typename TI::type;
            Flag flag{};
            if constexpr (std::is_same_v<Flag, std::string_view> || std::is_same_v<Flag, std::string>)
                flag = target[opt_tag];
            else {
                const auto opt_flags = target_get_composable_flag<Flag>(target, opt_tag);
                if (!opt_flags)
                    return error(301), DependsOutcome::FAILURE;
                flag = *opt_flags;
            }
            auto&& res = lifted(std::move(flag));
            return valid_check(res) ? (res_val = std::move(to_json(std::move(res), allocator)), DependsOutcome::SUCCESS) : DependsOutcome::FAILURE;
        }
        return DependsOutcome::SKIPPED;
    };
}

template <class F, class VC, class TI>
auto subquery(std::string_view name, std::string_view opt_tag, TI ti, F&& lifted,
              VC&& valid_check) noexcept(std::is_nothrow_move_constructible_v<F>&& std::is_nothrow_move_constructible_v<VC>) -> decltype(auto) {
    return subquery(name, opt_tag, ti, std::forward<F>(lifted), std::forward<VC>(valid_check),
                    [](auto&&... args) -> decltype(subq_impl::auto_serialize(args...)) { return subq_impl::auto_serialize(args...); });
}

template <class F, class VC, class TJ, class = std::enable_if_t<!std::is_same_v<F, std::string_view>>>
auto subquery(std::string_view name, F&& lifted, VC&& valid_check, TJ&& to_json) noexcept(
    std::is_nothrow_move_constructible_v<F>&& std::is_nothrow_move_constructible_v<VC>&& std::is_nothrow_move_constructible_v<TJ>) {
    return [&, name, lifted = std::forward<F>(lifted), valid_check = std::forward<VC>(valid_check), to_json = std::forward<TJ>(to_json)](
               int sq_lev, const TargetParser& target, auto& res_val, auto& allocator, auto&& error) -> DependsOutcome {
        if (target.getPathParts()[sq_lev] == name) {
            auto&& res = lifted();
            return valid_check(res) ? (res_val = std::move(to_json(std::move(res), allocator)), DependsOutcome::SUCCESS) : DependsOutcome::FAILURE;
        }
        return DependsOutcome::SKIPPED;
    };
}

template <class F, class VC, class = std::enable_if_t<!std::is_same_v<F, std::string_view>>>
auto subquery(std::string_view name, F&& lifted,
              VC&& valid_check) noexcept(std::is_nothrow_move_constructible_v<F>&& std::is_nothrow_move_constructible_v<VC>) -> decltype(auto) {
    return subquery(name, std::forward<F>(lifted), std::forward<VC>(valid_check),
                    [](auto&&... args) -> decltype(subq_impl::auto_serialize(args...)) { return subq_impl::auto_serialize(args...); });
}

} // namespace subq_impl

constexpr auto subquery = [](auto&&... args) noexcept(noexcept(subq_impl::subquery(std::forward<decltype(args)>(args)...)))
    -> decltype(subq_impl::subquery(std::forward<decltype(args)>(args)...)) { return subq_impl::subquery(std::forward<decltype(args)>(args)...); };