Container.hpp

Go to the documentation of this file.

 
#ifndef CONTAINER_TRY_HPP_
#define CONTAINER_TRY_HPP_
 
#include "configs/concepts/ChainableConfig.hpp"
#include "configs/concepts/CreationalConfig.hpp"
#include "dispatchers/CreationalConfigDispatcher.hpp"
#include "dispatchers/ChainableConfigDispatcher.hpp"
#include "configs/ConfigClassifier.hpp"
#include "configs/inputs/NoInput.hpp"
#include "ResolutionContext.hpp"
 
#include <capymeta/primitives/Pack.hpp>
#include <capymeta/algorithms/pack/Filter.hpp>
#include <capymeta/primitives/referencing/Reference.hpp>
#include <capymeta/primitives/Functor.hpp>
#include <tuple>
#include <utility>
 
 
namespace capy::di
{

 
template<typename... Configs>
class DI
{
private:
    using ConfigsPack = meta::Pack<Configs...>;
    using CreationalConfigsPack = meta::pack_filter_t<
        ConfigsPack,
        meta::template_fv<IsCreationalConfig, meta::MetaArity::N1>
    >;
    using ChainableConfigsPack = meta::pack_filter_t<
        ConfigsPack,
        meta::template_fv<IsChainableConfig, meta::MetaArity::N1>
    >;
    
    using CreationalDispatcherType = meta::rebind_pack_t<
        CreationalConfigsPack, 
        CreationalConfigDispatcher
    >; 
    
    using ChainableDispatcherType = meta::rebind_pack_t<
        ChainableConfigsPack, 
        ChainableConfigDispatcher
    >;
 
public:
    explicit constexpr DI(Configs&&... configs)
        : creational_dispatcher_ { make_dispatcher(
            meta::Unit<CreationalDispatcherType>{},
            filter_configs(
                meta::UnaryMetaFunction<IsCreationalConfig>{},
                configs...
            )
        )}
        , chainable_dispatcher_ { make_dispatcher(
            meta::Unit<ChainableDispatcherType>{},
            filter_configs(
                meta::UnaryMetaFunction<IsChainableConfig>{},
                configs...
            )
        )}
    {}
 
public: 
    template<
        typename Type, 
        typename KeyPack = meta::Pack<Type>, 
        typename InputType = std::tuple<>
    >
    [[nodiscard]] constexpr Resolution<Type, Error> auto 
        resolve(InputType&& input = std::tuple{}) const
    {
        /* TODO: implement dispatcher for retrieving key */
        // using /* meta::Pack<?> */ KeyPack = meta::Pack<Type>;
 
        ResolutionContext context {
            .input = std::move(input),
            .container = *this,
            .flags = ResolutionFlags{},
        };
 
        return this->creational_dispatcher_
            .template resolve<Type, KeyPack>(context)
            .and_then([this, &context](meta::Reference<Type> auto entity) {
                return this->chainable_dispatcher_
                    .template apply_configs_chain<KeyPack, Type>(
                        entity, 
                        context
                    );
            });
    }
 
private:
    template<typename Dispatcher, typename... Configs_> 
    [[nodiscard]] static constexpr Dispatcher 
        make_dispatcher(
            meta::Unit<Dispatcher>&&, 
            std::tuple<Configs_...>&& configs_tuple
        )
    {
        return std::apply(
            [](auto&&... configs) {
                return Dispatcher(
                    std::forward<decltype(configs)>(configs)...
                );
            }, 
            std::move(configs_tuple)
        );
    }
 
private:
    CreationalDispatcherType creational_dispatcher_;
    ChainableDispatcherType chainable_dispatcher_;
};
 
}
 
#endif // !CONTAINER_TRY_HPP_