protected virtual void ValidateConstraintModel(CompositeValidationResult result, CompositeModel model, ConstraintModel constraint)
{
if (constraint.ConstraintType == null)
{
result.InternalValidationErrors.Add(ValidationErrorFactory.NewInternalError("Constraint model had null as constraint type", constraint));
}
}
protected virtual void ValidateFragmentMethod(CompositeValidationResult result, CompositeModel compositeModel, CompositeMethodModel compositeMethod, AbstractFragmentMethodModel methodModel)
{
if (compositeMethod == null)
{
result.InternalValidationErrors.Add(ValidationErrorFactory.NewInternalError("Composite method model may not be null.", compositeModel));
}
if (methodModel != null)
{
var declType = methodModel.NativeInfo.DeclaringType;
if (!declType
#if WINDOWS_PHONE_APP
.GetTypeInfo()
#endif
.IsClass)
{
result.StructureValidationErrors.Add(ValidationErrorFactory.NewStructureError("The declaring type of fragment method " + methodModel.NativeInfo + " must be a class, however " + declType + " is not a class.", compositeModel, compositeMethod));
}
if (!methodModel.IsGeneric && (!methodModel.NativeInfo.IsVirtual || methodModel.NativeInfo.IsFinal))
{
result.StructureValidationErrors.Add(ValidationErrorFactory.NewStructureError("The method " + methodModel.NativeInfo + " in " + declType + " is not virtual, however, all composite methods must be virtual.", compositeModel, methodModel));
}
if (declType
#if WINDOWS_PHONE_APP
.GetTypeInfo()
#endif
.IsSealed)
{
result.StructureValidationErrors.Add(ValidationErrorFactory.NewStructureError("The type " + declType + " is sealed, however, all fragment types must be non-sealed.", compositeModel, methodModel));
}
//if ( !declType.IsPublic && !declType.IsNestedPublic )
//{
// String msg = null;
// if ( methodModel.NativeInfo.IsAssembly || methodModel.NativeInfo.IsFamilyOrAssembly )
// {
// if ( !declType.Assembly.GetCustomAttributes( true ).OfType<InternalsVisibleToAttribute>().Any( attr => Qi4CSGeneratedAssemblyAttribute.ASSEMBLY_NAME.Equals( attr.AssemblyName ) ) )
// {
// msg = "The type " + declType + " is marked as internal, however, the " + typeof( InternalsVisibleToAttribute ) + " with argument " + typeof( Qi4CSGeneratedAssemblyAttribute ) + ".ASSEMBLY_NAME is not applied to the assembly";
// }
// }
// else
// {
// msg = "The type " + declType + " is not visible to the generated assembly.";
// }
// if ( msg != null )
// {
// result.AddStructureError( new StructureValidationErrorImpl( compositeModel, methodModel, msg ) );
// }
//}
var genName = Qi4CSGeneratedAssemblyAttribute.GetGeneratedAssemblyName(declType.GetAssembly());
if (!IsTypeVisible(declType, genName))
{
result.StructureValidationErrors.Add(ValidationErrorFactory.NewStructureError("The type " + declType + " is not visible. Consider either making it public, or internal with combination of applying " + typeof(InternalsVisibleToAttribute) + " with argument " + typeof(Qi4CSGeneratedAssemblyAttribute) + ".ASSEMBLY_NAME to the assembly.", compositeModel, methodModel));
}
}
}
protected virtual void ValidateField(CompositeValidationResult result, CompositeModel compositeModel, FieldModel fieldModel)
{
if (fieldModel == null)
{
result.InternalValidationErrors.Add(ValidationErrorFactory.NewInternalError("Field model may not be null.", compositeModel));
}
else
{
this.ValidateInjectableModel(result, compositeModel, fieldModel);
}
}
public override void ValidateModelsInApplication(ApplicationModel <ApplicationSPI> appModel, ApplicationValidationResultMutable appValidation)
{
var sModels = appModel.CompositeModels.Values.OfType <ServiceCompositeModel>().ToArray();
if (sModels.Any(sModel => sModel.ServiceID == null))
{
appValidation.InternalValidationErrors.Add(ValidationErrorFactory.NewInternalError("The following service composite models had their service ID as null: " + String.Join(", ", sModels.Where(sModel => sModel.ServiceID == null)), null));
}
else
{
var grouping = sModels.GroupBy(sModel => sModel.ServiceID).Where(g => g.Count() > 1).ToArray();
if (grouping.Length > 0)
{
appValidation.StructureValidationErrors.Add(ValidationErrorFactory.NewStructureError("The following services have same service ID: " + String.Join("; ", grouping.Select(g => String.Join(", ", g))), appModel));
}
}
}
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));
}
}
}
public virtual void ValidateComposite(CompositeValidationResultMutable result, CompositeModel compositeModel)
{
// TODO check that all keys of the type model CompositeTypeInformations and FragmentTypeInformations are assignable from all methods of the composite model.
this.ValidateCompositeTypeModel(result, compositeModel);
if (compositeModel.MainCodeGenerationType == null)
{
result.StructureValidationErrors.Add(ValidationErrorFactory.NewStructureError("Composite model main code generation type was null", compositeModel));
}
else if (!compositeModel.PublicTypes.Contains(compositeModel.MainCodeGenerationType))
{
result.StructureValidationErrors.Add(ValidationErrorFactory.NewStructureError("Composite model main code generation type " + compositeModel.MainCodeGenerationType + " was not contained in its public types (" + String.Join(", ", compositeModel.PublicTypes) + ").", compositeModel));
}
else
{
CompositeMethodModel[] unimplementedMethods = compositeModel.Methods
.Where(methodModel => methodModel.Mixin == null)
.ToArray();
if (unimplementedMethods.Any())
{
foreach (CompositeMethodModel unimplementedMethod in unimplementedMethods)
{
result.StructureValidationErrors.Add(ValidationErrorFactory.NewStructureError("No implementation found for " + unimplementedMethod.NativeInfo + ".", compositeModel, unimplementedMethod));
}
}
else
{
foreach (FieldModel fieldModel in compositeModel.Fields)
{
this.ValidateField(result, compositeModel, fieldModel);
}
foreach (ConstructorModel constructorModel in compositeModel.Constructors)
{
foreach (ParameterModel parameterModel in constructorModel.Parameters)
{
this.ValidateParameter(result, compositeModel, parameterModel);
}
}
foreach (CompositeMethodModel compositeMethod in compositeModel.Methods)
{
if (compositeMethod == null)
{
result.InternalValidationErrors.Add(ValidationErrorFactory.NewInternalError("Composite method model may not be null.", compositeModel));
}
else
{
this.ValidateParameter(result, compositeModel, compositeMethod.Result);
foreach (ParameterModel parameterModel in compositeMethod.Parameters)
{
this.ValidateParameter(result, compositeModel, parameterModel);
}
foreach (AbstractFragmentMethodModel fragmentMethod in compositeMethod.GetAllMethodModels().OfType <AbstractFragmentMethodModel>())
{
this.ValidateFragmentMethod(result, compositeModel, compositeMethod, fragmentMethod);
}
foreach (ConstraintModel constraintModel in compositeMethod.Parameters.SelectMany(param => param.Constraints).Concat(compositeMethod.Result.Constraints))
{
if (constraintModel.ConstraintType == null)
{
result.StructureValidationErrors.Add(ValidationErrorFactory.NewStructureError("Could not bind parameter constraint " + constraintModel.ConstraintAttribute + ".", compositeModel, compositeMethod));
}
else if (constraintModel.ConstraintType.GetConstructor(Empty <Type> .Array) == null)
{
result.StructureValidationErrors.Add(ValidationErrorFactory.NewStructureError("Constraints must have constructor without parameters, but constraint of type " + constraintModel.ConstraintType + " does not.", compositeModel, compositeMethod));
}
else if (constraintModel.ConstraintType.ContainsGenericParameters() && !constraintModel.ConstraintType.IsGenericTypeDefinition())
{
result.StructureValidationErrors.Add(ValidationErrorFactory.NewStructureError("Constraint type " + constraintModel.ConstraintType + " contains non-closed generic parameters but is not generic type definition.", compositeModel, compositeMethod));
}
}
}
}
foreach (var pModel in compositeModel.GetAllPropertyModels())
{
this.ValidatePropertyModel(result, compositeModel, pModel);
}
foreach (SpecialMethodModel specialMethod in compositeModel.SpecialMethods)
{
this.ValidateSpecialMethodModel(result, compositeModel, specialMethod);
}
foreach (var constraintModel in compositeModel.GetAllConstraints())
{
this.ValidateConstraintModel(result, compositeModel, constraintModel);
}
if (!result.IQ.HasAnyErrors())
{
result.TypeModel = new CompositeTypeModelImpl(compositeModel, result);
}
}
}
}
