make_env.h

Go to the documentation of this file.

#pragma once
 
#include "di/execution/concepts/forwarding_query.h"
#include "di/execution/interface/get_env.h"
#include "di/function/invoke.h"
#include "di/function/tag_invoke.h"
#include "di/meta/algorithm.h"
#include "di/meta/core.h"
#include "di/meta/function.h"
#include "di/meta/operations.h"
#include "di/meta/util.h"
#include "di/util/declval.h"
#include "di/util/forward.h"
#include "di/util/get.h"
#include "di/vocab/tuple/tuple.h"
 
namespace di::execution {
namespace make_env_ns {
    template<typename Tag, typename Val>
    struct With {
        using Type = Tag;
 
        [[no_unique_address]] Val value;
    };
 
    struct WithFunction {
        template<typename Tag, concepts::CopyConstructible Val>
        constexpr auto operator()(Tag, Val&& value) const {
            return With<Tag, meta::Decay<Val>> { util::forward<Val>(value) };
        }
    };
 
    template<typename Tag>
    struct Without {
        using Type = Tag;
    };
 
    struct WithoutFunction {
        template<typename Tag>
        constexpr auto operator()(Tag) const {
            return Without<Tag> {};
        }
    };
 
    template<typename T>
    concept Override = concepts::InstanceOf<T, With> || concepts::InstanceOf<T, Without>;
 
    template<typename Tag, concepts::TypeList List>
    using LookupTag = meta::Front<meta::Filter<List, meta::Compose<meta::SameAs<Tag>, meta::Quote<meta::Type>>>>;
 
    template<typename Tag, typename List>
    concept HasTag =
        requires { typename LookupTag<Tag, List>; } && !concepts::InstanceOf<LookupTag<Tag, List>, Without>;
 
    template<typename BaseEnv, typename Withs>
    struct EnvT;
 
    template<typename BaseEnv, typename... Overrides>
    struct EnvT<BaseEnv, meta::List<Overrides...>> {
        struct Type {
        public:
            template<typename... Args>
            constexpr explicit Type(BaseEnv base_env, Overrides... overrides)
                : m_base_env(util::move(base_env)), m_overrides(util::move(overrides)...) {}
 
        private:
            template<typename Tag>
            requires(HasTag<Tag, meta::List<Overrides...>>)
            constexpr friend auto tag_invoke(Tag, Type const& self) {
                return util::get<LookupTag<Tag, meta::List<Overrides...>>>(self.m_overrides).value;
            }
 
            template<concepts::ForwardingQuery Tag>
            requires(!HasTag<Tag, meta::List<Overrides...>> && concepts::Invocable<Tag, BaseEnv const&>)
            constexpr friend auto tag_invoke(Tag tag, Type const& self) -> decltype(auto) {
                return tag(self.m_base_env);
            }
 
            [[no_unique_address]] BaseEnv m_base_env;
            [[no_unique_address]] vocab::Tuple<Overrides...> m_overrides;
        };
    };
 
    template<typename BaseEnv, typename... Withs>
    using Env = meta::Type<EnvT<BaseEnv, meta::List<Withs...>>>;
 
    struct Function {
        template<typename BaseEnv, Override... Overrides>
        constexpr auto operator()(BaseEnv base_env, Overrides... overrides) const {
            static_assert(meta::Size<meta::Unique<meta::List<meta::Type<Overrides>...>>> == sizeof...(Overrides),
                          "di::execution::make_env() must be called with unique overrides.");
            return Env<BaseEnv, Overrides...> { util::move(base_env), util::move(overrides)... };
        }
    };
}

constexpr inline auto with = make_env_ns::WithFunction {};

constexpr inline auto without = make_env_ns::WithoutFunction {};

constexpr inline auto make_env = make_env_ns::Function {};

template<typename Tag, typename Val>
using With = make_env_ns::With<Tag, Val>;

template<typename Tag>
using Without = make_env_ns::Without<Tag>;

template<typename BaseEnv, typename... Withs>
using MakeEnv = decltype(make_env(util::declval<BaseEnv>(), util::declval<Withs>()...));
}