From f1bd2260d1247b8a01902981fd1944a8d35e79fb Mon Sep 17 00:00:00 2001 From: Mike Bierlee Date: Tue, 6 Dec 2016 23:00:30 +0100 Subject: [PATCH] Split autowire code up into multiple functions --- source/poodinis/autowire.d | 106 +++++++++++++++++++++---------------- 1 file changed, 59 insertions(+), 47 deletions(-) diff --git a/source/poodinis/autowire.d b/source/poodinis/autowire.d index 3c6223d..3f69bad 100644 --- a/source/poodinis/autowire.d +++ b/source/poodinis/autowire.d @@ -27,7 +27,7 @@ import std.string; import std.traits; import std.range; -struct UseMemberType {}; +private struct UseMemberType {}; /** * UDA for annotating class members as candidates for autowiring. @@ -62,11 +62,10 @@ struct UseMemberType {}; * autowire member "fuelEngine" as if it's of type "FuelEngine". This means that the members of instance "fuelEngine" * will also be autowired because the autowire mechanism knows that member "fuelEngine" is an instance of "FuelEngine" */ -struct Autowire(QualifierType = UseMemberType) { +struct Autowire(QualifierType) { QualifierType qualifier; }; - /** * UDA for marking autowired dependencies optional. * Optional dependencies will not lead to a resolveException when there is no type registered for them. @@ -130,54 +129,67 @@ private void printDebugAutowiringArray(TypeInfo superTypeInfo, TypeInfo instance } private void autowireMember(string member, size_t memberIndex, Type)(shared(DependencyContainer) container, Type instance) { - foreach(autowireAttribute; __traits(getAttributes, Type.tupleof[memberIndex])) { - static if (__traits(isSame, autowireAttribute, Autowire) || is(autowireAttribute == Autowire!T, T)) { - if (instance.tupleof[memberIndex] is null) { - alias MemberType = typeof(Type.tupleof[memberIndex]); - - enum assignNewInstance = hasUDA!(Type.tupleof[memberIndex], AssignNewInstance); - enum isOptional = hasUDA!(Type.tupleof[memberIndex], OptionalDependency); - - static if (isDynamicArray!MemberType) { - alias MemberElementType = ElementType!MemberType; - static if (isOptional) { - auto instances = container.resolveAll!MemberElementType(ResolveOption.noResolveException); - } else { - auto instances = container.resolveAll!MemberElementType; - } - instance.tupleof[memberIndex] = instances; - debug(poodinisVerbose) { - printDebugAutowiringArray(typeid(MemberElementType), typeid(Type), &instance, member); - } - } else { - debug(poodinisVerbose) { - TypeInfo qualifiedInstanceType = typeid(MemberType); - } - - MemberType qualifiedInstance; - static if (is(autowireAttribute == Autowire!T, T) && !is(autowireAttribute.qualifier == UseMemberType)) { - alias QualifierType = typeof(autowireAttribute.qualifier); - qualifiedInstance = createOrResolveInstance!(MemberType, QualifierType, assignNewInstance, isOptional)(container); - debug(poodinisVerbose) { - qualifiedInstanceType = typeid(QualifierType); - } - } else { - qualifiedInstance = createOrResolveInstance!(MemberType, MemberType, assignNewInstance, isOptional)(container); - } - - instance.tupleof[memberIndex] = qualifiedInstance; - - debug(poodinisVerbose) { - printDebugAutowiringCandidate(qualifiedInstanceType, &qualifiedInstance, typeid(Type), &instance, member); - } - } - } - - break; + foreach(attribute; __traits(getAttributes, Type.tupleof[memberIndex])) { + static if (is(attribute == Autowire!T, T)) { + injectInstance!(member, memberIndex, attribute)(container, instance); + } else if (__traits(isSame, attribute, Autowire)) { + injectInstance!(member, memberIndex, Autowire!UseMemberType)(container, instance); } } } +private void injectInstance(string member, size_t memberIndex, autowireAttribute, Type)(shared(DependencyContainer) container, Type instance) { + if (instance.tupleof[memberIndex] is null) { + alias MemberType = typeof(Type.tupleof[memberIndex]); + enum isOptional = hasUDA!(Type.tupleof[memberIndex], OptionalDependency); + + static if (isDynamicArray!MemberType) { + injectMultipleInstances!(member, memberIndex, isOptional, MemberType)(container, instance); + } else { + injectSingleInstance!(member, memberIndex, autowireAttribute, isOptional, MemberType)(container, instance); + } + } +} + +private void injectMultipleInstances(string member, size_t memberIndex, bool isOptional, MemberType, Type)(shared(DependencyContainer) container, Type instance) { + alias MemberElementType = ElementType!MemberType; + static if (isOptional) { + auto instances = container.resolveAll!MemberElementType(ResolveOption.noResolveException); + } else { + auto instances = container.resolveAll!MemberElementType; + } + + instance.tupleof[memberIndex] = instances; + debug(poodinisVerbose) { + printDebugAutowiringArray(typeid(MemberElementType), typeid(Type), &instance, member); + } +} + +private void injectSingleInstance(string member, size_t memberIndex, autowireAttribute, bool isOptional, MemberType, Type)(shared(DependencyContainer) container, Type instance) { + debug(poodinisVerbose) { + TypeInfo qualifiedInstanceType = typeid(MemberType); + } + + enum assignNewInstance = hasUDA!(Type.tupleof[memberIndex], AssignNewInstance); + + MemberType qualifiedInstance; + static if (is(autowireAttribute == Autowire!T, T) && !is(typeof(autowireAttribute.qualifier) == UseMemberType)) { + alias QualifierType = typeof(autowireAttribute.qualifier); + qualifiedInstance = createOrResolveInstance!(MemberType, QualifierType, assignNewInstance, isOptional)(container); + debug(poodinisVerbose) { + qualifiedInstanceType = typeid(QualifierType); + } + } else { + qualifiedInstance = createOrResolveInstance!(MemberType, MemberType, assignNewInstance, isOptional)(container); + } + + instance.tupleof[memberIndex] = qualifiedInstance; + + debug(poodinisVerbose) { + printDebugAutowiringCandidate(qualifiedInstanceType, &qualifiedInstance, typeid(Type), &instance, member); + } +} + private QualifierType createOrResolveInstance(MemberType, QualifierType, bool createNew, bool isOptional)(shared(DependencyContainer) container) { static if (createNew) { auto instanceFactory = new InstanceFactory();