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);
}
}
}
}
