Lines Matching full:using
31 using Result = Comp1;
44 using type = typename F::Result;
57 using type = F(Comp, Args...);
67 using Result = Comp;
82 using Op1 = F1(Comp);
83 using Op2 = F2(GetResult(Op1));
85 using Result = Eval<GetResult(Op2)>;
94 using type = PropagateError(Op1, PropagateError(Op2, Op));
105 using type = Fold(Compose2ComponentFunctors, ComponentFunctorIdentity, Functors...);
118 using type = ComponentFunctorIdentity;
123 using type = Functor;
128 using type = Compose2ComponentFunctors(ReverseComposeFunctors(Functors...), Functor);
136 // Doesn't actually bind in ComponentStorage. The binding is added later (if needed) using ProcessI…
140 … using Comp1 = ConsComp(typename Comp::RsSuperset, typename Comp::Ps, typename Comp::NonConstRsPs,
149 using Result = Eval<Comp1>;
155 using I = RemoveAnnotations(AnnotatedI);
156 using C = RemoveAnnotations(AnnotatedC);
157 using type =
173 using R = If(NonConstBindingRequired,
181 using Result = Eval<R>;
194 using Result = Eval<R>;
204 using type = PropagateError(R, If(NonConstBindingRequired, NonConstOp, ConstOp));
211 using I = RemoveAnnotations(AnnotatedI);
212 using C = RemoveAnnotations(AnnotatedC);
213 using R = AddRequirements(Comp, Vector<AnnotatedC>, Vector<AnnotatedC>);
215 using Result = Eval<R>;
227 using type = If(Not(IsBaseOf(I, C)), ConstructError(NotABaseClassOfErrorTag, I, C), Op);
266 using AnnotatedC = NormalizeType(SignatureType(AnnotatedSignature));
267 using OptionalAnnotatedI = FindValueInMap(typename Comp::InterfaceBindings, AnnotatedC);
269 using Result = Comp;
271 …using Helper = PostProcessRegisterProviderHelper<UnwrapType<AnnotatedSignature>, UnwrapType<Lambda…
280 using type = Op;
287 using Signature = RemoveAnnotationsFromSignature(AnnotatedSignature);
288 using SignatureFromLambda = FunctionSignature(Lambda);
290 using AnnotatedC = NormalizeType(SignatureType(AnnotatedSignature));
291 using AnnotatedCDeps = NormalizeTypeVector(SignatureArgs(AnnotatedSignature));
292 using R = AddProvidedType(Comp, AnnotatedC, Bool<true>, AnnotatedCDeps,
294 using type =
318 …using Comp1 = AddDeferredBinding(Comp, ComponentFunctor(PostProcessRegisterProvider, AnnotatedSign…
319 using type = PreProcessRegisterProvider(Comp1, AnnotatedSignature, Lambda);
327 using type = DeferredRegisterProviderWithAnnotations(Comp, FunctionSignature(Lambda), Lambda);
336 using Signature = RemoveAnnotationsFromSignature(AnnotatedSignature);
337 using SignatureFromLambda = FunctionSignature(Lambda);
339 using AnnotatedArgs = SignatureArgs(AnnotatedSignature);
340 using AnnotatedArgVector = NormalizeTypeVector(AnnotatedArgs);
341 using NonConstRequirements = NormalizedNonConstTypesIn(AnnotatedArgs);
342 using R = AddRequirements(Comp, AnnotatedArgVector, NonConstRequirements);
344 using Result = Eval<R>;
356 using type = If(
387 … using type = RegisterMultibindingProviderWithAnnotations(Comp, FunctionSignature(Lambda), Lambda);
425 using AnnotatedT = SignatureType(DecoratedSignature);
426 using T = RemoveAnnotations(AnnotatedT);
427 using DecoratedArgs = SignatureArgs(DecoratedSignature);
428 using NakedInjectedSignature = NakedC(NakedUserProvidedArgs...);
429 using NakedRequiredSignature = NakedC(NakedAllArgs...);
430 using NakedFunctor = std::function<NakedInjectedSignature>;
432 using AnnotatedFunctor = CopyAnnotation(AnnotatedT, Type<NakedFunctor>);
433 using FunctorDeps = NormalizeTypeVector(Vector<InjectedAnnotatedArgs...>);
434 using FunctorNonConstDeps = NormalizedNonConstTypesIn(Vector<InjectedAnnotatedArgs...>);
435 using R = AddProvidedType(Comp, AnnotatedFunctor, Bool<true>, FunctorDeps, FunctorNonConstDeps);
437 using Result = Eval<R>;
467 using type = If(Not(IsSame(Type<NakedRequiredSignature>, FunctionSignature(Lambda))),
478 using LambdaReturnType = SignatureType(FunctionSignature(Lambda));
479 using type =
546 using AnnotatedC = NormalizeType(SignatureType(AnnotatedSignature));
547 using Result = Comp;
548 using Helper =
564 using Signature = RemoveAnnotationsFromSignature(AnnotatedSignature);
565 using C = SignatureType(Signature);
566 using Args = SignatureArgs(Signature);
567 using AnnotatedT = SignatureType(AnnotatedSignature);
568 using AnnotatedArgs = SignatureArgs(AnnotatedSignature);
569 using AnnotatedC = NormalizeType(AnnotatedT);
570 using CDeps = NormalizeTypeVector(AnnotatedArgs);
571 using CNonConstDeps = NormalizedNonConstTypesIn(AnnotatedArgs);
572 using R = AddProvidedType(Comp, AnnotatedC, Bool<true>, CDeps, CNonConstDeps);
573 …using type = If(Not(IsValidSignature(AnnotatedSignature)), ConstructError(NotASignatureErrorTag, A…
589 …using Comp1 = AddDeferredBinding(Comp, ComponentFunctor(PostProcessRegisterConstructor, AnnotatedS…
590 using type = PreProcessRegisterConstructor(Comp1, AnnotatedSignature);
597 using R = AddProvidedType(Comp, AnnotatedC, IsNonConst, Vector<>, Vector<>);
599 using Result = Eval<R>;
605 using type = PropagateError(
627 using RequiredSignature = Type<NakedT(NakedArgs...)>;
628 using Op1 = RegisterFactory(Comp, DecoratedSignature, RequiredSignature);
630 using Result = Eval<GetResult(Op1)>;
633 using RealOp = RegisterFactory(Comp, DecoratedSignature, Type<decltype(provider)>);
640 using RealOp = RegisterFactory(Comp, DecoratedSignature, Type<decltype(provider)>);
646 using type = PropagateError(Op1, Op);
657 using RequiredSignature = Type<std::unique_ptr<NakedT>(NakedArgs...)>;
658 using Op1 = RegisterFactory(Comp, DecoratedSignature, RequiredSignature);
660 using Result = Eval<GetResult(Op1)>;
665 using RealOp = RegisterFactory(Comp, DecoratedSignature, Type<decltype(provider)>);
674 using RealOp = RegisterFactory(Comp, DecoratedSignature, Type<decltype(provider)>);
681 using type = PropagateError(Op1, Op);
688 using new_RsSuperset = SetUnion(typename OtherComp::RsSuperset, typename Comp::RsSuperset);
689 using new_Ps = SetUncheckedUnion(typename OtherComp::Ps, typename Comp::Ps);
690 … using new_NonConstRsPs = SetUnion(typename OtherComp::NonConstRsPs, typename Comp::NonConstRsPs);
692 using new_Deps = ConcatVectors(typename OtherComp::Deps, typename Comp::Deps);
695 using new_InterfaceBindings = typename Comp::InterfaceBindings;
698 using new_DeferredBindingFunctors = typename Comp::DeferredBindingFunctors;
700 using R = ConsComp(new_RsSuperset, new_Ps, new_NonConstRsPs,
706 using Result = Eval<R>;
712 using InterfacePs = VectorToSetUnchecked(GetMapKeys(typename Comp::InterfaceBindings));
713 using AllPs = SetUncheckedUnion(InterfacePs, typename Comp::Ps);
714 using DuplicateTypes = SetIntersection(typename OtherComp::Ps, AllPs);
715 using CompConstPs = SetDifference(typename Comp::Ps, typename Comp::NonConstRsPs);
716 using CompRs = SetDifference(typename Comp::RsSuperset, typename Comp::Ps);
717 using CompNonConstRs = SetIntersection(CompRs, typename Comp::NonConstRsPs);
719 … using OtherCompConstPs = SetDifference(typename OtherComp::Ps, typename OtherComp::NonConstRsPs);
720 using OtherCompRs = SetDifference(typename OtherComp::RsSuperset, typename OtherComp::Ps);
721 using OtherCompNonConstRs = SetIntersection(OtherCompRs, typename OtherComp::NonConstRsPs);
723 using type = If(Not(IsDisjoint(typename OtherComp::Ps, AllPs)),
738 using OtherComp = ConstructComponentImpl(OtherCompParams...);
739 using type = InstallComponent(Comp, OtherComp);
749 using type = ComponentFunctorIdentity(Comp);
754 using type =
764 using type = ConstructError(IncorrectArgTypePassedToInstallComponentFuntionsErrorTag, T);
773 using type = Bool<true>;
780 using SourcePs = typename SourceComp::Ps;
781 using DestPs = typename DestComp::Ps;
782 using SourceRs = SetDifference(typename SourceComp::RsSuperset, typename SourceComp::Ps);
783 using DestRs = SetDifference(typename DestComp::RsSuperset, typename DestComp::Ps);
784 using NonConstSourceRs = SetIntersection(SourceRs, typename SourceComp::NonConstRsPs);
785 using NonConstDestPs = SetIntersection(DestPs, typename DestComp::NonConstRsPs);
786 using NonConstDestRs = SetIntersection(DestRs, typename DestComp::NonConstRsPs);
788 using ConstSourcePs = SetDifference(SourcePs, typename SourceComp::NonConstRsPs);
789 using ConstDestRs = SetDifference(DestRs, typename DestComp::NonConstRsPs);
797 using ToRegister = SetUnion(
802 …using NonConstTypesToRegister = SetIntersection(ToRegister, SetUnion(typename SourceComp::NonConst…
804 using type = EnsureProvidedTypes(SourceComp, DestRs, NonConstDestRs, SetToVector(ToRegister),
833 using Comp1 = ConsComp(RsSupersetParam, PsParam, NonConstRsPsParam,
838 …using type = Call(FoldList(DeferredBindingFunctors, Compose2ComponentFunctors, ComponentFunctorIde…
846 using type = E;
851 …using type = If(IsSame(Type<T>, AnnotatedCFunctor), ConstructNoBindingFoundError(AnnotatedCUniqueP…
857 …using type = If(IsSame(Type<T1>, AnnotatedCFunctor), ConstructNoBindingFoundError(AnnotatedCUnique…
869 using AnnotatedC = SignatureType(AnnotatedSignature);
870 using CFunctor = ConsStdFunction(RemoveAnnotationsFromSignature(AnnotatedSignature));
871 using AnnotatedCFunctor = CopyAnnotation(AnnotatedC, CFunctor);
872 …using type = If(IsAbstract(C), ConstructError(NoBindingFoundForAbstractClassErrorTag, AnnotatedCFu…
882 using AnnotatedC = SignatureType(AnnotatedSignature);
883 using CFunctor = ConsStdFunction(RemoveAnnotationsFromSignature(AnnotatedSignature));
884 using AnnotatedCFunctor = CopyAnnotation(AnnotatedC, CFunctor);
885 using type = If(IsAbstract(Type<NakedI>),
896 using I = Type<NakedI>;
897 using AnnotatedI = CopyAnnotation(SignatureType(AnnotatedSignature), I);
898 using C = RemoveAnnotations(AnnotatedC);
899 using IFunctor = ConsStdFunction(ConsSignature(ConsUniquePtr(I), Args...));
900 using CFunctor = ConsStdFunction(ConsSignature(ConsUniquePtr(C), Args...));
901 using AnnotatedIFunctor = CopyAnnotation(AnnotatedI, IFunctor);
902 using AnnotatedCFunctor = CopyAnnotation(AnnotatedC, CFunctor);
904 using ProvidedSignature = ConsSignature(AnnotatedIFunctor,
906 using LambdaSignature = ConsSignature(IFunctor, ConsConstReference(CFunctor));
908 …using F1 = ComponentFunctor(EnsureProvidedType, TargetRequirements, TargetNonConstRequirements, An…
910 using F2 = ComponentFunctor(PreProcessRegisterProvider, ProvidedSignature, LambdaSignature);
911 using F3 = ComponentFunctor(PostProcessRegisterProvider, ProvidedSignature, LambdaSignature);
912 using R = Call(ComposeFunctors(F1, F2, F3), Comp);
914 using Result = Eval<GetResult(R)>;
915 using NakedC = UnwrapType<Eval<C>>;
958 using type = PropagateError(R, If(Not(HasVirtualDestructor(I)),
970 using C = Type<NakedC>;
971 using CFunctor = ConsStdFunction(ConsSignature(C, Args...));
972 using CUniquePtrFunctor = ConsStdFunction(ConsSignature(ConsUniquePtr(C), Args...));
973 using AnnotatedCUniquePtr = SignatureType(AnnotatedSignature);
974 using AnnotatedC = CopyAnnotation(AnnotatedCUniquePtr, C);
975 using AnnotatedCFunctor = CopyAnnotation(AnnotatedCUniquePtr, CFunctor);
976 using AnnotatedCUniquePtrFunctor = CopyAnnotation(AnnotatedCUniquePtr, CUniquePtrFunctor);
977 using AnnotatedCFunctorRef = CopyAnnotation(AnnotatedCUniquePtr, ConsConstReference(CFunctor));
979 using ProvidedSignature = ConsSignature(AnnotatedCUniquePtrFunctor, AnnotatedCFunctorRef);
980 using LambdaSignature = ConsSignature(CUniquePtrFunctor, ConsConstReference(CFunctor));
982 …using F1 = ComponentFunctor(EnsureProvidedType, TargetRequirements, TargetNonConstRequirements, An…
984 using F2 = ComponentFunctor(PreProcessRegisterProvider, ProvidedSignature, LambdaSignature);
985 using F3 = ComponentFunctor(PostProcessRegisterProvider, ProvidedSignature, LambdaSignature);
986 using R = Call(ComposeFunctors(F1, F2, F3), Comp);
988 using Result = Eval<GetResult(R)>;
996 …using RealF2 = ComponentFunctor(PreProcessRegisterProvider, ProvidedSignature, Type<decltype(provi…
997 …using RealF3 = ComponentFunctor(PostProcessRegisterProvider, ProvidedSignature, Type<decltype(prov…
998 using RealOp = Call(ComposeFunctors(F1, RealF2, RealF3), Comp);
1010 …using RealF2 = ComponentFunctor(PreProcessRegisterProvider, ProvidedSignature, Type<decltype(provi…
1011 …using RealF3 = ComponentFunctor(PostProcessRegisterProvider, ProvidedSignature, Type<decltype(prov…
1012 using RealOp = Call(ComposeFunctors(F1, RealF2, RealF3), Comp);
1019 using ErrorHandler =
1025 using type = PropagateError(Catch(Catch(R, NoBindingFoundErrorTag, ErrorHandler),
1035 using AnnotatedCUniquePtr = SignatureType(AnnotatedSignature);
1036 …using AnnotatedC = CopyAnnotation(AnnotatedCUniquePtr, RemoveUniquePtr(RemoveAnnotations(Annotated…
1037 using DecoratedSignatureReturningValue = GetInjectAnnotation(AnnotatedC);
1038 using DecoratedSignature = ConsSignatureWithVector(AnnotatedCUniquePtr,
1040 using DecoratedSignatureArgs = SignatureArgs(DecoratedSignature);
1041 …using ActualSignatureInInjectionTypedef = ConsSignatureWithVector(SignatureType(DecoratedSignature…
1043 using NonAssistedArgs = RemoveAssisted(DecoratedSignatureArgs);
1045 using F1 = ComponentFunctor(RegisterConstructorAsUniquePtrFactory, DecoratedSignature);
1046 using F2 = ComponentFunctor(EnsureProvidedTypes, TargetRequirements, TargetNonConstRequirements,
1049 using type = If(Not(IsSame(AnnotatedSignature, ActualSignatureInInjectionTypedef)),
1060 using AnnotatedC = SignatureType(AnnotatedSignature);
1061 using DecoratedSignature = GetInjectAnnotation(AnnotatedC);
1062 using DecoratedSignatureArgs = SignatureArgs(DecoratedSignature);
1063 …using ActualSignatureInInjectionTypedef = ConsSignatureWithVector(SignatureType(DecoratedSignature…
1065 using NonAssistedArgs = RemoveAssisted(DecoratedSignatureArgs);
1067 using F1 = ComponentFunctor(RegisterConstructorAsValueFactory, DecoratedSignature);
1068 using F2 = ComponentFunctor(EnsureProvidedTypes, TargetRequirements, TargetNonConstRequirements,
1071 using type = If(Not(IsSame(AnnotatedSignature, ActualSignatureInInjectionTypedef)),
1086 using CHasInjectAnnotation = HasInjectAnnotation(RemoveAnnotations(AnnotatedC));
1087 using Inject = GetInjectAnnotation(AnnotatedC);
1088 using CRequirements = NormalizeTypeVector(SignatureArgs(Inject));
1089 using CNonConstRequirements = NormalizedNonConstTypesIn(SignatureArgs(Inject));
1090 using F = ComposeFunctors(ComponentFunctor(PreProcessRegisterConstructor, Inject),
1094 using type = If(CHasInjectAnnotation, Call(F, Comp), ConstructNoBindingFoundError(AnnotatedC));
1100 using type = AutoRegisterFactoryHelper(Comp, TargetRequirements, TargetNonConstRequirements,
1110 using type = AutoRegisterFactoryHelper(Comp, TargetRequirements, TargetNonConstRequirements,
1121 using type = AutoRegisterFactoryHelper(Comp, TargetRequirements, TargetNonConstRequirements,
1133 using type = AutoRegisterFactoryHelper(Comp, TargetRequirements, TargetNonConstRequirements,
1147 using type = E;
1152 using type = If(IsSame(Type<T>, AnnotatedT),
1159 using type = If(IsSame(Type<T1>, AnnotatedT),
1169 using AnnotatedC = NormalizeType(AnnotatedT);
1170 using AnnotatedCImpl = FindInMap(typename Comp::InterfaceBindings, AnnotatedC);
1171 …using AutoRegisterResult = AutoRegister(Comp, TargetRequirements, TargetNonConstRequirements, Anno…
1172 using ErrorHandler = EnsureProvidedTypeErrorHandler<AnnotatedT>;
1173 using type = If(
1207 … using type = Compose2ComponentFunctors(ComponentFunctor(EnsureProvidedType, TargetRequirements,
1214 using type = Call(FoldVector(TypesToProvide, Helper, ComponentFunctorIdentity), Comp);
1224 using type = ComponentFunctor(AddDeferredInterfaceBinding, Type<I>, Type<C>);
1229 using type = ComponentFunctor(DeferredRegisterConstructor, Type<Signature>);
1234 using type = ComponentFunctor(RegisterInstance, Type<AnnotatedC>, Type<C>, Bool<true>);
1239 using type = ComponentFunctor(RegisterInstance, Type<AnnotatedC>, Type<C>, Bool<false>);
1244 using type = ComponentFunctor(DeferredRegisterProvider, Type<Lambda>);
1249 …using type = ComponentFunctor(DeferredRegisterProviderWithAnnotations, Type<AnnotatedSignature>, T…
1254 using type = ComponentFunctorIdentity;
1259 using type = ComponentFunctorIdentity;
1264 using type = ComponentFunctor(AddInterfaceMultibinding, Type<I>, Type<C>);
1269 using type = ComponentFunctor(RegisterMultibindingProvider, Type<Lambda>);
1274 …using type = ComponentFunctor(RegisterMultibindingProviderWithAnnotations, Type<AnnotatedSignature…
1279 using type = ComponentFunctor(RegisterFactory, Type<DecoratedSignature>, Type<Lambda>);
1284 using type = ComponentFunctor(InstallComponentHelper, Type<Params>...);
1289 using type = ComponentFunctor(InstallComponentFunctions, Type<ComponentFunctions>...);
1294 using type = ComponentFunctorIdentity;