named_arguments.h

Go to the documentation of this file.

#pragma once
 
#include "di/meta/algorithm.h"
#include "di/meta/constexpr.h"
#include "di/meta/core.h"
#include "di/meta/function.h"
#include "di/meta/language.h"
#include "di/meta/list.h"
#include "di/meta/operations.h"
#include "di/meta/util.h"
#include "di/types/in_place.h"
#include "di/util/get.h"
#include "di/vocab/tuple/tuple.h"
 
namespace di::util {
template<typename Tag_, typename T>
class NamedArgument {
public:
    using Tag = Tag_;
    using Type = T;
 
    constexpr static bool is_named_argument = true;
 
    explicit NamedArgument()
    requires(concepts::DefaultConstructible<T>)
    = default;
 
    template<typename U>
    requires(!concepts::DecaySameAs<NamedArgument, U> && concepts::ConstructibleFrom<T, U>)
    // NOLINTNEXTLINE(bugprone-forwarding-reference-overload)
    constexpr explicit(!concepts::ConvertibleTo<U, T>) NamedArgument(U&& value) : m_value(di::forward<U>(value)) {}
 
    template<typename... Args>
    requires(concepts::ConstructibleFrom<T, Args...>)
    constexpr explicit NamedArgument(InPlace, Args&&... args) : m_value(di::forward<Args>(args)...) {}
 
    constexpr auto value() & -> T& { return m_value; }
    constexpr auto value() const& -> T const& { return m_value; }
    constexpr auto value() && -> T&& { return di::move(m_value); }
    constexpr auto value() const&& -> T const&& { return di::move(m_value); }
 
private:
    T m_value;
};

template<typename... Args>
requires((meta::RemoveCVRef<Args>::is_named_argument && ...) &&
         meta::Size<meta::Unique<meta::List<meta::Like<Args &&, typename meta::RemoveCVRef<Args>::Tag>...>>> ==
             sizeof...(Args))
class NamedArguments {
public:
    constexpr explicit NamedArguments(Args&&... args) : m_arguments(di::forward<Args>(args)...) {}
 
    using Type = meta::List<meta::Like<Args&&, typename meta::RemoveCVRef<Args>::Tag>...>;
 
    constexpr auto arguments() & -> Tuple<Args&&...>& { return m_arguments; }
    constexpr auto arguments() const& -> Tuple<Args&&...> const& { return m_arguments; }
    constexpr auto arguments() && -> Tuple<Args&&...>&& { return di::move(m_arguments); }
    constexpr auto arguments() const&& -> Tuple<Args&&...> const&& { return di::move(m_arguments); }
 
private:
    Tuple<Args&&...> m_arguments;
};
 
template<typename... Args>
NamedArguments(Args&&...) -> NamedArguments<Args&&...>;
 
namespace detail {
    template<typename Tag>
    struct GetNamedArgumentFunction {
        template<concepts::RemoveCVRefInstanceOf<NamedArguments> Args>
        requires(meta::Contains<meta::Type<meta::RemoveCVRef<Args>>, Tag &&>)
        constexpr auto operator()(Args&& args) const -> decltype(auto) {
            constexpr auto index = meta::Lookup<Tag&&, meta::Type<meta::RemoveCVRef<Args>>>;
            return di::get<index>(di::forward<Args>(args).arguments()).value();
        }
    };
}

template<typename Arg>
constexpr inline auto get_named_argument = detail::GetNamedArgumentFunction<Arg> {};
 
namespace detail {
    template<typename Tag>
    struct GetNamedArgumentOrFunction {
        template<concepts::RemoveCVRefInstanceOf<NamedArguments> Args, typename Val = meta::Type<Tag>,
                 concepts::ConvertibleTo<Val> U>
        requires(concepts::ConstructibleFrom<Val, meta::Like<Args, Val>>)
        constexpr auto operator()(Args&& args, U&& fallback) const -> Val {
            if constexpr (meta::Contains<meta::Type<meta::RemoveCVRef<Args>>, Tag&&>) {
                return get_named_argument<Tag>(args);
            } else {
                return di::forward<U>(fallback);
            }
        }
    };
 
    template<typename Tag>
    requires(concepts::InstanceOfT<Tag, InPlaceTemplate>)
    struct GetNamedArgumentOrFunction<Tag> {
        template<concepts::RemoveCVRefInstanceOf<NamedArguments> Args, typename U>
        constexpr auto operator()(Args&& args, U&& fallback) const -> decltype(auto) {
            if constexpr (meta::Contains<meta::Type<meta::RemoveCVRef<Args>>, Tag&&>) {
                return get_named_argument<Tag>(args);
            } else {
                return di::forward<U>(fallback);
            }
        }
    };
}

template<typename Arg>
constexpr inline auto get_named_argument_or = detail::GetNamedArgumentOrFunction<Arg> {};
}
 
namespace di::meta {
template<typename Args, typename Tag>
using NamedArgument = decltype(util::get_named_argument<Tag>(declval<Args>()));

template<typename Args, typename Tag>
using NamedArgumentValue = meta::Decay<NamedArgument<Args, Tag>>;

template<typename Args, typename Tag, typename Fallback>
using NamedArgumentOr = decltype(util::get_named_argument_or<Tag>(declval<Args>(), declval<Fallback>()));

template<typename Args, typename Tag, typename Fallback>
using NamedArgumentValueOr = meta::Decay<NamedArgumentOr<Args, Tag, Fallback>>;
}
 
namespace di::concepts {
template<typename Args, typename Tag>
concept HasNamedArgument = concepts::InstanceOf<Args, util::NamedArguments> && meta::Contains<meta::Type<Args>, Tag&&>;
 
namespace detail {
    struct ContainsF {
        template<typename List, typename T>
        using Invoke = meta::Constexpr<meta::Contains<List, T>>;
    };
}

template<typename Allowed, typename... Args>
concept ValidNamedArguments =
    (meta::Size<meta::Unique<meta::List<meta::Like<Args, typename Args::Tag>&&...>>> == sizeof...(Args)) &&
    (meta::All<meta::List<meta::Like<Args, typename Args::Tag>&&...>,
               meta::BindFront<detail::ContainsF, meta::Transform<Allowed, meta::Quote<meta::AddRValueReference>>>>);
}
 
namespace di {
using concepts::HasNamedArgument;
using concepts::ValidNamedArguments;
using util::get_named_argument;
using util::get_named_argument_or;
using util::NamedArgument;
using util::NamedArguments;
}