/*
* Copyright 2014 Google Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef FRUIT_COMPONENT_FUNCTORS_DEFN_H
#define FRUIT_COMPONENT_FUNCTORS_DEFN_H
#include <fruit/component.h>
#include <fruit/impl/injection_debug_errors.h>
#include <fruit/impl/injection_errors.h>
#include <fruit/impl/injector/injector_storage.h>
#include <memory>
/*********************************************************************************************************************************
This file contains functors that take a Comp and return a struct Op with the form:
struct {
using Result = Comp1;
void operator()(FixedSizeVector<ComponentStorageEntry>& entries) {...}
std::size_t numEntries() {...}
}
*********************************************************************************************************************************/
namespace fruit {
namespace impl {
namespace meta {
struct GetResult {
template <typename F>
struct apply {
using type = typename F::Result;
};
};
// Call(ComponentFunctor(F, Args...), Comp)
// is equivalent to:
// F(Comp, Args...)
struct ComponentFunctor {
template <typename F, typename... Args>
struct apply {
struct type {
template <typename Comp>
struct apply {
using type = F(Comp, Args...);
};
};
};
};
struct ComponentFunctorIdentity {
template <typename Comp>
struct apply {
struct type {
using Result = Comp;
void operator()(FixedSizeVector<ComponentStorageEntry>&) {}
std::size_t numEntries() {
return 0;
}
};
};
};
struct Compose2ComponentFunctors {
template <typename F1, typename F2>
struct apply {
struct type {
template <typename Comp>
struct apply {
using Op1 = F1(Comp);
using Op2 = F2(GetResult(Op1));
struct Op {
using Result = Eval<GetResult(Op2)>;
void operator()(FixedSizeVector<ComponentStorageEntry>& entries) {
Eval<Op2>()(entries);
Eval<Op1>()(entries);
}
std::size_t numEntries() {
return Eval<Op1>().numEntries() + Eval<Op2>().numEntries();
}
};
using type = PropagateError(Op1, PropagateError(Op2, Op));
};
};
};
};
// ComposeFunctors(F1,..,Fn) returns a functor that executes F1,..,Fn in order (stopping at the
// first Error).
struct ComposeFunctors {
template <typename... Functors>
struct apply {
using type = Fold(Compose2ComponentFunctors, ComponentFunctorIdentity, Functors...);
};
};
// ReverseComposeFunctors(T1, ..., Tn) is equivalent to ComposeFunctors(Tn, ..., T1), but it's more
// efficient when all of the following must be evaluated:
// ReverseComposeFunctors<T1>
// ReverseComposeFunctors<T2, T1>
// ReverseComposeFunctors<T3, T2, T1>
// In that case, this implementation shares many more instantiations with previous invocations
struct ReverseComposeFunctors {
template <typename... Functors>
struct apply {
using type = ComponentFunctorIdentity;
};
template <typename Functor>
struct apply<Functor> {
using type = Functor;
};
template <typename Functor, typename... Functors>
struct apply<Functor, Functors...> {
using type = Compose2ComponentFunctors(ReverseComposeFunctors(Functors...), Functor);
};
};
struct EnsureProvidedType;
struct EnsureProvidedTypes;
// Doesn't actually bind in ComponentStorage. The binding is added later (if needed) using ProcessInterfaceBinding.
struct AddDeferredInterfaceBinding {
template <typename Comp, typename AnnotatedI, typename AnnotatedC>
struct apply {
using Comp1 = ConsComp(typename Comp::RsSuperset, typename Comp::Ps, typename Comp::NonConstRsPs,
#if !FRUIT_NO_LOOP_CHECK
typename Comp::Deps,
#endif
PushFront(typename Comp::InterfaceBindings, Pair<AnnotatedI, AnnotatedC>),
typename Comp::DeferredBindingFunctors);
struct Op {
// Note that we do NOT call AddProvidedType here. We'll only know the right required type
// when the binding will be used.
using Result = Eval<Comp1>;
void operator()(FixedSizeVector<ComponentStorageEntry>&) {}
std::size_t numEntries() {
return 0;
}
};
using I = RemoveAnnotations(AnnotatedI);
using C = RemoveAnnotations(AnnotatedC);
using type =
If(IsSame(I, C), ConstructError(InterfaceBindingToSelfErrorTag, C),
If(Not(IsBaseOf(I, C)), ConstructError(NotABaseClassOfErrorTag, I, C),
If(Not(IsSame(I, NormalizeType(I))), ConstructError(NonClassTypeErrorTag, I, NormalizeUntilStable(I)),
If(Not(IsSame(C, NormalizeType(C))),
// We handle this case too, just to be on the safe side, but this should never happen.
ConstructError(NonClassTypeErrorTag, C, NormalizeUntilStable(C)),
If(IsInSet(AnnotatedI, typename Comp::Ps), ConstructError(TypeAlreadyBoundErrorTag, AnnotatedI),
If(MapContainsKey(typename Comp::InterfaceBindings, AnnotatedI),
ConstructError(TypeAlreadyBoundErrorTag, AnnotatedI), Op))))));
};
};
struct ProcessInterfaceBinding {
template <typename Comp, typename AnnotatedI, typename AnnotatedC, typename NonConstBindingRequired>
struct apply {
using R = If(NonConstBindingRequired,
AddProvidedTypeIgnoringInterfaceBindings(Comp, AnnotatedI, NonConstBindingRequired, Vector<AnnotatedC>,
Vector<AnnotatedC>),
AddProvidedTypeIgnoringInterfaceBindings(Comp, AnnotatedI, NonConstBindingRequired, Vector<AnnotatedC>,
Vector<>));
struct ConstOp {
// This must be here (and not in AddDeferredInterfaceBinding) because the binding might be
// used to bind functors instead, so we might never need to add C to the requirements.
using Result = Eval<R>;
void operator()(FixedSizeVector<ComponentStorageEntry>& entries) {
entries.push_back(
InjectorStorage::createComponentStorageEntryForConstBind<UnwrapType<AnnotatedI>, UnwrapType<AnnotatedC>>());
};
std::size_t numEntries() {
return 1;
}
};
struct NonConstOp {
// This must be here (and not in AddDeferredInterfaceBinding) because the binding might be
// used to bind functors instead, so we might never need to add C to the requirements.
using Result = Eval<R>;
void operator()(FixedSizeVector<ComponentStorageEntry>& entries) {
entries.push_back(
InjectorStorage::createComponentStorageEntryForBind<UnwrapType<AnnotatedI>, UnwrapType<AnnotatedC>>());
};
std::size_t numEntries() {
return 1;
}
};
using type = PropagateError(R, If(NonConstBindingRequired, NonConstOp, ConstOp));
};
};
struct AddInterfaceMultibinding {
template <typename Comp, typename AnnotatedI, typename AnnotatedC>
struct apply {
using I = RemoveAnnotations(AnnotatedI);
using C = RemoveAnnotations(AnnotatedC);
using R = AddRequirements(Comp, Vector<AnnotatedC>, Vector<AnnotatedC>);
struct Op {
using Result = Eval<R>;
void operator()(FixedSizeVector<ComponentStorageEntry>& entries) {
entries.push_back(InjectorStorage::createComponentStorageEntryForMultibinding<UnwrapType<AnnotatedI>,
UnwrapType<AnnotatedC>>());
entries.push_back(
InjectorStorage::createComponentStorageEntryForMultibindingVectorCreator<UnwrapType<AnnotatedI>>());
};
std::size_t numEntries() {
return 2;
}
};
using type = If(Not(IsBaseOf(I, C)), ConstructError(NotABaseClassOfErrorTag, I, C), Op);
};
};
template <typename AnnotatedSignature, typename Lambda, typename OptionalAnnotatedI>
struct PostProcessRegisterProviderHelper;
template <typename AnnotatedSignature, typename Lambda, typename AnnotatedI>
struct PostProcessRegisterProviderHelper;
template <typename AnnotatedSignature, typename Lambda, typename AnnotatedI>
struct PostProcessRegisterProviderHelper<AnnotatedSignature, Lambda, Type<AnnotatedI>> {
inline void operator()(FixedSizeVector<ComponentStorageEntry>& entries) {
entries.push_back(
InjectorStorage::createComponentStorageEntryForCompressedProvider<AnnotatedSignature, Lambda, AnnotatedI>());
entries.push_back(InjectorStorage::createComponentStorageEntryForProvider<AnnotatedSignature, Lambda>());
}
std::size_t numEntries() {
return 2;
}
};
template <typename AnnotatedSignature, typename Lambda>
struct PostProcessRegisterProviderHelper<AnnotatedSignature, Lambda, None> {
inline void operator()(FixedSizeVector<ComponentStorageEntry>& entries) {
entries.push_back(InjectorStorage::createComponentStorageEntryForProvider<AnnotatedSignature, Lambda>());
}
std::size_t numEntries() {
return 1;
}
};
// T can't be any injectable type, it must match the return type of the provider in one of
// the registerProvider() overloads in ComponentStorage.
struct PostProcessRegisterProvider {
template <typename Comp, typename AnnotatedSignature, typename Lambda>
struct apply {
using AnnotatedC = NormalizeType(SignatureType(AnnotatedSignature));
using OptionalAnnotatedI = FindValueInMap(typename Comp::InterfaceBindings, AnnotatedC);
struct Op {
using Result = Comp;
using Helper = PostProcessRegisterProviderHelper<UnwrapType<AnnotatedSignature>, UnwrapType<Lambda>,
Eval<OptionalAnnotatedI>>;
void operator()(FixedSizeVector<ComponentStorageEntry>& entries) {
Helper()(entries);
}
std::size_t numEntries() {
return Helper().numEntries();
}
};
using type = Op;
};
};
struct PreProcessRegisterProvider {
template <typename Comp, typename AnnotatedSignature, typename Lambda>
struct apply {
using Signature = RemoveAnnotationsFromSignature(AnnotatedSignature);
using SignatureFromLambda = FunctionSignature(Lambda);
using AnnotatedC = NormalizeType(SignatureType(AnnotatedSignature));
using AnnotatedCDeps = NormalizeTypeVector(SignatureArgs(AnnotatedSignature));
using R = AddProvidedType(Comp, AnnotatedC, Bool<true>, AnnotatedCDeps,
Id<NormalizedNonConstTypesIn(SignatureArgs(AnnotatedSignature))>);
using type =
If(Not(IsSame(Signature, SignatureFromLambda)),
ConstructError(AnnotatedSignatureDifferentFromLambdaSignatureErrorTag, Signature, SignatureFromLambda),
PropagateError(
CheckInjectableType(RemoveAnnotations(SignatureType(AnnotatedSignature))),
PropagateError(
CheckInjectableTypeVector(RemoveAnnotationsFromVector(AnnotatedCDeps)),
PropagateError(
CheckInjectableType(SignatureType(SignatureFromLambda)),
PropagateError(
CheckInjectableTypeVector(SignatureArgs(SignatureFromLambda)),
If(And(IsPointer(SignatureType(SignatureFromLambda)),
And(IsAbstract(RemovePointer(SignatureType(SignatureFromLambda))),
Not(HasVirtualDestructor(RemovePointer(SignatureType(SignatureFromLambda)))))),
ConstructError(ProviderReturningPointerToAbstractClassWithNoVirtualDestructorErrorTag,
RemovePointer(SignatureType(SignatureFromLambda))),
ComponentFunctorIdentity(R)))))));
};
};
// The registration is actually deferred until the PartialComponent is converted to a component.
struct DeferredRegisterProviderWithAnnotations {
template <typename Comp, typename AnnotatedSignature, typename Lambda>
struct apply {
using Comp1 = AddDeferredBinding(Comp, ComponentFunctor(PostProcessRegisterProvider, AnnotatedSignature, Lambda));
using type = PreProcessRegisterProvider(Comp1, AnnotatedSignature, Lambda);
};
};
// The registration is actually deferred until the PartialComponent is converted to a component.
struct DeferredRegisterProvider {
template <typename Comp, typename Lambda>
struct apply {
using type = DeferredRegisterProviderWithAnnotations(Comp, FunctionSignature(Lambda), Lambda);
};
};
// T can't be any injectable type, it must match the return type of the provider in one of
// the registerMultibindingProvider() overloads in ComponentStorage.
struct RegisterMultibindingProviderWithAnnotations {
template <typename Comp, typename AnnotatedSignature, typename Lambda>
struct apply {
using Signature = RemoveAnnotationsFromSignature(AnnotatedSignature);
using SignatureFromLambda = FunctionSignature(Lambda);
using AnnotatedArgs = SignatureArgs(AnnotatedSignature);
using AnnotatedArgVector = NormalizeTypeVector(AnnotatedArgs);
using NonConstRequirements = NormalizedNonConstTypesIn(AnnotatedArgs);
using R = AddRequirements(Comp, AnnotatedArgVector, NonConstRequirements);
struct Op {
using Result = Eval<R>;
void operator()(FixedSizeVector<ComponentStorageEntry>& entries) {
entries.push_back(
InjectorStorage::createComponentStorageEntryForMultibindingProvider<UnwrapType<AnnotatedSignature>,
UnwrapType<Lambda>>());
entries.push_back(InjectorStorage::createComponentStorageEntryForMultibindingVectorCreator<
UnwrapType<Eval<NormalizeType(SignatureType(AnnotatedSignature))>>>());
}
std::size_t numEntries() {
return 2;
}
};
using type = If(
Not(IsValidSignature(AnnotatedSignature)), ConstructError(NotASignatureErrorTag, AnnotatedSignature),
PropagateError(
CheckInjectableType(RemoveAnnotations(SignatureType(AnnotatedSignature))),
PropagateError(
CheckInjectableTypeVector(RemoveAnnotationsFromVector(SignatureArgs(AnnotatedSignature))),
PropagateError(
CheckInjectableType(SignatureType(SignatureFromLambda)),
PropagateError(
CheckInjectableTypeVector(SignatureArgs(SignatureFromLambda)),
If(IsAbstract(RemoveAnnotations(SignatureType(AnnotatedSignature))),
ConstructError(CannotConstructAbstractClassErrorTag,
RemoveAnnotations(SignatureType(AnnotatedSignature))),
If(Not(IsSame(Signature, SignatureFromLambda)),
ConstructError(AnnotatedSignatureDifferentFromLambdaSignatureErrorTag, Signature,
SignatureFromLambda),
If(And(IsPointer(SignatureType(SignatureFromLambda)),
And(IsAbstract(RemovePointer(SignatureType(SignatureFromLambda))),
Not(HasVirtualDestructor(RemovePointer(SignatureType(SignatureFromLambda)))))),
ConstructError(
MultibindingProviderReturningPointerToAbstractClassWithNoVirtualDestructorErrorTag,
RemovePointer(SignatureType(SignatureFromLambda))),
PropagateError(R, Op)))))))));
};
};
// T can't be any injectable type, it must match the return type of the provider in one of
// the registerMultibindingProvider() overloads in ComponentStorage.
struct RegisterMultibindingProvider {
template <typename Comp, typename Lambda>
struct apply {
using type = RegisterMultibindingProviderWithAnnotations(Comp, FunctionSignature(Lambda), Lambda);
};
};
// Non-assisted case.
template <int numAssistedBefore, int numNonAssistedBefore, typename Arg>
struct GetAssistedArg {
template <typename InjectedArgsTuple, typename UserProvidedArgsTuple>
inline Arg operator()(InjectedArgsTuple& injected_args, UserProvidedArgsTuple&) {
return std::get<numNonAssistedBefore>(injected_args);
}
};
// Assisted case.
template <int numAssistedBefore, int numNonAssistedBefore, typename Arg>
struct GetAssistedArg<numAssistedBefore, numNonAssistedBefore, Assisted<Arg>> {
template <typename InjectedArgsTuple, typename UserProvidedArgsTuple>
inline Arg operator()(InjectedArgsTuple&, UserProvidedArgsTuple& user_provided_args) {
return std::get<numAssistedBefore>(user_provided_args);
}
};
struct RegisterFactoryHelper {
template <typename Comp, typename DecoratedSignature, typename Lambda,
// std::function<InjectedSignature> is the injected type (possibly with an Annotation<> wrapping it)
typename InjectedSignature, typename RequiredLambdaSignature, typename InjectedAnnotatedArgs,
// The types that are injected, unwrapped from any Annotation<>.
typename InjectedArgs, typename IndexSequence>
struct apply;
template <typename Comp, typename DecoratedSignature, typename Lambda, typename NakedC,
typename... NakedUserProvidedArgs, typename... NakedAllArgs, typename... InjectedAnnotatedArgs,
typename... NakedInjectedArgs, typename... Indexes>
struct apply<Comp, DecoratedSignature, Lambda, Type<NakedC(NakedUserProvidedArgs...)>, Type<NakedC(NakedAllArgs...)>,
Vector<InjectedAnnotatedArgs...>, Vector<Type<NakedInjectedArgs>...>, Vector<Indexes...>> {
// Here we call "decorated" the types that might be wrapped in Annotated<> or Assisted<>,
// while we call "annotated" the ones that might only be wrapped in Annotated<> (but not Assisted<>).
using AnnotatedT = SignatureType(DecoratedSignature);
using T = RemoveAnnotations(AnnotatedT);
using DecoratedArgs = SignatureArgs(DecoratedSignature);
using NakedInjectedSignature = NakedC(NakedUserProvidedArgs...);
using NakedRequiredSignature = NakedC(NakedAllArgs...);
using NakedFunctor = std::function<NakedInjectedSignature>;
// This is usually the same as Functor, but this might be annotated.
using AnnotatedFunctor = CopyAnnotation(AnnotatedT, Type<NakedFunctor>);
using FunctorDeps = NormalizeTypeVector(Vector<InjectedAnnotatedArgs...>);
using FunctorNonConstDeps = NormalizedNonConstTypesIn(Vector<InjectedAnnotatedArgs...>);
using R = AddProvidedType(Comp, AnnotatedFunctor, Bool<true>, FunctorDeps, FunctorNonConstDeps);
struct Op {
using Result = Eval<R>;
void operator()(FixedSizeVector<ComponentStorageEntry>& entries) {
auto function_provider = [](NakedInjectedArgs... args) {
auto injected_args = std::make_tuple(args...);
auto object_provider = [injected_args](NakedUserProvidedArgs... params) mutable {
auto user_provided_args = std::tie(params...);
// These are unused if they are 0-arg tuples. Silence the unused-variable warnings anyway.
(void)injected_args;
(void)user_provided_args;
return LambdaInvoker::invoke<UnwrapType<Lambda>, NakedAllArgs...>(
GetAssistedArg<
Eval<NumAssistedBefore(Indexes, DecoratedArgs)>::value,
getIntValue<Indexes>() - Eval<NumAssistedBefore(Indexes, DecoratedArgs)>::value,
// Note that the Assisted<> wrapper (if any) remains, we just remove any wrapping Annotated<>.
UnwrapType<Eval<RemoveAnnotations(GetNthType(Indexes, DecoratedArgs))>>>()(injected_args,
user_provided_args)...);
};
return NakedFunctor(object_provider);
};
entries.push_back(InjectorStorage::createComponentStorageEntryForProvider<
UnwrapType<Eval<ConsSignatureWithVector(AnnotatedFunctor, Vector<InjectedAnnotatedArgs...>)>>,
decltype(function_provider)>());
}
std::size_t numEntries() {
return 1;
}
};
// The first two IsValidSignature checks are a bit of a hack, they are needed to make the F2/RealF2 split
// work in the caller (we need to allow Lambda to be a function type).
using type = If(Not(IsSame(Type<NakedRequiredSignature>, FunctionSignature(Lambda))),
ConstructError(FunctorSignatureDoesNotMatchErrorTag, Type<NakedRequiredSignature>,
FunctionSignature(Lambda)),
If(IsPointer(T), ConstructError(FactoryReturningPointerErrorTag, DecoratedSignature),
PropagateError(R, Op)));
};
};
struct RegisterFactory {
template <typename Comp, typename DecoratedSignature, typename Lambda>
struct apply {
using LambdaReturnType = SignatureType(FunctionSignature(Lambda));
using type =
If(Not(IsValidSignature(DecoratedSignature)), ConstructError(NotASignatureErrorTag, DecoratedSignature),
PropagateError(
CheckInjectableType(RemoveAnnotations(SignatureType(DecoratedSignature))),
PropagateError(
CheckInjectableTypeVector(
RemoveAnnotationsFromVector(RemoveAssisted(SignatureArgs(DecoratedSignature)))),
If(IsAbstract(RemoveAnnotations(SignatureType(DecoratedSignature))),
// We error out early in this case. Calling RegisterFactoryHelper would also produce an error, but
// it'd be
// much less user-friendly.
ConstructError(CannotConstructAbstractClassErrorTag,
RemoveAnnotations(SignatureType(DecoratedSignature))),
If(Not(Or(IsEmpty(Lambda), IsValidSignature(Lambda))),
ConstructError(LambdaWithCapturesErrorTag, Lambda),
If(Not(Or(IsTriviallyCopyable(Lambda), IsValidSignature(Lambda))),
ConstructError(NonTriviallyCopyableLambdaErrorTag, Lambda),
If(And(IsUniquePtr(LambdaReturnType),
And(IsAbstract(RemoveUniquePtr(LambdaReturnType)),
Not(HasVirtualDestructor(RemoveUniquePtr(LambdaReturnType))))),
ConstructError(RegisterFactoryForUniquePtrOfAbstractClassWithNoVirtualDestructorErrorTag,
RemoveUniquePtr(LambdaReturnType)),
RegisterFactoryHelper(
Comp, DecoratedSignature, Lambda,
InjectedSignatureForAssistedFactory(DecoratedSignature),
RequiredLambdaSignatureForAssistedFactory(DecoratedSignature),
RemoveAssisted(SignatureArgs(DecoratedSignature)),
RemoveAnnotationsFromVector(RemoveAssisted(SignatureArgs(DecoratedSignature))),
GenerateIntSequence(
VectorSize(RequiredLambdaArgsForAssistedFactory(DecoratedSignature)))))))))));
};
};
struct PostProcessRegisterConstructor;
template <typename AnnotatedSignature, typename OptionalAnnotatedI>
struct PostProcessRegisterConstructorHelper;
template <typename AnnotatedSignature, typename AnnotatedI>
struct PostProcessRegisterConstructorHelper;
template <typename AnnotatedSignature, typename AnnotatedI>
struct PostProcessRegisterConstructorHelper<AnnotatedSignature, Type<AnnotatedI>> {
inline void operator()(FixedSizeVector<ComponentStorageEntry>& entries) {
entries.push_back(
InjectorStorage::createComponentStorageEntryForCompressedConstructor<AnnotatedSignature, AnnotatedI>());
entries.push_back(InjectorStorage::createComponentStorageEntryForConstructor<AnnotatedSignature>());
}
std::size_t numEntries() {
return 2;
}
};
template <typename AnnotatedSignature>
struct PostProcessRegisterConstructorHelper<AnnotatedSignature, None> {
inline void operator()(FixedSizeVector<ComponentStorageEntry>& entries) {
entries.push_back(InjectorStorage::createComponentStorageEntryForConstructor<AnnotatedSignature>());
}
std::size_t numEntries() {
return 1;
}
};
struct PostProcessRegisterConstructor {
template <typename Comp, typename AnnotatedSignature>
struct apply {
struct type {
using AnnotatedC = NormalizeType(SignatureType(AnnotatedSignature));
using Result = Comp;
using Helper =
PostProcessRegisterConstructorHelper<UnwrapType<AnnotatedSignature>,
Eval<FindValueInMap(typename Comp::InterfaceBindings, AnnotatedC)>>;
void operator()(FixedSizeVector<ComponentStorageEntry>& entries) {
Helper()(entries);
}
std::size_t numEntries() {
return Helper().numEntries();
}
};
};
};
struct PreProcessRegisterConstructor {
template <typename Comp, typename AnnotatedSignature>
struct apply {
using Signature = RemoveAnnotationsFromSignature(AnnotatedSignature);
using C = SignatureType(Signature);
using Args = SignatureArgs(Signature);
using AnnotatedT = SignatureType(AnnotatedSignature);
using AnnotatedArgs = SignatureArgs(AnnotatedSignature);
using AnnotatedC = NormalizeType(AnnotatedT);
using CDeps = NormalizeTypeVector(AnnotatedArgs);
using CNonConstDeps = NormalizedNonConstTypesIn(AnnotatedArgs);
using R = AddProvidedType(Comp, AnnotatedC, Bool<true>, CDeps, CNonConstDeps);
using type = If(
Not(IsValidSignature(AnnotatedSignature)), ConstructError(NotASignatureErrorTag, AnnotatedSignature),
PropagateError(CheckInjectableType(RemoveAnnotations(C)),
PropagateError(CheckInjectableTypeVector(RemoveAnnotationsFromVector(Args)),
If(IsAbstract(RemoveAnnotations(SignatureType(AnnotatedSignature))),
ConstructError(CannotConstructAbstractClassErrorTag,
RemoveAnnotations(SignatureType(AnnotatedSignature))),
If(Not(IsConstructibleWithVector(C, Args)),
ConstructError(NoConstructorMatchingInjectSignatureErrorTag, C, Signature),
PropagateError(R, ComponentFunctorIdentity(R)))))));
};
};
struct DeferredRegisterConstructor {
template <typename Comp, typename AnnotatedSignature>
struct apply {
using Comp1 = AddDeferredBinding(Comp, ComponentFunctor(PostProcessRegisterConstructor, AnnotatedSignature));
using type = PreProcessRegisterConstructor(Comp1, AnnotatedSignature);
};
};
struct RegisterInstance {
template <typename Comp, typename AnnotatedC, typename C, typename IsNonConst>
struct apply {
using R = AddProvidedType(Comp, AnnotatedC, IsNonConst, Vector<>, Vector<>);
struct Op {
using Result = Eval<R>;
void operator()(FixedSizeVector<ComponentStorageEntry>&) {}
std::size_t numEntries() {
return 0;
}
};
using type = PropagateError(
CheckNormalizedTypes(ConsVector(RemoveAnnotations(AnnotatedC))),
PropagateError(
CheckNormalizedTypes(ConsVector(C)),
If(Not(IsSame(C, NormalizeType(C))), ConstructError(NonClassTypeErrorTag, C, NormalizeUntilStable(C)),
If(Not(IsSame(RemoveAnnotations(AnnotatedC), NormalizeType(RemoveAnnotations(AnnotatedC)))),
ConstructError(NonClassTypeErrorTag, RemoveAnnotations(AnnotatedC),
NormalizeUntilStable(RemoveAnnotations(C))),
// The IsSame check is not redundant because IsBaseOf returns false for non-class types (e.g. int).
If(Not(Or(IsSame(RemoveAnnotations(AnnotatedC), C), IsBaseOf(RemoveAnnotations(AnnotatedC), C))),
ConstructError(TypeMismatchInBindInstanceErrorTag, RemoveAnnotations(AnnotatedC), C),
PropagateError(R, Op))))));
};
};
struct RegisterConstructorAsValueFactory {
template <typename Comp, typename DecoratedSignature,
typename RequiredSignature = Eval<RequiredLambdaSignatureForAssistedFactory(DecoratedSignature)>>
struct apply;
template <typename Comp, typename DecoratedSignature, typename NakedT, typename... NakedArgs>
struct apply<Comp, DecoratedSignature, Type<NakedT(NakedArgs...)>> {
using RequiredSignature = Type<NakedT(NakedArgs...)>;
using Op1 = RegisterFactory(Comp, DecoratedSignature, RequiredSignature);
struct Op {
using Result = Eval<GetResult(Op1)>;
void operator()(FixedSizeVector<ComponentStorageEntry>& entries) {
auto provider = [](NakedArgs... args) { return NakedT(std::forward<NakedArgs>(args)...); };
using RealOp = RegisterFactory(Comp, DecoratedSignature, Type<decltype(provider)>);
FruitStaticAssert(IsSame(GetResult(Op1), GetResult(RealOp)));
Eval<RealOp>()(entries);
}
std::size_t numEntries() {
#if FRUIT_EXTRA_DEBUG
auto provider = [](NakedArgs... args) { return NakedT(std::forward<NakedArgs>(args)...); };
using RealOp = RegisterFactory(Comp, DecoratedSignature, Type<decltype(provider)>);
FruitAssert(Eval<Op1>().numEntries() == Eval<RealOp>().numEntries());
#endif
return Eval<Op1>().numEntries();
}
};
using type = PropagateError(Op1, Op);
};
};
struct RegisterConstructorAsUniquePtrFactory {
template <typename Comp, typename DecoratedSignature,
typename RequiredSignature = Eval<RequiredLambdaSignatureForAssistedFactory(DecoratedSignature)>>
struct apply;
template <typename Comp, typename DecoratedSignature, typename NakedT, typename... NakedArgs>
struct apply<Comp, DecoratedSignature, Type<std::unique_ptr<NakedT>(NakedArgs...)>> {
using RequiredSignature = Type<std::unique_ptr<NakedT>(NakedArgs...)>;
using Op1 = RegisterFactory(Comp, DecoratedSignature, RequiredSignature);
struct Op {
using Result = Eval<GetResult(Op1)>;
void operator()(FixedSizeVector<ComponentStorageEntry>& entries) {
auto provider = [](NakedArgs... args) {
return std::unique_ptr<NakedT>(new NakedT(std::forward<NakedArgs>(args)...));
};
using RealOp = RegisterFactory(Comp, DecoratedSignature, Type<decltype(provider)>);
FruitStaticAssert(IsSame(GetResult(Op1), GetResult(RealOp)));
Eval<RealOp>()(entries);
};
std::size_t numEntries() {
#if FRUIT_EXTRA_DEBUG
auto provider = [](NakedArgs... args) {
return std::unique_ptr<NakedT>(new NakedT(std::forward<NakedArgs>(args)...));
};
using RealOp = RegisterFactory(Comp, DecoratedSignature, Type<decltype(provider)>);
FruitAssert(Eval<Op1>().numEntries() == Eval<RealOp>().numEntries());
#endif
return Eval<Op1>().numEntries();
}
};
using type = PropagateError(Op1, Op);
};
};
struct InstallComponent {
template <typename Comp, typename OtherComp>
struct apply {
using new_RsSuperset = SetUnion(typename OtherComp::RsSuperset, typename Comp::RsSuperset);
using new_Ps = SetUncheckedUnion(typename OtherComp::Ps, typename Comp::Ps);
using new_NonConstRsPs = SetUnion(typename OtherComp::NonConstRsPs, typename Comp::NonConstRsPs);
#if !FRUIT_NO_LOOP_CHECK
using new_Deps = ConcatVectors(typename OtherComp::Deps, typename Comp::Deps);
#endif
FruitStaticAssert(IsSame(typename OtherComp::InterfaceBindings, Vector<>));
using new_InterfaceBindings = typename Comp::InterfaceBindings;
FruitStaticAssert(IsSame(typename OtherComp::DeferredBindingFunctors, EmptyList));
using new_DeferredBindingFunctors = typename Comp::DeferredBindingFunctors;
using R = ConsComp(new_RsSuperset, new_Ps, new_NonConstRsPs,
#if !FRUIT_NO_LOOP_CHECK
new_Deps,
#endif
new_InterfaceBindings, new_DeferredBindingFunctors);
struct Op {
using Result = Eval<R>;
void operator()(FixedSizeVector<ComponentStorageEntry>&) {}
std::size_t numEntries() {
return 0;
}
};
using InterfacePs = VectorToSetUnchecked(GetMapKeys(typename Comp::InterfaceBindings));
using AllPs = SetUncheckedUnion(InterfacePs, typename Comp::Ps);
using DuplicateTypes = SetIntersection(typename OtherComp::Ps, AllPs);
using CompConstPs = SetDifference(typename Comp::Ps, typename Comp::NonConstRsPs);
using CompRs = SetDifference(typename Comp::RsSuperset, typename Comp::Ps);
using CompNonConstRs = SetIntersection(CompRs, typename Comp::NonConstRsPs);
using OtherCompConstPs = SetDifference(typename OtherComp::Ps, typename OtherComp::NonConstRsPs);
using OtherCompRs = SetDifference(typename OtherComp::RsSuperset, typename OtherComp::Ps);
using OtherCompNonConstRs = SetIntersection(OtherCompRs, typename OtherComp::NonConstRsPs);
using type = If(Not(IsDisjoint(typename OtherComp::Ps, AllPs)),
ConstructErrorWithArgVector(DuplicateTypesInComponentErrorTag, SetToVector(DuplicateTypes)),
If(Not(IsDisjoint(CompConstPs, OtherCompNonConstRs)),
ConstructError(NonConstBindingRequiredButConstBindingProvidedErrorTag,
GetArbitrarySetElement(SetIntersection(CompConstPs, OtherCompNonConstRs))),
If(Not(IsDisjoint(CompNonConstRs, OtherCompConstPs)),
ConstructError(NonConstBindingRequiredButConstBindingProvidedErrorTag,
GetArbitrarySetElement(SetIntersection(CompNonConstRs, OtherCompConstPs))),
Op)));
};
};
struct InstallComponentHelper {
template <typename Comp, typename... OtherCompParams>
struct apply {
using OtherComp = ConstructComponentImpl(OtherCompParams...);
using type = InstallComponent(Comp, OtherComp);
};
};
struct InstallComponentFunctions {
template <typename Comp, typename... ComponentFunctions>
struct apply;
template <typename Comp>
struct apply<Comp> {
using type = ComponentFunctorIdentity(Comp);
};
template <typename Comp, typename... ComponentParams, typename... ComponentFunctionArgs, typename... ComponentFunctions>
struct apply<Comp, Type<fruit::ComponentFunction<fruit::Component<ComponentParams...>, ComponentFunctionArgs...>>, ComponentFunctions...> {
using type =
Call(
Compose2ComponentFunctors(
ComponentFunctor(InstallComponent, ConstructComponentImpl(Type<ComponentParams>...)),
ComponentFunctor(InstallComponentFunctions, ComponentFunctions...)),
Comp);
};
template <typename Comp, typename T, typename... ComponentFunctions>
struct apply<Comp, T, ComponentFunctions...> {
using type = ConstructError(IncorrectArgTypePassedToInstallComponentFuntionsErrorTag, T);
};
};
// CatchAll(PropagateError(Expr, Bool<false>), IsErrorExceptionHandler) evaluates to Bool<true> if Expr throws an error,
// and Bool<false> otherwise.
struct IsErrorExceptionHandler {
template <typename E>
struct apply {
using type = Bool<true>;
};
};
struct ConvertComponent {
template <typename SourceComp, typename DestComp>
struct apply {
using SourcePs = typename SourceComp::Ps;
using DestPs = typename DestComp::Ps;
using SourceRs = SetDifference(typename SourceComp::RsSuperset, typename SourceComp::Ps);
using DestRs = SetDifference(typename DestComp::RsSuperset, typename DestComp::Ps);
using NonConstSourceRs = SetIntersection(SourceRs, typename SourceComp::NonConstRsPs);
using NonConstDestPs = SetIntersection(DestPs, typename DestComp::NonConstRsPs);
using NonConstDestRs = SetIntersection(DestRs, typename DestComp::NonConstRsPs);
using ConstSourcePs = SetDifference(SourcePs, typename SourceComp::NonConstRsPs);
using ConstDestRs = SetDifference(DestRs, typename DestComp::NonConstRsPs);
// We need to register:
// * All the types provided by the new component
// * All the types required by the old component
// except:
// * The ones already provided by the old component (if they have the right constness).
// * The ones required by the new one (if they have the right constness).
using ToRegister = SetUnion(
// The types that we must provide and aren't currently provided
SetDifference(SetUnion(DestPs, SourceRs), SetUnion(DestRs, SourcePs)),
// And the ones that are currently provided as const but that we need to provide as non-const
SetIntersection(SetUnion(NonConstDestPs, NonConstSourceRs), SetUnion(ConstDestRs, ConstSourcePs)));
using NonConstTypesToRegister = SetIntersection(ToRegister, SetUnion(typename SourceComp::NonConstRsPs,
typename DestComp::NonConstRsPs));
using type = EnsureProvidedTypes(SourceComp, DestRs, NonConstDestRs, SetToVector(ToRegister),
NonConstTypesToRegister);
// Not needed, just double-checking.
// Uses FruitStaticAssert instead of FruitDelegateCheck so that it's checked only in debug mode.
#if FRUIT_EXTRA_DEBUG
FruitDelegateCheck(
If(CatchAll(PropagateError(type, PropagateError(Id<GetResult(type)>, Bool<false>)), IsErrorExceptionHandler),
// We're going to return an error soon anyway, we don't want to interfere by reporting this one.
None, CheckComponentEntails(GetResult(type), DestComp)));
#endif // FRUIT_EXTRA_DEBUG
};
};
struct ProcessDeferredBindings {
template <typename Comp>
struct apply;
template <typename RsSupersetParam, typename PsParam, typename NonConstRsPsParam,
#if !FRUIT_NO_LOOP_CHECK
typename DepsParam,
#endif
typename InterfaceBindingsParam, typename DeferredBindingFunctors>
struct apply<Comp<RsSupersetParam, PsParam, NonConstRsPsParam,
#if !FRUIT_NO_LOOP_CHECK
DepsParam,
#endif
InterfaceBindingsParam, DeferredBindingFunctors>> {
// Comp1 is the same as Comp, but without the DeferredBindingFunctors.
using Comp1 = ConsComp(RsSupersetParam, PsParam, NonConstRsPsParam,
#if !FRUIT_NO_LOOP_CHECK
DepsParam,
#endif
InterfaceBindingsParam, EmptyList);
using type = Call(FoldList(DeferredBindingFunctors, Compose2ComponentFunctors, ComponentFunctorIdentity), Comp1);
};
};
template <typename AnnotatedCFunctor, typename AnnotatedCUniquePtrFunctor>
struct AutoRegisterFactoryHelperErrorHandler {
template <typename E>
struct apply {
using type = E;
};
template <typename T>
struct apply<Error<NoBindingFoundErrorTag, T>> {
using type = If(IsSame(Type<T>, AnnotatedCFunctor), ConstructNoBindingFoundError(AnnotatedCUniquePtrFunctor),
ConstructError(NoBindingFoundErrorTag, Type<T>));
};
template <typename T1, typename T2>
struct apply<Error<NoBindingFoundForAbstractClassErrorTag, T1, T2>> {
using type = If(IsSame(Type<T1>, AnnotatedCFunctor), ConstructNoBindingFoundError(AnnotatedCUniquePtrFunctor),
ConstructError(NoBindingFoundForAbstractClassErrorTag, Type<T1>, Type<T2>));
};
};
struct AutoRegisterFactoryHelper {
// General case, no way to bind it.
template <typename Comp, typename TargetRequirements, typename TargetNonConstRequirements, typename InterfaceBinding,
typename has_inject_annotation, typename is_abstract, typename C, typename AnnotatedSignature,
typename... Args>
struct apply {
using AnnotatedC = SignatureType(AnnotatedSignature);
using CFunctor = ConsStdFunction(RemoveAnnotationsFromSignature(AnnotatedSignature));
using AnnotatedCFunctor = CopyAnnotation(AnnotatedC, CFunctor);
using type = If(IsAbstract(C), ConstructError(NoBindingFoundForAbstractClassErrorTag, AnnotatedCFunctor, C),
ConstructError(NoBindingFoundErrorTag, AnnotatedCFunctor));
};
// No way to bind it (we need this specialization too to ensure that the specialization below
// is not chosen for AnnotatedC=None).
template <typename Comp, typename TargetRequirements, typename TargetNonConstRequirements, typename unused1,
typename unused2, typename NakedI, typename AnnotatedSignature, typename... Args>
struct apply<Comp, TargetRequirements, TargetNonConstRequirements, None, unused1, unused2,
Type<std::unique_ptr<NakedI>>, AnnotatedSignature, Args...> {
using AnnotatedC = SignatureType(AnnotatedSignature);
using CFunctor = ConsStdFunction(RemoveAnnotationsFromSignature(AnnotatedSignature));
using AnnotatedCFunctor = CopyAnnotation(AnnotatedC, CFunctor);
using type = If(IsAbstract(Type<NakedI>),
ConstructError(NoBindingFoundForAbstractClassErrorTag, AnnotatedCFunctor, Type<NakedI>),
ConstructError(NoBindingFoundErrorTag, AnnotatedCFunctor));
};
// AnnotatedI has an interface binding, use it and look for a factory that returns the type that AnnotatedI is bound
// to.
template <typename Comp, typename TargetRequirements, typename TargetNonConstRequirements, typename AnnotatedC,
typename unused1, typename unused2, typename NakedI, typename AnnotatedSignature, typename... Args>
struct apply<Comp, TargetRequirements, TargetNonConstRequirements, AnnotatedC, unused1, unused2,
Type<std::unique_ptr<NakedI>>, AnnotatedSignature, Args...> {
using I = Type<NakedI>;
using AnnotatedI = CopyAnnotation(SignatureType(AnnotatedSignature), I);
using C = RemoveAnnotations(AnnotatedC);
using IFunctor = ConsStdFunction(ConsSignature(ConsUniquePtr(I), Args...));
using CFunctor = ConsStdFunction(ConsSignature(ConsUniquePtr(C), Args...));
using AnnotatedIFunctor = CopyAnnotation(AnnotatedI, IFunctor);
using AnnotatedCFunctor = CopyAnnotation(AnnotatedC, CFunctor);
using ProvidedSignature = ConsSignature(AnnotatedIFunctor,
CopyAnnotation(AnnotatedC, ConsConstReference(CFunctor)));
using LambdaSignature = ConsSignature(IFunctor, ConsConstReference(CFunctor));
using F1 = ComponentFunctor(EnsureProvidedType, TargetRequirements, TargetNonConstRequirements, AnnotatedCFunctor,
Bool<false>);
using F2 = ComponentFunctor(PreProcessRegisterProvider, ProvidedSignature, LambdaSignature);
using F3 = ComponentFunctor(PostProcessRegisterProvider, ProvidedSignature, LambdaSignature);
using R = Call(ComposeFunctors(F1, F2, F3), Comp);
struct Op {
using Result = Eval<GetResult(R)>;
void operator()(FixedSizeVector<ComponentStorageEntry>& entries) {
using NakedC = UnwrapType<Eval<C>>;
auto provider = [](const UnwrapType<Eval<CFunctor>>& fun) {
return UnwrapType<Eval<IFunctor>>([=](typename TypeUnwrapper<Args>::type... args) {
NakedC* c = fun(args...).release();
NakedI* i = static_cast<NakedI*>(c);
return std::unique_ptr<NakedI>(i);
});
};
using RealF2 = ComponentFunctor(PreProcessRegisterProvider, ProvidedSignature, Type<decltype(provider)>);
using RealF3 = ComponentFunctor(PostProcessRegisterProvider, ProvidedSignature, Type<decltype(provider)>);
using RealOp = Call(ComposeFunctors(F1, RealF2, RealF3), Comp);
FruitStaticAssert(IsSame(GetResult(RealOp), GetResult(R)));
Eval<RealOp>()(entries);
}
std::size_t numEntries() {
#if FRUIT_EXTRA_DEBUG
using NakedC = UnwrapType<Eval<C>>;
auto provider = [](const UnwrapType<Eval<CFunctor>>& fun) {
return UnwrapType<Eval<IFunctor>>([=](typename TypeUnwrapper<Args>::type... args) {
NakedC* c = fun(args...).release();
NakedI* i = static_cast<NakedI*>(c);
return std::unique_ptr<NakedI>(i);
});
};
using RealF2 = ComponentFunctor(PreProcessRegisterProvider, ProvidedSignature, Type<decltype(provider)>);
using RealF3 = ComponentFunctor(PostProcessRegisterProvider, ProvidedSignature, Type<decltype(provider)>);
using RealOp = Call(ComposeFunctors(F1, RealF2, RealF3), Comp);
FruitAssert(Eval<R>().numEntries() == Eval<RealOp>().numEntries());
#endif
return Eval<R>().numEntries();
}
};
using type = PropagateError(R, If(Not(HasVirtualDestructor(I)),
ConstructError(FactoryBindingForUniquePtrOfClassWithNoVirtualDestructorErrorTag,
IFunctor, CFunctor),
Op));
};
// C doesn't have an interface binding as interface, nor an INJECT annotation, and is not an abstract class.
// Bind std::function<unique_ptr<C>(Args...)> to std::function<C(Args...)> (possibly with annotations).
template <typename Comp, typename TargetRequirements, typename TargetNonConstRequirements, typename NakedC,
typename AnnotatedSignature, typename... Args>
struct apply<Comp, TargetRequirements, TargetNonConstRequirements, None, Bool<false>, Bool<false>,
Type<std::unique_ptr<NakedC>>, AnnotatedSignature, Args...> {
using C = Type<NakedC>;
using CFunctor = ConsStdFunction(ConsSignature(C, Args...));
using CUniquePtrFunctor = ConsStdFunction(ConsSignature(ConsUniquePtr(C), Args...));
using AnnotatedCUniquePtr = SignatureType(AnnotatedSignature);
using AnnotatedC = CopyAnnotation(AnnotatedCUniquePtr, C);
using AnnotatedCFunctor = CopyAnnotation(AnnotatedCUniquePtr, CFunctor);
using AnnotatedCUniquePtrFunctor = CopyAnnotation(AnnotatedCUniquePtr, CUniquePtrFunctor);
using AnnotatedCFunctorRef = CopyAnnotation(AnnotatedCUniquePtr, ConsConstReference(CFunctor));
using ProvidedSignature = ConsSignature(AnnotatedCUniquePtrFunctor, AnnotatedCFunctorRef);
using LambdaSignature = ConsSignature(CUniquePtrFunctor, ConsConstReference(CFunctor));
using F1 = ComponentFunctor(EnsureProvidedType, TargetRequirements, TargetNonConstRequirements, AnnotatedCFunctor,
Bool<false>);
using F2 = ComponentFunctor(PreProcessRegisterProvider, ProvidedSignature, LambdaSignature);
using F3 = ComponentFunctor(PostProcessRegisterProvider, ProvidedSignature, LambdaSignature);
using R = Call(ComposeFunctors(F1, F2, F3), Comp);
struct Op {
using Result = Eval<GetResult(R)>;
void operator()(FixedSizeVector<ComponentStorageEntry>& entries) {
auto provider = [](const UnwrapType<Eval<CFunctor>>& fun) {
return UnwrapType<Eval<CUniquePtrFunctor>>([=](typename TypeUnwrapper<Args>::type... args) {
NakedC* c = new NakedC(fun(args...));
return std::unique_ptr<NakedC>(c);
});
};
using RealF2 = ComponentFunctor(PreProcessRegisterProvider, ProvidedSignature, Type<decltype(provider)>);
using RealF3 = ComponentFunctor(PostProcessRegisterProvider, ProvidedSignature, Type<decltype(provider)>);
using RealOp = Call(ComposeFunctors(F1, RealF2, RealF3), Comp);
FruitStaticAssert(IsSame(GetResult(RealOp), GetResult(R)));
Eval<RealOp>()(entries);
}
std::size_t numEntries() {
#if FRUIT_EXTRA_DEBUG
auto provider = [](const UnwrapType<Eval<CFunctor>>& fun) {
return UnwrapType<Eval<CUniquePtrFunctor>>([=](typename TypeUnwrapper<Args>::type... args) {
NakedC* c = new NakedC(fun(args...));
return std::unique_ptr<NakedC>(c);
});
};
using RealF2 = ComponentFunctor(PreProcessRegisterProvider, ProvidedSignature, Type<decltype(provider)>);
using RealF3 = ComponentFunctor(PostProcessRegisterProvider, ProvidedSignature, Type<decltype(provider)>);
using RealOp = Call(ComposeFunctors(F1, RealF2, RealF3), Comp);
FruitAssert(Eval<R>().numEntries() == Eval<RealOp>().numEntries());
#endif
return Eval<R>().numEntries();
}
};
using ErrorHandler =
AutoRegisterFactoryHelperErrorHandler<Eval<AnnotatedCFunctor>, Eval<AnnotatedCUniquePtrFunctor>>;
// If we are about to report a NoBindingFound/NoBindingFoundForAbstractClass error for AnnotatedCFunctor,
// report one for std::function<std::unique_ptr<C>(Args...)> instead,
// otherwise we'd report an error about a type that the user doesn't expect.
using type = PropagateError(Catch(Catch(R, NoBindingFoundErrorTag, ErrorHandler),
NoBindingFoundForAbstractClassErrorTag, ErrorHandler),
Op);
};
// C has an Inject typedef, use it. unique_ptr case.
template <typename Comp, typename TargetRequirements, typename TargetNonConstRequirements, typename unused,
typename NakedC, typename AnnotatedSignature, typename... Args>
struct apply<Comp, TargetRequirements, TargetNonConstRequirements, None, Bool<true>, unused,
Type<std::unique_ptr<NakedC>>, AnnotatedSignature, Args...> {
using AnnotatedCUniquePtr = SignatureType(AnnotatedSignature);
using AnnotatedC = CopyAnnotation(AnnotatedCUniquePtr, RemoveUniquePtr(RemoveAnnotations(AnnotatedCUniquePtr)));
using DecoratedSignatureReturningValue = GetInjectAnnotation(AnnotatedC);
using DecoratedSignature = ConsSignatureWithVector(AnnotatedCUniquePtr,
SignatureArgs(DecoratedSignatureReturningValue));
using DecoratedSignatureArgs = SignatureArgs(DecoratedSignature);
using ActualSignatureInInjectionTypedef = ConsSignatureWithVector(SignatureType(DecoratedSignature),
RemoveNonAssisted(DecoratedSignatureArgs));
using NonAssistedArgs = RemoveAssisted(DecoratedSignatureArgs);
using F1 = ComponentFunctor(RegisterConstructorAsUniquePtrFactory, DecoratedSignature);
using F2 = ComponentFunctor(EnsureProvidedTypes, TargetRequirements, TargetNonConstRequirements,
NormalizeTypeVector(NonAssistedArgs), NormalizedNonConstTypesIn(NonAssistedArgs));
using type = If(Not(IsSame(AnnotatedSignature, ActualSignatureInInjectionTypedef)),
ConstructError(FunctorSignatureDoesNotMatchErrorTag, AnnotatedSignature,
ActualSignatureInInjectionTypedef),
Call(ComposeFunctors(F1, F2), Comp));
};
// C has an Inject typedef, use it. Value (not unique_ptr) case.
template <typename Comp, typename TargetRequirements, typename TargetNonConstRequirements, typename unused,
typename NakedC, typename AnnotatedSignature, typename... Args>
struct apply<Comp, TargetRequirements, TargetNonConstRequirements, None, Bool<true>, unused, Type<NakedC>,
AnnotatedSignature, Args...> {
using AnnotatedC = SignatureType(AnnotatedSignature);
using DecoratedSignature = GetInjectAnnotation(AnnotatedC);
using DecoratedSignatureArgs = SignatureArgs(DecoratedSignature);
using ActualSignatureInInjectionTypedef = ConsSignatureWithVector(SignatureType(DecoratedSignature),
RemoveNonAssisted(DecoratedSignatureArgs));
using NonAssistedArgs = RemoveAssisted(DecoratedSignatureArgs);
using F1 = ComponentFunctor(RegisterConstructorAsValueFactory, DecoratedSignature);
using F2 = ComponentFunctor(EnsureProvidedTypes, TargetRequirements, TargetNonConstRequirements,
NormalizeTypeVector(NonAssistedArgs), NormalizedNonConstTypesIn(NonAssistedArgs));
using type = If(Not(IsSame(AnnotatedSignature, ActualSignatureInInjectionTypedef)),
ConstructError(FunctorSignatureDoesNotMatchErrorTag, AnnotatedSignature,
ActualSignatureInInjectionTypedef),
Call(ComposeFunctors(F1, F2), Comp));
};
};
struct AutoRegister {
// The types in TargetRequirements will not be auto-registered.
template <typename Comp, typename TargetRequirements, typename TargetNonConstRequirements, typename AnnotatedC>
struct apply;
// Tries to register C by looking for a typedef called Inject inside C.
template <typename Comp, typename TargetRequirements, typename TargetNonConstRequirements, typename AnnotatedC>
struct apply {
using CHasInjectAnnotation = HasInjectAnnotation(RemoveAnnotations(AnnotatedC));
using Inject = GetInjectAnnotation(AnnotatedC);
using CRequirements = NormalizeTypeVector(SignatureArgs(Inject));
using CNonConstRequirements = NormalizedNonConstTypesIn(SignatureArgs(Inject));
using F = ComposeFunctors(ComponentFunctor(PreProcessRegisterConstructor, Inject),
ComponentFunctor(PostProcessRegisterConstructor, Inject),
ComponentFunctor(EnsureProvidedTypes, TargetRequirements, TargetNonConstRequirements,
CRequirements, CNonConstRequirements));
using type = If(CHasInjectAnnotation, Call(F, Comp), ConstructNoBindingFoundError(AnnotatedC));
};
template <typename Comp, typename TargetRequirements, typename TargetNonConstRequirements, typename NakedC,
typename... NakedArgs>
struct apply<Comp, TargetRequirements, TargetNonConstRequirements, Type<std::function<NakedC(NakedArgs...)>>> {
using type = AutoRegisterFactoryHelper(Comp, TargetRequirements, TargetNonConstRequirements,
FindInMap(typename Comp::InterfaceBindings, Type<NakedC>),
HasInjectAnnotation(Type<NakedC>), IsAbstract(Type<NakedC>), Type<NakedC>,
Type<NakedC(NakedArgs...)>, Id<RemoveAnnotations(Type<NakedArgs>)>...);
};
template <typename Comp, typename TargetRequirements, typename TargetNonConstRequirements, typename NakedC,
typename... NakedArgs>
struct apply<Comp, TargetRequirements, TargetNonConstRequirements,
Type<std::function<std::unique_ptr<NakedC>(NakedArgs...)>>> {
using type = AutoRegisterFactoryHelper(Comp, TargetRequirements, TargetNonConstRequirements,
FindInMap(typename Comp::InterfaceBindings, Type<NakedC>),
HasInjectAnnotation(Type<NakedC>), IsAbstract(Type<NakedC>),
Type<std::unique_ptr<NakedC>>, Type<std::unique_ptr<NakedC>(NakedArgs...)>,
Id<RemoveAnnotations(Type<NakedArgs>)>...);
};
template <typename Comp, typename TargetRequirements, typename TargetNonConstRequirements, typename Annotation,
typename NakedC, typename... NakedArgs>
struct apply<Comp, TargetRequirements, TargetNonConstRequirements,
Type<fruit::Annotated<Annotation, std::function<NakedC(NakedArgs...)>>>> {
using type = AutoRegisterFactoryHelper(Comp, TargetRequirements, TargetNonConstRequirements,
FindInMap(typename Comp::InterfaceBindings,
Type<fruit::Annotated<Annotation, NakedC>>),
HasInjectAnnotation(Type<NakedC>), IsAbstract(Type<NakedC>), Type<NakedC>,
Type<fruit::Annotated<Annotation, NakedC>(NakedArgs...)>,
Id<RemoveAnnotations(Type<NakedArgs>)>...);
};
template <typename Comp, typename TargetRequirements, typename TargetNonConstRequirements, typename Annotation,
typename NakedC, typename... NakedArgs>
struct apply<Comp, TargetRequirements, TargetNonConstRequirements,
Type<fruit::Annotated<Annotation, std::function<std::unique_ptr<NakedC>(NakedArgs...)>>>> {
using type = AutoRegisterFactoryHelper(Comp, TargetRequirements, TargetNonConstRequirements,
FindInMap(typename Comp::InterfaceBindings,
Type<fruit::Annotated<Annotation, NakedC>>),
HasInjectAnnotation(Type<NakedC>), IsAbstract(Type<NakedC>),
Type<std::unique_ptr<NakedC>>,
Type<fruit::Annotated<Annotation, std::unique_ptr<NakedC>>(NakedArgs...)>,
Id<RemoveAnnotations(Type<NakedArgs>)>...);
};
};
template <typename AnnotatedT>
struct EnsureProvidedTypeErrorHandler {
template <typename E>
struct apply {
using type = E;
};
template <typename T>
struct apply<Error<NoBindingFoundErrorTag, T>> {
using type = If(IsSame(Type<T>, AnnotatedT),
ConstructError(ConstBindingDeclaredAsRequiredButNonConstBindingRequiredErrorTag, AnnotatedT),
ConstructError(NoBindingFoundErrorTag, Type<T>));
};
template <typename T1, typename T2>
struct apply<Error<NoBindingFoundForAbstractClassErrorTag, T1, T2>> {
using type = If(IsSame(Type<T1>, AnnotatedT),
ConstructError(ConstBindingDeclaredAsRequiredButNonConstBindingRequiredErrorTag, AnnotatedT),
ConstructError(NoBindingFoundForAbstractClassErrorTag, Type<T1>, Type<T2>));
};
};
struct EnsureProvidedType {
template <typename Comp, typename TargetRequirements, typename TargetNonConstRequirements, typename AnnotatedT,
typename NonConstBindingRequired>
struct apply {
using AnnotatedC = NormalizeType(AnnotatedT);
using AnnotatedCImpl = FindInMap(typename Comp::InterfaceBindings, AnnotatedC);
using AutoRegisterResult = AutoRegister(Comp, TargetRequirements, TargetNonConstRequirements, AnnotatedC);
using ErrorHandler = EnsureProvidedTypeErrorHandler<AnnotatedT>;
using type = If(
IsInSet(AnnotatedC, typename Comp::Ps),
If(And(NonConstBindingRequired, Not(IsInSet(AnnotatedC, typename Comp::NonConstRsPs))),
ConstructError(NonConstBindingRequiredButConstBindingProvidedErrorTag, AnnotatedC),
ComponentFunctorIdentity(Comp)),
If(And(IsInSet(AnnotatedC, TargetRequirements),
Or(Not(NonConstBindingRequired), IsInSet(AnnotatedC, TargetNonConstRequirements))),
// The type is already in the target requirements with the desired constness, nothing to do.
ComponentFunctorIdentity(Comp),
If(Not(IsNone(AnnotatedCImpl)),
// Has an interface binding.
Call(ComposeFunctors(ComponentFunctor(ProcessInterfaceBinding, AnnotatedC, AnnotatedCImpl,
NonConstBindingRequired),
ComponentFunctor(EnsureProvidedType, TargetRequirements, TargetNonConstRequirements,
AnnotatedCImpl, NonConstBindingRequired)),
Comp),
// If we are about to report a NoBindingFound/NoBindingFoundForAbstractClass error for AnnotatedT and the
// target
// component has a Required<const T>, we can report a more specific error (rather than the usual
// "binding not found").
If(And(NonConstBindingRequired, IsInSet(AnnotatedC, TargetRequirements)),
Catch(Catch(AutoRegisterResult, NoBindingFoundErrorTag, ErrorHandler),
NoBindingFoundForAbstractClassErrorTag, ErrorHandler),
AutoRegisterResult))));
};
};
struct EnsureProvidedTypes {
template <typename Comp, typename TargetRequirements, typename TargetNonConstRequirements, typename TypesToProvide,
typename NonConstTypesToProvide>
struct apply {
struct Helper {
template <typename CurrentResult, typename T>
struct apply {
using type = Compose2ComponentFunctors(ComponentFunctor(EnsureProvidedType, TargetRequirements,
TargetNonConstRequirements, T,
IsInSet(T, NonConstTypesToProvide)),
CurrentResult);
};
};
using type = Call(FoldVector(TypesToProvide, Helper, ComponentFunctorIdentity), Comp);
};
};
struct ProcessBinding {
template <typename Binding>
struct apply;
template <typename I, typename C>
struct apply<fruit::impl::Bind<I, C>> {
using type = ComponentFunctor(AddDeferredInterfaceBinding, Type<I>, Type<C>);
};
template <typename Signature>
struct apply<fruit::impl::RegisterConstructor<Signature>> {
using type = ComponentFunctor(DeferredRegisterConstructor, Type<Signature>);
};
template <typename AnnotatedC, typename C>
struct apply<fruit::impl::BindInstance<AnnotatedC, C>> {
using type = ComponentFunctor(RegisterInstance, Type<AnnotatedC>, Type<C>, Bool<true>);
};
template <typename AnnotatedC, typename C>
struct apply<fruit::impl::BindConstInstance<AnnotatedC, C>> {
using type = ComponentFunctor(RegisterInstance, Type<AnnotatedC>, Type<C>, Bool<false>);
};
template <typename Lambda>
struct apply<fruit::impl::RegisterProvider<Lambda>> {
using type = ComponentFunctor(DeferredRegisterProvider, Type<Lambda>);
};
template <typename AnnotatedSignature, typename Lambda>
struct apply<fruit::impl::RegisterProvider<AnnotatedSignature, Lambda>> {
using type = ComponentFunctor(DeferredRegisterProviderWithAnnotations, Type<AnnotatedSignature>, Type<Lambda>);
};
template <typename AnnotatedC>
struct apply<fruit::impl::AddInstanceMultibinding<AnnotatedC>> {
using type = ComponentFunctorIdentity;
};
template <typename AnnotatedC>
struct apply<fruit::impl::AddInstanceVectorMultibindings<AnnotatedC>> {
using type = ComponentFunctorIdentity;
};
template <typename I, typename C>
struct apply<fruit::impl::AddMultibinding<I, C>> {
using type = ComponentFunctor(AddInterfaceMultibinding, Type<I>, Type<C>);
};
template <typename Lambda>
struct apply<fruit::impl::AddMultibindingProvider<Lambda>> {
using type = ComponentFunctor(RegisterMultibindingProvider, Type<Lambda>);
};
template <typename AnnotatedSignature, typename Lambda>
struct apply<fruit::impl::AddMultibindingProvider<AnnotatedSignature, Lambda>> {
using type = ComponentFunctor(RegisterMultibindingProviderWithAnnotations, Type<AnnotatedSignature>, Type<Lambda>);
};
template <typename DecoratedSignature, typename Lambda>
struct apply<fruit::impl::RegisterFactory<DecoratedSignature, Lambda>> {
using type = ComponentFunctor(RegisterFactory, Type<DecoratedSignature>, Type<Lambda>);
};
template <typename... Params, typename... Args>
struct apply<fruit::impl::InstallComponent<fruit::Component<Params...>(Args...)>> {
using type = ComponentFunctor(InstallComponentHelper, Type<Params>...);
};
template <typename... ComponentFunctions>
struct apply<fruit::impl::InstallComponentFunctions<ComponentFunctions...>> {
using type = ComponentFunctor(InstallComponentFunctions, Type<ComponentFunctions>...);
};
template <typename GetReplacedComponent, typename GetReplacementComponent>
struct apply<fruit::impl::ReplaceComponent<GetReplacedComponent, GetReplacementComponent>> {
using type = ComponentFunctorIdentity;
};
};
} // namespace meta
} // namespace impl
} // namespace fruit
#endif // FRUIT_COMPONENT_FUNCTORS_DEFN_H