protected AbstractProducer(IWeldComponent declaringComponent, MemberInfo member, Type returnType, IEnumerable <IBinderAttribute> binders, Type scope, WeldComponentManager manager)
: base(member.ToString(), returnType, binders, scope, manager)
{
_member = member;
_containsGenericParameters = GenericUtils.MemberContainsGenericArguments(member);
DeclaringComponent = declaringComponent;
}
public IWeldComponent MakeProducerProperty(IWeldComponent component, PropertyInfo property)
{
var binders = property.GetBinders();
var scope = property.GetAttributesRecursive <ScopeAttribute>().Select(x => x.GetType()).FirstOrDefault() ?? typeof(DependentAttribute);
return(new ProducerProperty(component, property, binders, scope, _manager));
}
public IWeldComponent MakeProducerField(IWeldComponent component, FieldInfo field)
{
var binders = field.GetBinders();
var scope = field.GetAttributesRecursive <ScopeAttribute>().Select(x => x.GetType()).FirstOrDefault() ?? typeof(DependentAttribute);
return(new ProducerField(component, field, binders, scope, _manager));
}
public EventObserverMethod(IWeldComponent component, ParameterInfo parameter, IAnnotations annotations)
{
Component = component;
_parameter = parameter;
_annotations = annotations;
_eventType = parameter.ParameterType;
IsConcrete = _eventType.ContainsGenericParameters;
_method = new InjectableMethod(component, (MethodInfo)parameter.Member, parameter);
NextNonLinearValidatables = _method.LinearValidatables.Union(_method.NonLinearValidatables);
}
protected InjectableMethodBase(IWeldComponent component, MethodBase method, ParameterInfo specialParameter)
{
Component = component;
_method = method;
SpecialParameter = specialParameter;
IsConstructor = _method is ConstructorInfo;
_injectionPoints = method.GetParameters()
.Select(p => p == specialParameter? null: new MethodParameterInjectionPoint(component, p, AttributeUtils.GetAnnotations(p)))
.ToArray();
}
public override InjectableMethodBase TranslateGenericArguments(IWeldComponent component, IDictionary <Type, Type> translations)
{
var resolvedMethod = GenericUtils.TranslateMethodGenericArguments(Method, translations);
if (resolvedMethod == null || GenericUtils.MemberContainsGenericArguments(resolvedMethod))
{
return(null);
}
return(new InjectableMethod(component, resolvedMethod, SpecialParameter));
}
public IWeldComponent MakeProducerMethod(IWeldComponent component, MethodInfo method)
{
var binders = method.GetBinders();
var scope = method.GetAttributesRecursive <ScopeAttribute>().Select(x => x.GetType()).FirstOrDefault() ?? typeof(DependentAttribute);
var producer = new ProducerMethod(component, method, binders, scope, _manager);
var injects = ToMethodInjections(producer, method).ToArray();
producer.AddInjectionPoints(injects);
return(producer);
}
public IEnumerable <IComponent> GetComponents(Type type, IQualifier[] qualifiers)
{
qualifiers = qualifiers.DefaultIfEmpty(DefaultAttribute.Instance).ToArray();
var unwrappedType = UnwrapType(type);
var isWrapped = unwrappedType != type;
var components = _typeComponents.GetOrAdd(unwrappedType, t =>
_allComponents.Select(x => x.Resolve(t)).Where(x => x != null).ToArray());
var matched = components.Where(x => x.CanSatisfy(qualifiers)).ToArray();
if (matched.Length > 1)
{
var onMissings = matched.Where(x => x.IsConditionalOnMissing).ToArray();
var others = matched.Except(onMissings).ToArray();
matched = others.Any() ? others: onMissings.Take(1).ToArray();
}
var newComponents = matched.Where(x => !_allComponents.Contains(x));
foreach (var c in newComponents)
{
_allComponents.Add(c);
ContextualStore.PutIfAbsent(c);
if (_isDeployed)
{
Validate(c, new IComponent[0]);
}
}
if (isWrapped)
{
matched = new IWeldComponent[] { new InstanceComponent(unwrappedType, qualifiers, this, matched) }
}
;
return(matched);
}
public ProducerMethod(IWeldComponent declaringComponent, MethodInfo method, IEnumerable <IBinderAttribute> binders, Type scope, WeldComponentManager manager)
: base(declaringComponent, method, method.ReturnType, binders, scope, manager)
{
_method = method;
}
public ProducerProperty(IWeldComponent component, PropertyInfo property, IEnumerable <IBinderAttribute> binders, Type scope, WeldComponentManager manager)
: base(component, property, property.PropertyType, binders, scope, manager)
{
_property = property;
}
public void AddConfiguration(IWeldComponent component)
{
_configurations.Add(component);
}
public void AddComponent(IWeldComponent component)
{
_components.Add(component);
}
public ProducerProperty(IWeldComponent component, PropertyInfo property, IAnnotations annotations, WeldComponentManager manager)
: base(component, property, property.PropertyType, annotations, manager)
{
_property = property;
}
public ProducerMethod(IWeldComponent declaringComponent, IAnnotatedMethod method, WeldComponentManager manager)
: this(declaringComponent, method.Method, method.Annotations, manager)
{
}
private static IEnumerable <EventObserverMethod> FindEventObservers(IAnnotatedType type, IWeldComponent component)
{
foreach (var method in type.Methods)
{
var injectParams = method.Parameters
.Where(p => p.Annotations.Any <ObservesAttribute>())
.ToArray();
if (!injectParams.Any())
{
continue;
}
if (injectParams.Length > 1)
{
throw new InvalidComponentException(Formatters.MultipleObservesParameter(method.Method));
}
var param = injectParams.Single();
yield return(new EventObserverMethod(component, param.Parameter, param.Annotations));
}
}
public override InjectableMethodBase TranslateGenericArguments(IWeldComponent component, IDictionary <Type, Type> translations)
{
var resolvedCtor = GenericUtils.TranslateConstructorGenericArguments(_ctor, translations);
return(new InjectableConstructor(component, resolvedCtor));
}
public InjectableConstructor(IWeldComponent component, ConstructorInfo ctor)
: base(component, ctor, null)
{
_ctor = ctor;
}
public abstract InjectableMethodBase TranslateGenericArguments(IWeldComponent weldComponent,
IDictionary <Type, Type> translations);
public ProducerField(IWeldComponent component, FieldInfo field, IEnumerable <IBinderAttribute> binders, Type scope, WeldComponentManager manager)
: base(component, field, field.FieldType, binders, scope, manager)
{
_field = field;
}
public ProducerField(IWeldComponent component, IAnnotatedField field, WeldComponentManager manager)
: this(component, field.Field, field.Annotations, manager)
{
}
private ProducerField(IWeldComponent component, FieldInfo field, IAnnotations annotations, WeldComponentManager manager)
: base(component, field, field.FieldType, annotations, manager)
{
_field = field;
}
public ProducerMethod(IWeldComponent declaringComponent, MethodInfo method, IAnnotations annotations, WeldComponentManager manager)
: base(declaringComponent, method, method.ReturnType, annotations, manager)
{
_method = new InjectableMethod(declaringComponent, method, null);
}
protected AbstractProducer(IWeldComponent declaringComponent, MemberInfo member, Type returnType, IAnnotations annotations, WeldComponentManager manager)
: base(Formatters.Member(member), returnType, annotations, manager)
{
_containsGenericParameters = GenericUtils.MemberContainsGenericArguments(member);
DeclaringComponent = declaringComponent;
}
public InjectableMethod(IWeldComponent component, MethodInfo method, ParameterInfo specialParameter) :
base(component, method, specialParameter)
{
Method = method;
IsAsync = typeof(Task).IsAssignableFrom(method.ReturnType);
}
