private TypeBindingInformationState NewTypeBindingInformation(
CompositeValidationResultMutable vResult,
CollectionsFactory collectionsFactory,
CompositeModel compositeModel,
AbstractInjectableModel injModel,
Type nInfo,
Type type,
Type declaringType,
IDictionary <Type, TypeBindingInformationState> privateComposites
)
{
TypeBindingInformationState state = new TypeBindingInformationState(collectionsFactory);
state.NativeInfo = nInfo.GetGenericDefinitionIfContainsGenericParameters();
ListProxy <ListProxy <AbstractGenericTypeBinding> > bindings = collectionsFactory.NewListProxy <ListProxy <AbstractGenericTypeBinding> >();
Boolean allBindingsOK = this.NewGenericTypeBinding(collectionsFactory, compositeModel, type, declaringType, bindings, privateComposites);
if (allBindingsOK)
{
state.Bindings.AddRange(bindings.CQ);
}
else if (vResult != null)
{
vResult.StructureValidationErrors.Add(ValidationErrorFactory.NewStructureError("Failed to deduce generic bindings for " + (injModel == null ? (Object)type : injModel) + ".", compositeModel, injModel as AbstractMemberInfoModel <Object>));
}
return(allBindingsOK ? state : null);
}
public Object ProvideInjection(CompositeInstance instance, AbstractInjectableModel model, Type targetType)
{
InvocationInfo invocationInfo = instance.InvocationInfo;
Object result;
if (Object.Equals(typeof(MethodInfo), targetType))
{
result = invocationInfo.CompositeMethod;
}
else if (Object.Equals(typeof(CompositeMethodModel), targetType))
{
result = invocationInfo.FragmentMethodModel.CompositeMethod;
}
else if (typeof(AbstractFragmentMethodModel).IsAssignableFrom(targetType))
{
result = invocationInfo.FragmentMethodModel;
}
else
{
AttributeHolder holder = instance.ModelInfo.CompositeMethodAttributeHolders[invocationInfo.FragmentMethodModel.CompositeMethod.MethodIndex];
if (typeof(Attribute).IsAssignableFrom(targetType))
{
ListQuery <Attribute> list;
holder.AllAttributes.TryFindInTypeDictionarySearchBottommostType(targetType, out list);
result = list.FirstOrDefault();
}
else // target type must be attribute holder
{
result = holder;
}
}
return(result);
}
public Object ProvideInjection(CompositeInstance instance, AbstractInjectableModel model, Type targetType)
{
Object result;
RoleMapHolder.ROLE_MAPS.Value.Peek().TryGetRole <Object>(((RoleAttribute)model.InjectionScope).Name, targetType, out result);
return(result);
}
public Object ProvideInjection(CompositeInstance instance, AbstractInjectableModel model, Type targetType)
{
Object retVal;
instance.Composites.TryGetValue(targetType, out retVal);
return(retVal);
}
internal InjectionValidationErrorImpl(String message, AbstractInjectableModel injectableModel)
{
ArgumentValidator.ValidateNotNull("Injectable model", injectableModel);
this._injectableModel = injectableModel;
this._message = message;
}
public Object ProvideInjection(CompositeInstance instance, AbstractInjectableModel model, Type targetType)
{
Object result = null;
if (targetType.IsAssignableFrom(typeof(CollectionsFactory)))
{
result = instance.StructureOwner.Application.CollectionsFactory;
}
else if (targetType.IsAssignableFrom(typeof(ApplicationSPI)))
{
result = instance.StructureOwner.Application;
}
else if (targetType.IsAssignableFrom(typeof(StructureServiceProviderSPI)))
{
result = this.GetStructureServiceProvider(instance, model, targetType);
}
else if (targetType.IsAssignableFrom(typeof(UsesProviderQuery)))
{
result = instance.UsesContainer;
}
else if (targetType.IsAssignableFrom(typeof(CompositeModel)) || targetType.IsAssignableFrom(typeof(ServiceCompositeModel)))
{
result = instance.ModelInfo.Model;
}
else if (targetType.IsAssignableFrom(typeof(CompositeInstance)))
{
result = instance;
}
else
{
result = this.ProvideNonStandardInjection(instance, model, targetType);
}
return(result);
}
public ValidationResult InjectionPossible(AbstractInjectableModel model)
{
// TODO might check for model here already if the type is assignable from Attribute.
var targetType = model.TargetType;
return(new ValidationResult(
Object.Equals(typeof(MethodInfo), targetType) ||
Object.Equals(typeof(AttributeHolder), targetType) ||
typeof(Attribute).IsAssignableFrom_IgnoreGenericArgumentsForGenericTypes(targetType) ||
Object.Equals(typeof(CompositeMethodModel), targetType) ||
typeof(AbstractFragmentMethodModel).IsAssignableFrom_IgnoreGenericArgumentsForGenericTypes(targetType),
"Target type must be either " + typeof(MethodInfo) + ", " + typeof(AttributeHolder) + ", or any sub-type of " + typeof(Attribute) + ", or " + typeof(CompositeMethodModel) + ", or any sub-type of " + typeof(AbstractFragmentMethodModel) + "."));
}
public Object ProvideInjection(CompositeInstance instance, AbstractInjectableModel model, Type targetType)
{
var scope = model.InjectionScope;
Object result;
if (typeof(CompositeState).IsAssignableFrom(targetType))
{
result = instance.State;
}
else
{
var attribute = (StateAttribute)scope;
var isCompositeProperty = typeof(CompositeProperty).IsAssignableFrom(targetType);
var prop = this.FindSuitable <CompositeProperty, PropertyInfo>(
instance.State.Properties.Values,
attribute.DeclaringType,
attribute.ElementName,
GetActualTargetType <CompositeProperty>(targetType),
cProp => cProp.ReflectionInfo,
pInfo => pInfo.PropertyType
);
if (prop != null)
{
result = isCompositeProperty ? prop : prop.PropertyValueAsObject;
}
else
{
var isCompositeEvent = typeof(CompositeEvent).IsAssignableFrom(targetType);
var evt = this.FindSuitable <CompositeEvent, EventInfo>(
instance.State.Events.Values,
attribute.DeclaringType,
attribute.ElementName,
GetActualTargetType <CompositeEvent>(targetType),
cEvent => cEvent.ReflectionInfo,
eventInfo => eventInfo.EventHandlerType
);
if (evt != null)
{
result = isCompositeEvent ? evt : evt.InvokeActionAsObject;
}
else
{
result = null;
}
}
}
return(result);
}
public Object ProvideInjection(SPI.Instance.CompositeInstance instance, AbstractInjectableModel model, Type targetType)
{
var scope = model.InjectionScope;
// First check if we are trying to reference ourselves
//var gDef = TypeUtils.TypeUtil.GenericDefinitionIfGenericType( targetType );
Object result = null;
var provider = instance.StructureOwner.StructureServices;
var actualServiceType = GetActualServiceType(targetType);
var refs = provider.FindServices(actualServiceType);
foreach (var tuple in GetQualifierTypes(model))
{
var qInstance = (ServiceQualifier)tuple.Item2.QualifierType.LoadConstructorOrThrow(0).Invoke(null);
refs = refs.Where(sRef => qInstance.Qualifies(sRef, tuple.Item1));
}
if (Object.Equals(actualServiceType, targetType))
{
result = refs.Select(sRef => sRef.GetServiceWithType(actualServiceType)).FirstOrDefault();
}
else
{
if (targetType.IsGenericType())
{
var gArgs = targetType.GetGenericArguments();
if (Object.Equals(typeof(IEnumerable <>), targetType.GetGenericTypeDefinition()))
{
var enumerableType = gArgs[0];
if (enumerableType.IsGenericType() &&
Object.Equals(typeof(ServiceReferenceInfo <>), enumerableType.GetGenericTypeDefinition())
)
{
result = GetTypedEnumerable(refs.Select(sRef => MakeRefToInfo(sRef, enumerableType.GetGenericArguments()[0])), enumerableType);
}
else
{
result = GetTypedEnumerable(refs.Select(sRef => sRef.GetServiceWithType(actualServiceType)), enumerableType);
}
}
else
{
result = MakeRefToInfo(refs.FirstOrDefault(), gArgs[0]);
}
}
}
return(result);
}
public Object ProvideInjection(SPI.Instance.CompositeInstance instance, AbstractInjectableModel model, Type targetType)
{
// Code generation will use Lazy<> by itself if needed, don't do check here.
Object result;
InjectionFunctionality func;
var scope = model.InjectionScope;
if (scope != null && this._functionalities.TryGetValue(scope.GetType(), out func))
{
result = func.ProvideInjection(instance, model, targetType);
}
else
{
result = null;
}
return(result);
}
public Object ProvideInjection(CompositeInstance instance, AbstractInjectableModel model, Type targetType)
{
KeyedRoleMap roleMap = RoleMapHolder.INVOCATION_DATA.Value.RoleMap;
Object result;
if (roleMap.ThisHasRole(targetType))
{
result = roleMap.Get <Object>(targetType);
}
else
{
FunctionInvocationDataAttribute attr = (FunctionInvocationDataAttribute)model.InjectionScope;
result = attr.GetFactory(targetType).NewInvocationData();
roleMap.Set(result);
}
return(result);
}
public InjectionTime GetInjectionTime(AbstractInjectableModel model)
{
var targetType = model.TargetType;
var attribute = (StateAttribute)model.InjectionScope;
return(typeof(CompositeProperty).IsAssignableFrom(targetType) ||
typeof(CompositeEvent).IsAssignableFrom(targetType) ||
!this.FindSuitable <PropertyInfo, PropertyModel>(
model.CompositeModel,
model,
attribute.ElementName,
attribute.DeclaringType,
method => method.PropertyModel,
GetActualTargetType <CompositeProperty>(targetType),
pInfo => pInfo.PropertyType
).Any() ?
InjectionTime.ON_CREATION :
InjectionTime.ON_METHOD_INVOKATION);
}
private static Type GetBottommostDeclaringType(AbstractInjectableModel iModel)
{
var useWholeHierarchy = iModel is ParameterModel;
//if (!useFragments)
//{
// var owner = ((ParameterModel)iModel).Owner ;
// useFragments = owner is SpecialMethodModel || owner is ConstructorModel;
//}
//return (useFragments ?
// iModel.CompositeModel.GetAllFragmentTypes() :
// iModel.CompositeModel.GetAllCompositeTypes() )
// .First( f => f.GetClassHierarchy().Contains( iModel.DeclaringType ) );
return(iModel.CompositeModel
.GetAllFragmentTypes()
.First(f =>
(useWholeHierarchy ? f.GetAllParentTypes() : f.GetClassHierarchy())
.Contains(iModel.DeclaringType)
));
}
protected IEnumerable <TModel> FindSuitable <TMemberInfo, TModel>(
CompositeModel compositeModel,
AbstractInjectableModel model,
String name,
Type declaringType,
Func <CompositeMethodModel, TModel> methodModelGetter,
Type targetType,
Func <TMemberInfo, Type> memberInfoTargetTypeGetter
)
where TMemberInfo : MemberInfo
where TModel : AbstractMemberInfoModel <TMemberInfo>
{
// Type mixinDeclaringType = model is ParameterModel ? ( (ParameterModel) model ).NativeInfo.Member.DeclaringType : ( (FieldModel) model ).NativeInfo.DeclaringType;
return(compositeModel.Methods
.Select(method => methodModelGetter(method))
.Where(targetModel => targetModel != null)
.Distinct()
.Where(targetModel =>
(name == null || name.Equals(targetModel.NativeInfo.Name)) &&
(declaringType == null || declaringType.Equals(targetModel.NativeInfo.DeclaringType.GetGenericDefinitionIfContainsGenericParameters())) &&
(targetType == null || ReflectionHelper.AreStructurallySame(targetType, memberInfoTargetTypeGetter(targetModel.NativeInfo), true))
));
}
internal ThisTypeInfo(AbstractInjectableModel aModel)
{
this.model = aModel;
this.resolvedTargetType = aModel.TargetType;
this.resolvedDeclaringType = aModel.DeclaringType;
}
public InjectionTime GetInjectionTime(AbstractInjectableModel model)
{
return(InjectionTime.ON_METHOD_INVOKATION);
}
public Object ProvideInjection(CompositeInstance instance, AbstractInjectableModel model, Type targetType)
{
return(_holder == null ? _holder2 : _holder);
}
public ValidationResult InjectionPossible(AbstractInjectableModel model)
{
// TODO additional validation using FunctionInfo
return(new ValidationResult(true, null));
}
public Object ProvideInjection(CompositeInstance instance, AbstractInjectableModel model, Type targetType)
{
return(((CompositeInstanceImpl)instance).CreateOrGetConcernInvocationBase(targetType));
}
public ValidationResult InjectionPossible(AbstractInjectableModel model)
{
return(new ValidationResult(true, null));
}
public object ProvideInjection(Qi4CS.Core.SPI.Instance.CompositeInstance instance, AbstractInjectableModel model, Type targetType)
{
return(InjectableObject);
}
/// <summary>
/// Gets the injection time of given <see cref="AbstractInjectableModel"/>.
/// </summary>
/// <param name="model">The <see cref="AbstractInjectableModel"/>.</param>
/// <returns>The injection time for <paramref name="model"/>.</returns>
/// <exception cref="NullReferenceException">If <paramref name="model"/> is <c>null</c>.</exception>
/// <seealso cref="InjectionTime"/>
public static InjectionTime GetInjectionTime(this AbstractInjectableModel model)
{
return(model.CompositeModel.ApplicationModel.InjectionService.GetInjectionTime(model));
}
protected virtual Object ProvideNonStandardInjection(CompositeInstance instance, AbstractInjectableModel model, Type targetType)
{
return(null);
}
public InjectionTime GetInjectionTime(AbstractInjectableModel model)
{
return(InjectionTime.ON_CREATION);
}
protected abstract StructureServiceProviderSPI GetStructureServiceProvider(CompositeInstance instance, AbstractInjectableModel model, Type targetType);
protected virtual void ValidateParameterType(CompositeValidationResult result, CompositeModel compositeModel, AbstractMemberInfoModel <MemberInfo> memberModel, AbstractInjectableModel injectableModel, Type type)
{
if (this.IsCompositeTypeAffectingInjection(injectableModel.InjectionScope))
{
Stack <Type> stk = new Stack <Type>();
stk.Push(type);
while (stk.Any())
{
Type current = stk.Pop();
if (current.IsGenericParameter && current
#if WINDOWS_PHONE_APP
.GetTypeInfo()
#endif
.DeclaringMethod != null)
{
result.StructureValidationErrors.Add(ValidationErrorFactory.NewStructureError("Injection scopes affecting composite type (like " + typeof(ThisAttribute) + ", " + typeof(ConcernForAttribute) + ", or " + typeof(SideEffectForAttribute) + " are not allowed on method argument, which is referencing a generic method parameter.", compositeModel, memberModel));
}
else if (!current.IsGenericParameter && current.ContainsGenericParameters())
{
foreach (Type gArg in current.GetGenericArguments())
{
stk.Push(gArg);
}
}
}
}
}
/// <summary>
/// Checks whether given <see cref="AbstractInjectableModel"/> is non-<c>null</c> and related to a given fragment type.
/// </summary>
/// <param name="model">The <see cref="AbstractInjectableModel"/>.</param>
/// <param name="fragmentType">The fragment type.</param>
/// <returns><c>true</c> if <paramref name="model"/> is non-<c>null</c> and <see cref="AbstractInjectableModel.DeclaringType"/> or generic definition of it if it is generic type matches <paramref name="fragmentType"/>; <c>false</c> otherwise.</returns>
public static Boolean IsRelatedToFragment(this AbstractInjectableModel model, Type fragmentType)
{
var typeToCompare = model == null ? null : model.DeclaringType;
return(typeToCompare != null && typeToCompare.GetGenericDefinitionIfGenericType().IsAssignableFrom_IgnoreGenericArgumentsForGenericTypes(fragmentType));
}
protected virtual void ValidateInjectableModel(CompositeValidationResult result, CompositeModel compositeModel, AbstractInjectableModel model)
{
Int32 amount = model.GetAttributesMarkedWith(typeof(InjectionScopeAttribute)).Count;
if (amount > 1)
{
result.InjectionValidationErrors.Add(ValidationErrorFactory.NewInjectionError("Only one injection permitted for field or parameter.", model));
}
else
{
Attribute attr = model.InjectionScope;
if (attr != null)
{
InjectionService injectionService = compositeModel.ApplicationModel.InjectionService;
if (injectionService.HasFunctionalityFor(attr))
{
if (!model.IsOptional)
{
var validationResult = injectionService.InjectionPossible(model);
if (validationResult == null || !validationResult.InjectionPossible)
{
result.InjectionValidationErrors.Add(ValidationErrorFactory.NewInjectionError("Injection was not possible" + (validationResult == null ? "." : (": " + validationResult.AdditionalMessage)), model));
}
}
}
else if (!model.IsOptional)
{
result.InjectionValidationErrors.Add(ValidationErrorFactory.NewInjectionError("Could not find injection functionality for attribute " + attr + ".", model));
}
}
else if (model is FieldModel)
{
result.InternalValidationErrors.Add(ValidationErrorFactory.NewInternalError("Injection attribute was null", model));
}
}
}
/// <summary>
/// Checks whether given <see cref="AbstractInjectableModel"/> is non-<c>null</c> and the injectable value will be dependant on fragment instance.
/// </summary>
/// <param name="model">The <see cref="AbstractInjectableModel"/>.</param>
/// <returns><c>true</c> if <paramref name="model"/> is non-<c>null</c> and the injection scope attribute has <see cref="FragmentDependentInjectionAttribute"/> applied to it; <c>false</c> otherwise.</returns>
public static Boolean IsFragmentDependant(this AbstractInjectableModel model)
{
return(model != null && model.InjectionScope != null && model.GetAttributesOfAttribute(model.InjectionScope.GetType()).ContainsKey(typeof(FragmentDependentInjectionAttribute)));
}
protected override SPI.Instance.StructureServiceProviderSPI GetStructureServiceProvider(CompositeInstance instance, AbstractInjectableModel model, Type targetType)
{
return(((SingletonApplication)instance.StructureOwner).StructureServices);
}
