internal static bool TryWriteCsdl(IEdmModel model, Func<string, XmlWriter> writerProvider, bool singleFileExpected, out IEnumerable<EdmError> errors) { EdmUtil.CheckArgumentNull(model, "model"); EdmUtil.CheckArgumentNull(writerProvider, "writerProvider"); errors = model.GetSerializationErrors(); if (errors.FirstOrDefault() != null) { return false; } IEnumerable<EdmSchema> schemas = new EdmModelSchemaSeparationSerializationVisitor(model).GetSchemas(); if (schemas.Count() > 1 && singleFileExpected) { errors = new EdmError[] { new EdmError(new CsdlLocation(0, 0), EdmErrorCode.SingleFileExpected, Edm.Strings.Serializer_SingleFileExpected) }; return false; } if (schemas.Count() == 0) { errors = new EdmError[] { new EdmError(new CsdlLocation(0, 0), EdmErrorCode.NoSchemasProduced, Edm.Strings.Serializer_NoSchemasProduced) }; return false; } WriteSchemas(model, schemas, writerProvider); errors = Enumerable.Empty<EdmError>(); return true; }
/// <summary> /// Outputs an EDMX artifact to the provided XmlWriter. /// </summary> /// <param name="model">Model to be written.</param> /// <param name="writer">XmlWriter the generated EDMX will be written to.</param> /// <param name="target">Target implementation of the EDMX being generated.</param> /// <param name="errors">Errors that prevented successful serialization, or no errors if serialization was successfull. </param> /// <returns>A value indicating whether serialization was successful.</returns> public static bool TryWriteEdmx(IEdmModel model, XmlWriter writer, EdmxTarget target, out IEnumerable<EdmError> errors) { EdmUtil.CheckArgumentNull(model, "model"); EdmUtil.CheckArgumentNull(writer, "writer"); errors = model.GetSerializationErrors(); if (errors.FirstOrDefault() != null) { return false; } Version edmxVersion = model.GetEdmxVersion(); if (edmxVersion != null) { if (!CsdlConstants.SupportedEdmxVersions.ContainsKey(edmxVersion)) { errors = new EdmError[] { new EdmError(new CsdlLocation(0, 0), EdmErrorCode.UnknownEdmxVersion, Edm.Strings.Serializer_UnknownEdmxVersion) }; return false; } } else if (!CsdlConstants.EdmToEdmxVersions.TryGetValue(model.GetEdmVersion() ?? EdmConstants.EdmVersionLatest, out edmxVersion)) { errors = new EdmError[] { new EdmError(new CsdlLocation(0, 0), EdmErrorCode.UnknownEdmVersion, Edm.Strings.Serializer_UnknownEdmVersion) }; return false; } IEnumerable<EdmSchema> schemas = new EdmModelSchemaSeparationSerializationVisitor(model).GetSchemas(); EdmxWriter edmxWriter = new EdmxWriter(model, schemas, writer, edmxVersion, target); edmxWriter.WriteEdmx(); errors = Enumerable.Empty<EdmError>(); return true; }
private static bool TestNullabilityMatch(this IEdmTypeReference expressionType, IEdmTypeReference assertedType, EdmLocation location, out IEnumerable<EdmError> discoveredErrors) { if (assertedType.IsNullable || !expressionType.IsNullable) { discoveredErrors = Enumerable.Empty<EdmError>(); return true; } else { EdmError[] edmError = new EdmError[1]; edmError[0] = new EdmError(location, EdmErrorCode.CannotAssertNullableTypeAsNonNullableType, Strings.EdmModel_Validator_Semantic_CannotAssertNullableTypeAsNonNullableType(expressionType.FullName())); discoveredErrors = edmError; return false; } }
public static bool TryParse(IEnumerable<XmlReader> csdlReaders, out CsdlModel entityModel, out IEnumerable<EdmError> errors) { EdmUtil.CheckArgumentNull(csdlReaders, "csdlReaders"); CsdlParser parser = new CsdlParser(); int readerCount = 0; foreach (var inputReader in csdlReaders) { if (inputReader != null) { try { parser.AddReader(inputReader); } catch (XmlException e) { entityModel = null; errors = new EdmError[] { new EdmError(new CsdlLocation(e.LineNumber, e.LinePosition), EdmErrorCode.XmlError, e.Message) }; return false; } } else { entityModel = null; errors = new EdmError[] { new EdmError(null, EdmErrorCode.NullXmlReader, Edm.Strings.CsdlParser_NullXmlReader) }; return false; } readerCount++; } if (readerCount == 0) { entityModel = null; errors = new EdmError[] { new EdmError(null, EdmErrorCode.NoReadersProvided, Edm.Strings.CsdlParser_NoReadersProvided) }; return false; } bool success = parser.GetResult(out entityModel, out errors); if (!success) { entityModel = null; } return success; }
public static bool TryWriteEdmx(IEdmModel model, XmlWriter writer, EdmxTarget target, out IEnumerable<EdmError> errors) { EdmUtil.CheckArgumentNull<IEdmModel>(model, "model"); EdmUtil.CheckArgumentNull<XmlWriter>(writer, "writer"); errors = model.GetSerializationErrors(); if (errors.FirstOrDefault<EdmError>() == null) { Version edmxVersion = model.GetEdmxVersion(); if (edmxVersion == null) { Dictionary<Version, Version> edmToEdmxVersions = CsdlConstants.EdmToEdmxVersions; Version edmVersion = model.GetEdmVersion(); Version edmVersionLatest = edmVersion; if (edmVersion == null) { edmVersionLatest = EdmConstants.EdmVersionLatest; } if (!edmToEdmxVersions.TryGetValue(edmVersionLatest, out edmxVersion)) { EdmError[] edmError = new EdmError[1]; edmError[0] = new EdmError(new CsdlLocation(0, 0), EdmErrorCode.UnknownEdmVersion, Strings.Serializer_UnknownEdmVersion); errors = edmError; return false; } } else { if (!CsdlConstants.SupportedEdmxVersions.ContainsKey(edmxVersion)) { EdmError[] edmErrorArray = new EdmError[1]; edmErrorArray[0] = new EdmError(new CsdlLocation(0, 0), EdmErrorCode.UnknownEdmxVersion, Strings.Serializer_UnknownEdmxVersion); errors = edmErrorArray; return false; } } IEnumerable<EdmSchema> schemas = (new EdmModelSchemaSeparationSerializationVisitor(model)).GetSchemas(); EdmxWriter edmxWriter = new EdmxWriter(model, schemas, writer, edmxVersion, target); edmxWriter.WriteEdmx(); errors = Enumerable.Empty<EdmError>(); return true; } else { return false; } }
private static bool TryAssertStringConstantAsType(IEdmStringConstantExpression expression, IEdmTypeReference type, out IEnumerable <EdmError> discoveredErrors) { if (!type.IsString()) { discoveredErrors = new EdmError[] { new EdmError(expression.Location(), EdmErrorCode.ExpressionPrimitiveKindNotValidForAssertedType, Edm.Strings.EdmModel_Validator_Semantic_ExpressionPrimitiveKindNotValidForAssertedType) }; return(false); } IEdmStringTypeReference stringType = type.AsString(); if (stringType.MaxLength.HasValue && expression.Value.Length > stringType.MaxLength.Value) { discoveredErrors = new EdmError[] { new EdmError(expression.Location(), EdmErrorCode.StringConstantLengthOutOfRange, Edm.Strings.EdmModel_Validator_Semantic_StringConstantLengthOutOfRange(expression.Value.Length, stringType.MaxLength.Value)) }; return(false); } discoveredErrors = Enumerable.Empty <EdmError>(); return(true); }
private static bool TestTypeMatch(this IEdmType expressionType, IEdmType assertedType, EdmLocation location, bool matchExactly, out IEnumerable <EdmError> discoveredErrors) { if (matchExactly) { if (!expressionType.IsEquivalentTo(assertedType)) { discoveredErrors = new EdmError[] { new EdmError(location, EdmErrorCode.ExpressionNotValidForTheAssertedType, Edm.Strings.EdmModel_Validator_Semantic_ExpressionNotValidForTheAssertedType) }; return(false); } } else { // A bad type matches anything (so as to avoid generating spurious errors). if (expressionType.TypeKind == EdmTypeKind.None || expressionType.IsBad()) { discoveredErrors = Enumerable.Empty <EdmError>(); return(true); } if (expressionType.TypeKind == EdmTypeKind.Primitive && assertedType.TypeKind == EdmTypeKind.Primitive) { IEdmPrimitiveType primitiveExpressionType = expressionType as IEdmPrimitiveType; IEdmPrimitiveType primitiveAssertedType = assertedType as IEdmPrimitiveType; if (!primitiveExpressionType.PrimitiveKind.PromotesTo(primitiveAssertedType.PrimitiveKind)) { discoveredErrors = new EdmError[] { new EdmError(location, EdmErrorCode.ExpressionPrimitiveKindNotValidForAssertedType, Edm.Strings.EdmModel_Validator_Semantic_ExpressionPrimitiveKindCannotPromoteToAssertedType(expressionType.ToTraceString(), assertedType.ToTraceString())) }; return(false); } } else { if (!expressionType.IsOrInheritsFrom(assertedType)) { discoveredErrors = new EdmError[] { new EdmError(location, EdmErrorCode.ExpressionNotValidForTheAssertedType, Edm.Strings.EdmModel_Validator_Semantic_ExpressionNotValidForTheAssertedType) }; return(false); } } } discoveredErrors = Enumerable.Empty <EdmError>(); return(true); }
private static bool TestTypeMatch(this IEdmTypeReference expressionType, IEdmTypeReference assertedType, EdmLocation location, out IEnumerable <EdmError> discoveredErrors) { if (expressionType.TestNullabilityMatch(assertedType, location, out discoveredErrors)) { if (expressionType.TypeKind() == EdmTypeKind.None || expressionType.IsBad()) { discoveredErrors = Enumerable.Empty <EdmError>(); return(true); } else { if (!expressionType.IsPrimitive() || !assertedType.IsPrimitive()) { if (!expressionType.Definition.IsEquivalentTo(assertedType.Definition)) { EdmError[] edmError = new EdmError[1]; edmError[0] = new EdmError(location, EdmErrorCode.ExpressionNotValidForTheAssertedType, Strings.EdmModel_Validator_Semantic_ExpressionNotValidForTheAssertedType); discoveredErrors = edmError; return(false); } } else { if (!expressionType.PrimitiveKind().PromotesTo(assertedType.AsPrimitive().PrimitiveKind())) { EdmError[] edmErrorArray = new EdmError[1]; edmErrorArray[0] = new EdmError(location, EdmErrorCode.ExpressionPrimitiveKindNotValidForAssertedType, Strings.EdmModel_Validator_Semantic_ExpressionPrimitiveKindCannotPromoteToAssertedType(expressionType.FullName(), assertedType.FullName())); discoveredErrors = edmErrorArray; return(false); } } discoveredErrors = Enumerable.Empty <EdmError>(); return(true); } } else { return(false); } }
internal static bool TryAssertCollectionAsType(this IEdmCollectionExpression expression, IEdmTypeReference type, IEdmType context, bool matchExactly, out IEnumerable <EdmError> discoveredErrors) { if (!type.IsCollection()) { discoveredErrors = new EdmError[] { new EdmError(expression.Location(), EdmErrorCode.CollectionExpressionNotValidForNonCollectionType, Edm.Strings.EdmModel_Validator_Semantic_CollectionExpressionNotValidForNonCollectionType) }; return(false); } IEdmTypeReference collectionElementType = type.AsCollection().ElementType(); bool success = true; List <EdmError> errors = new List <EdmError>(); IEnumerable <EdmError> recursiveErrors; foreach (IEdmExpression element in expression.Elements) { success = TryAssertType(element, collectionElementType, context, matchExactly, out recursiveErrors) && success; errors.AddRange(recursiveErrors); } discoveredErrors = errors; return(success); }
internal static bool TryWriteCsdl(IEdmModel model, Func<string, XmlWriter> writerProvider, bool singleFileExpected, out IEnumerable<EdmError> errors) { EdmUtil.CheckArgumentNull<IEdmModel>(model, "model"); EdmUtil.CheckArgumentNull<Func<string, XmlWriter>>(writerProvider, "writerProvider"); errors = model.GetSerializationErrors(); if (errors.FirstOrDefault<EdmError>() == null) { IEnumerable<EdmSchema> schemas = (new EdmModelSchemaSeparationSerializationVisitor(model)).GetSchemas(); if (schemas.Count<EdmSchema>() <= 1 || !singleFileExpected) { if (schemas.Count<EdmSchema>() != 0) { CsdlWriter.WriteSchemas(model, schemas, writerProvider); errors = Enumerable.Empty<EdmError>(); return true; } else { EdmError[] edmError = new EdmError[1]; edmError[0] = new EdmError(new CsdlLocation(0, 0), EdmErrorCode.NoSchemasProduced, Strings.Serializer_NoSchemasProduced); errors = edmError; return false; } } else { EdmError[] edmErrorArray = new EdmError[1]; edmErrorArray[0] = new EdmError(new CsdlLocation(0, 0), EdmErrorCode.SingleFileExpected, Strings.Serializer_SingleFileExpected); errors = edmErrorArray; return false; } } else { return false; } }
private IEdmAssociationEnd ComputeTo() { string toRole = this.navigationProperty.ToRole; string fromRole = this.navigationProperty.FromRole; this.Model.SetAssociationEndName(this, fromRole); IEdmAssociation association = this.Association; if (toRole != fromRole) { if (association.End1.Name != toRole) { if (association.End2.Name != toRole) { EdmError[] edmError = new EdmError[1]; edmError[0] = new EdmError(base.Location, EdmErrorCode.BadNavigationProperty, Strings.EdmModel_Validator_Semantic_BadNavigationPropertyUndefinedRole(this.Name, toRole, association.Name)); return new CsdlSemanticsNavigationProperty.BadCsdlSemanticsNavigationPropertyToEnd(this.Association, toRole, edmError); } else { return association.End2; } } else { return association.End1; } } else { EdmError[] edmErrorArray = new EdmError[1]; edmErrorArray[0] = new EdmError(base.Location, EdmErrorCode.BadNavigationProperty, Strings.EdmModel_Validator_Semantic_BadNavigationPropertyRolesCannotBeTheSame(this.Name)); return new CsdlSemanticsNavigationProperty.BadCsdlSemanticsNavigationPropertyToEnd(association, toRole, edmErrorArray); } }
public static bool TryAssertType(this IEdmExpression expression, IEdmTypeReference type, out IEnumerable <EdmError> discoveredErrors) { EdmError[] edmError; EdmUtil.CheckArgumentNull <IEdmExpression>(expression, "expression"); if (type == null || type.TypeKind() == EdmTypeKind.None) { discoveredErrors = Enumerable.Empty <EdmError>(); return(true); } else { EdmExpressionKind expressionKind = expression.ExpressionKind; switch (expressionKind) { case EdmExpressionKind.BinaryConstant: case EdmExpressionKind.BooleanConstant: case EdmExpressionKind.DateTimeConstant: case EdmExpressionKind.DateTimeOffsetConstant: case EdmExpressionKind.DecimalConstant: case EdmExpressionKind.FloatingConstant: case EdmExpressionKind.GuidConstant: case EdmExpressionKind.IntegerConstant: case EdmExpressionKind.StringConstant: case EdmExpressionKind.TimeConstant: { IEdmPrimitiveValue edmPrimitiveValue = (IEdmPrimitiveValue)expression; if (edmPrimitiveValue.Type == null) { return(edmPrimitiveValue.TryAssertPrimitiveAsType(type, out discoveredErrors)); } else { return(edmPrimitiveValue.Type.TestTypeMatch(type, expression.Location(), out discoveredErrors)); } } case EdmExpressionKind.Null: { return(((IEdmNullExpression)expression).TryAssertNullAsType(type, out discoveredErrors)); } case EdmExpressionKind.Record: { IEdmRecordExpression edmRecordExpression = (IEdmRecordExpression)expression; if (edmRecordExpression.DeclaredType == null) { return(edmRecordExpression.TryAssertRecordAsType(type, out discoveredErrors)); } else { return(edmRecordExpression.DeclaredType.TestTypeMatch(type, expression.Location(), out discoveredErrors)); } } case EdmExpressionKind.Collection: { IEdmCollectionExpression edmCollectionExpression = (IEdmCollectionExpression)expression; if (edmCollectionExpression.DeclaredType == null) { return(edmCollectionExpression.TryAssertCollectionAsType(type, out discoveredErrors)); } else { return(edmCollectionExpression.DeclaredType.TestTypeMatch(type, expression.Location(), out discoveredErrors)); } } case EdmExpressionKind.Path: { return(((IEdmPathExpression)expression).TryAssertPathAsType(type, out discoveredErrors)); } case EdmExpressionKind.ParameterReference: case EdmExpressionKind.FunctionReference: case EdmExpressionKind.PropertyReference: case EdmExpressionKind.ValueTermReference: case EdmExpressionKind.EntitySetReference: case EdmExpressionKind.EnumMemberReference: { edmError = new EdmError[1]; edmError[0] = new EdmError(expression.Location(), EdmErrorCode.ExpressionNotValidForTheAssertedType, Strings.EdmModel_Validator_Semantic_ExpressionNotValidForTheAssertedType); discoveredErrors = edmError; return(false); } case EdmExpressionKind.If: { return(((IEdmIfExpression)expression).TryAssertIfAsType(type, out discoveredErrors)); } case EdmExpressionKind.AssertType: { return(((IEdmAssertTypeExpression)expression).Type.TestTypeMatch(type, expression.Location(), out discoveredErrors)); } case EdmExpressionKind.IsType: { return(EdmCoreModel.Instance.GetBoolean(false).TestTypeMatch(type, expression.Location(), out discoveredErrors)); } case EdmExpressionKind.FunctionApplication: { IEdmApplyExpression edmApplyExpression = (IEdmApplyExpression)expression; if (edmApplyExpression.AppliedFunction != null) { IEdmFunctionBase appliedFunction = edmApplyExpression.AppliedFunction as IEdmFunctionBase; if (appliedFunction != null) { return(appliedFunction.ReturnType.TestTypeMatch(type, expression.Location(), out discoveredErrors)); } } discoveredErrors = Enumerable.Empty <EdmError>(); return(true); } case EdmExpressionKind.LabeledExpressionReference: { return(((IEdmLabeledExpressionReferenceExpression)expression).ReferencedLabeledExpression.TryAssertType(type, out discoveredErrors)); } case EdmExpressionKind.Labeled: { return(((IEdmLabeledExpression)expression).Expression.TryAssertType(type, out discoveredErrors)); } default: { edmError = new EdmError[1]; edmError[0] = new EdmError(expression.Location(), EdmErrorCode.ExpressionNotValidForTheAssertedType, Strings.EdmModel_Validator_Semantic_ExpressionNotValidForTheAssertedType); discoveredErrors = edmError; return(false); } } } }
internal static bool TryAssertRecordAsType(this IEdmRecordExpression expression, IEdmTypeReference type, out IEnumerable <EdmError> discoveredErrors) { IEnumerable <EdmError> edmErrors = null; EdmUtil.CheckArgumentNull <IEdmRecordExpression>(expression, "expression"); EdmUtil.CheckArgumentNull <IEdmTypeReference>(type, "type"); if (type.IsStructured()) { HashSetInternal <string> strs = new HashSetInternal <string>(); List <EdmError> edmErrors1 = new List <EdmError>(); IEdmStructuredTypeReference edmStructuredTypeReference = type.AsStructured(); IEnumerator <IEdmProperty> enumerator = edmStructuredTypeReference.StructuredDefinition().Properties().GetEnumerator(); using (enumerator) { Func <IEdmPropertyConstructor, bool> func = null; while (enumerator.MoveNext()) { IEdmProperty current = enumerator.Current; IEnumerable <IEdmPropertyConstructor> properties = expression.Properties; if (func == null) { func = (IEdmPropertyConstructor p) => p.Name == current.Name; } IEdmPropertyConstructor edmPropertyConstructor = properties.FirstOrDefault <IEdmPropertyConstructor>(func); if (edmPropertyConstructor != null) { if (!edmPropertyConstructor.Value.TryAssertType(current.Type, out edmErrors)) { IEnumerator <EdmError> enumerator1 = edmErrors.GetEnumerator(); using (enumerator1) { while (enumerator1.MoveNext()) { EdmError edmError = enumerator1.Current; edmErrors1.Add(edmError); } } } strs.Add(current.Name); } else { edmErrors1.Add(new EdmError(expression.Location(), EdmErrorCode.RecordExpressionMissingRequiredProperty, Strings.EdmModel_Validator_Semantic_RecordExpressionMissingProperty(current.Name))); } } } if (!edmStructuredTypeReference.IsOpen()) { foreach (IEdmPropertyConstructor property in expression.Properties) { if (strs.Contains(property.Name)) { continue; } edmErrors1.Add(new EdmError(expression.Location(), EdmErrorCode.RecordExpressionHasExtraProperties, Strings.EdmModel_Validator_Semantic_RecordExpressionHasExtraProperties(property.Name))); } } if (edmErrors1.FirstOrDefault <EdmError>() == null) { discoveredErrors = Enumerable.Empty <EdmError>(); return(true); } else { discoveredErrors = edmErrors1; return(false); } } else { EdmError[] edmErrorArray = new EdmError[1]; edmErrorArray[0] = new EdmError(expression.Location(), EdmErrorCode.RecordExpressionNotValidForNonStructuredType, Strings.EdmModel_Validator_Semantic_RecordExpressionNotValidForNonStructuredType); discoveredErrors = edmErrorArray; return(false); } }
internal static bool TryAssertPrimitiveAsType(this IEdmPrimitiveValue expression, IEdmTypeReference type, out IEnumerable <EdmError> discoveredErrors) { EdmError[] edmError; if (type.IsPrimitive()) { EdmValueKind valueKind = expression.ValueKind; switch (valueKind) { case EdmValueKind.Binary: { return(ExpressionTypeChecker.TryAssertBinaryConstantAsType((IEdmBinaryConstantExpression)expression, type, out discoveredErrors)); } case EdmValueKind.Boolean: { return(ExpressionTypeChecker.TryAssertBooleanConstantAsType((IEdmBooleanConstantExpression)expression, type, out discoveredErrors)); } case EdmValueKind.Collection: case EdmValueKind.Enum: case EdmValueKind.Null: case EdmValueKind.Structured: { edmError = new EdmError[1]; edmError[0] = new EdmError(expression.Location(), EdmErrorCode.ExpressionPrimitiveKindNotValidForAssertedType, Strings.EdmModel_Validator_Semantic_ExpressionPrimitiveKindNotValidForAssertedType); discoveredErrors = edmError; return(false); } case EdmValueKind.DateTimeOffset: { return(ExpressionTypeChecker.TryAssertDateTimeOffsetConstantAsType((IEdmDateTimeOffsetConstantExpression)expression, type, out discoveredErrors)); } case EdmValueKind.DateTime: { return(ExpressionTypeChecker.TryAssertDateTimeConstantAsType((IEdmDateTimeConstantExpression)expression, type, out discoveredErrors)); } case EdmValueKind.Decimal: { return(ExpressionTypeChecker.TryAssertDecimalConstantAsType((IEdmDecimalConstantExpression)expression, type, out discoveredErrors)); } case EdmValueKind.Floating: { return(ExpressionTypeChecker.TryAssertFloatingConstantAsType((IEdmFloatingConstantExpression)expression, type, out discoveredErrors)); } case EdmValueKind.Guid: { return(ExpressionTypeChecker.TryAssertGuidConstantAsType((IEdmGuidConstantExpression)expression, type, out discoveredErrors)); } case EdmValueKind.Integer: { return(ExpressionTypeChecker.TryAssertIntegerConstantAsType((IEdmIntegerConstantExpression)expression, type, out discoveredErrors)); } case EdmValueKind.String: { return(ExpressionTypeChecker.TryAssertStringConstantAsType((IEdmStringConstantExpression)expression, type, out discoveredErrors)); } case EdmValueKind.Time: { return(ExpressionTypeChecker.TryAssertTimeConstantAsType((IEdmTimeConstantExpression)expression, type, out discoveredErrors)); } default: { edmError = new EdmError[1]; edmError[0] = new EdmError(expression.Location(), EdmErrorCode.ExpressionPrimitiveKindNotValidForAssertedType, Strings.EdmModel_Validator_Semantic_ExpressionPrimitiveKindNotValidForAssertedType); discoveredErrors = edmError; return(false); } } } else { EdmError[] edmErrorArray = new EdmError[1]; edmErrorArray[0] = new EdmError(expression.Location(), EdmErrorCode.PrimitiveConstantExpressionNotValidForNonPrimitiveType, Strings.EdmModel_Validator_Semantic_PrimitiveConstantExpressionNotValidForNonPrimitiveType); discoveredErrors = edmErrorArray; return(false); } }
private bool TryParse(IEnumerable<IEdmModel> references, out IEdmModel model, out IEnumerable<EdmError> parsingErrors) { Version edmxVersion; try { this.ParseEdmxFile(out edmxVersion); } catch (XmlException e) { model = null; parsingErrors = new EdmError[] { new EdmError(new CsdlLocation(e.LineNumber, e.LinePosition), EdmErrorCode.XmlError, e.Message) }; return false; } if (this.errors.Count == 0) { CsdlModel astModel; IEnumerable<EdmError> csdlErrors; if (this.csdlParser.GetResult(out astModel, out csdlErrors)) { model = new CsdlSemanticsModel(astModel, new CsdlSemanticsDirectValueAnnotationsManager(), references); Debug.Assert(edmxVersion != null, "edmxVersion != null"); model.SetEdmxVersion(edmxVersion); if (this.dataServiceVersion != null) { model.SetDataServiceVersion(this.dataServiceVersion); } if (this.maxDataServiceVersion != null) { model.SetMaxDataServiceVersion(this.maxDataServiceVersion); } } else { Debug.Assert(csdlErrors != null && csdlErrors.Count() > 0, "csdlErrors != null && csdlErrors.Count() > 0"); this.errors.AddRange(csdlErrors); model = null; } } else { model = null; } parsingErrors = this.errors; return this.errors.Count == 0; }
private static bool TryAssertTimeConstantAsType(IEdmTimeConstantExpression expression, IEdmTypeReference type, out IEnumerable<EdmError> discoveredErrors) { if (type.IsTime()) { discoveredErrors = Enumerable.Empty<EdmError>(); return true; } else { EdmError[] edmError = new EdmError[1]; edmError[0] = new EdmError(expression.Location(), EdmErrorCode.ExpressionPrimitiveKindNotValidForAssertedType, Strings.EdmModel_Validator_Semantic_ExpressionPrimitiveKindNotValidForAssertedType); discoveredErrors = edmError; return false; } }
private IEnumerable<EdmError> ComputeErrors() { byte[] numArray = null; if (EdmValueParser.TryParseBinary(this.expression.Value, out numArray)) { return Enumerable.Empty<EdmError>(); } else { EdmError[] edmError = new EdmError[1]; edmError[0] = new EdmError(base.Location, EdmErrorCode.InvalidBinary, Strings.ValueParser_InvalidBinary(this.expression.Value)); return edmError; } }
private bool TryParse(IEnumerable<IEdmModel> references, out IEdmModel model, out IEnumerable<EdmError> parsingErrors) { Version version = null; CsdlModel csdlModel = null; IEnumerable<EdmError> edmErrors = null; bool flag; try { this.ParseEdmxFile(out version); if (this.errors.Count != 0) { model = null; } else { if (!this.csdlParser.GetResult(out csdlModel, out edmErrors)) { this.errors.AddRange(edmErrors); model = null; } else { model = new CsdlSemanticsModel(csdlModel, new CsdlSemanticsDirectValueAnnotationsManager(), references); model.SetEdmxVersion(version); if (this.dataServiceVersion != null) { model.SetDataServiceVersion(this.dataServiceVersion); } if (this.maxDataServiceVersion != null) { model.SetMaxDataServiceVersion(this.maxDataServiceVersion); } } } parsingErrors = this.errors; return this.errors.Count == 0; } catch (XmlException xmlException1) { XmlException xmlException = xmlException1; model = null; EdmError[] edmError = new EdmError[1]; edmError[0] = new EdmError(new CsdlLocation(xmlException.LineNumber, xmlException.LinePosition), EdmErrorCode.XmlError, xmlException.Message); parsingErrors = edmError; flag = false; } return flag; }
private IEnumerable<IEdmEnumMember> ComputeMembers() { IEdmEnumMember csdlSemanticsEnumMember; List<IEdmEnumMember> edmEnumMembers = new List<IEdmEnumMember>(); long value = (long)-1; foreach (CsdlEnumMember member in this.enumeration.Members) { long? nullable = member.Value; if (nullable.HasValue) { long? value1 = member.Value; value = value1.Value; csdlSemanticsEnumMember = new CsdlSemanticsEnumMember(this, member); csdlSemanticsEnumMember.SetIsValueExplicit(this.Model, new bool?(true)); } else { if (value >= 0x7fffffffffffffffL) { CsdlSemanticsEnumTypeDefinition csdlSemanticsEnumTypeDefinition = this; string name = member.Name; EdmError[] edmErrorArray = new EdmError[1]; EdmError[] edmError = edmErrorArray; int num = 0; EdmLocation location = member.Location; EdmLocation edmLocation = location; if (location == null) { edmLocation = base.Location; } edmError[num] = new EdmError(edmLocation, EdmErrorCode.EnumMemberValueOutOfRange, Strings.CsdlSemantics_EnumMemberValueOutOfRange); csdlSemanticsEnumMember = new BadEnumMember(csdlSemanticsEnumTypeDefinition, name, edmErrorArray); } else { long? nullable1 = new long?(value + (long)1); value = nullable1.Value; member.Value = nullable1; csdlSemanticsEnumMember = new CsdlSemanticsEnumMember(this, member); } csdlSemanticsEnumMember.SetIsValueExplicit(this.Model, new bool?(false)); } edmEnumMembers.Add(csdlSemanticsEnumMember); } return edmEnumMembers; }
private IEnumerable<EdmError> ComputeErrors() { bool? nullable; if (EdmValueParser.TryParseBool(this.expression.Value, out nullable)) { return Enumerable.Empty<EdmError>(); } else { EdmError[] edmError = new EdmError[1]; edmError[0] = new EdmError(base.Location, EdmErrorCode.InvalidBoolean, Strings.ValueParser_InvalidBoolean(this.expression.Value)); return edmError; } }
public static bool TryAssertType(this IEdmExpression expression, IEdmTypeReference type, out IEnumerable<EdmError> discoveredErrors) { EdmError[] edmError; EdmUtil.CheckArgumentNull<IEdmExpression>(expression, "expression"); if (type == null || type.TypeKind() == EdmTypeKind.None) { discoveredErrors = Enumerable.Empty<EdmError>(); return true; } else { EdmExpressionKind expressionKind = expression.ExpressionKind; switch (expressionKind) { case EdmExpressionKind.BinaryConstant: case EdmExpressionKind.BooleanConstant: case EdmExpressionKind.DateTimeConstant: case EdmExpressionKind.DateTimeOffsetConstant: case EdmExpressionKind.DecimalConstant: case EdmExpressionKind.FloatingConstant: case EdmExpressionKind.GuidConstant: case EdmExpressionKind.IntegerConstant: case EdmExpressionKind.StringConstant: case EdmExpressionKind.TimeConstant: { IEdmPrimitiveValue edmPrimitiveValue = (IEdmPrimitiveValue)expression; if (edmPrimitiveValue.Type == null) { return edmPrimitiveValue.TryAssertPrimitiveAsType(type, out discoveredErrors); } else { return edmPrimitiveValue.Type.TestTypeMatch(type, expression.Location(), out discoveredErrors); } } case EdmExpressionKind.Null: { return ((IEdmNullExpression)expression).TryAssertNullAsType(type, out discoveredErrors); } case EdmExpressionKind.Record: { IEdmRecordExpression edmRecordExpression = (IEdmRecordExpression)expression; if (edmRecordExpression.DeclaredType == null) { return edmRecordExpression.TryAssertRecordAsType(type, out discoveredErrors); } else { return edmRecordExpression.DeclaredType.TestTypeMatch(type, expression.Location(), out discoveredErrors); } } case EdmExpressionKind.Collection: { IEdmCollectionExpression edmCollectionExpression = (IEdmCollectionExpression)expression; if (edmCollectionExpression.DeclaredType == null) { return edmCollectionExpression.TryAssertCollectionAsType(type, out discoveredErrors); } else { return edmCollectionExpression.DeclaredType.TestTypeMatch(type, expression.Location(), out discoveredErrors); } } case EdmExpressionKind.Path: { return ((IEdmPathExpression)expression).TryAssertPathAsType(type, out discoveredErrors); } case EdmExpressionKind.ParameterReference: case EdmExpressionKind.FunctionReference: case EdmExpressionKind.PropertyReference: case EdmExpressionKind.ValueTermReference: case EdmExpressionKind.EntitySetReference: case EdmExpressionKind.EnumMemberReference: { edmError = new EdmError[1]; edmError[0] = new EdmError(expression.Location(), EdmErrorCode.ExpressionNotValidForTheAssertedType, Strings.EdmModel_Validator_Semantic_ExpressionNotValidForTheAssertedType); discoveredErrors = edmError; return false; } case EdmExpressionKind.If: { return ((IEdmIfExpression)expression).TryAssertIfAsType(type, out discoveredErrors); } case EdmExpressionKind.AssertType: { return ((IEdmAssertTypeExpression)expression).Type.TestTypeMatch(type, expression.Location(), out discoveredErrors); } case EdmExpressionKind.IsType: { return EdmCoreModel.Instance.GetBoolean(false).TestTypeMatch(type, expression.Location(), out discoveredErrors); } case EdmExpressionKind.FunctionApplication: { IEdmApplyExpression edmApplyExpression = (IEdmApplyExpression)expression; if (edmApplyExpression.AppliedFunction != null) { IEdmFunctionBase appliedFunction = edmApplyExpression.AppliedFunction as IEdmFunctionBase; if (appliedFunction != null) { return appliedFunction.ReturnType.TestTypeMatch(type, expression.Location(), out discoveredErrors); } } discoveredErrors = Enumerable.Empty<EdmError>(); return true; } case EdmExpressionKind.LabeledExpressionReference: { return ((IEdmLabeledExpressionReferenceExpression)expression).ReferencedLabeledExpression.TryAssertType(type, out discoveredErrors); } case EdmExpressionKind.Labeled: { return ((IEdmLabeledExpression)expression).Expression.TryAssertType(type, out discoveredErrors); } default: { edmError = new EdmError[1]; edmError[0] = new EdmError(expression.Location(), EdmErrorCode.ExpressionNotValidForTheAssertedType, Strings.EdmModel_Validator_Semantic_ExpressionNotValidForTheAssertedType); discoveredErrors = edmError; return false; } } } }
private static bool TestTypeMatch(this IEdmTypeReference expressionType, IEdmTypeReference assertedType, EdmLocation location, out IEnumerable<EdmError> discoveredErrors) { if (expressionType.TestNullabilityMatch(assertedType, location, out discoveredErrors)) { if (expressionType.TypeKind() == EdmTypeKind.None || expressionType.IsBad()) { discoveredErrors = Enumerable.Empty<EdmError>(); return true; } else { if (!expressionType.IsPrimitive() || !assertedType.IsPrimitive()) { if (!expressionType.Definition.IsEquivalentTo(assertedType.Definition)) { EdmError[] edmError = new EdmError[1]; edmError[0] = new EdmError(location, EdmErrorCode.ExpressionNotValidForTheAssertedType, Strings.EdmModel_Validator_Semantic_ExpressionNotValidForTheAssertedType); discoveredErrors = edmError; return false; } } else { if (!expressionType.PrimitiveKind().PromotesTo(assertedType.AsPrimitive().PrimitiveKind())) { EdmError[] edmErrorArray = new EdmError[1]; edmErrorArray[0] = new EdmError(location, EdmErrorCode.ExpressionPrimitiveKindNotValidForAssertedType, Strings.EdmModel_Validator_Semantic_ExpressionPrimitiveKindCannotPromoteToAssertedType(expressionType.FullName(), assertedType.FullName())); discoveredErrors = edmErrorArray; return false; } } discoveredErrors = Enumerable.Empty<EdmError>(); return true; } } else { return false; } }
private TupleInternal<IEdmAssociationEnd, IEdmAssociationEnd> ComputeEnds() { IEdmAssociationEnd csdlSemanticsAssociationEnd; IEdmAssociationEnd edmAssociationEnd; if (this.association.End1 != null) { csdlSemanticsAssociationEnd = new CsdlSemanticsAssociationEnd(this.context, this, this.association.End1); } else { EdmError[] edmError = new EdmError[1]; edmError[0] = new EdmError(base.Location, EdmErrorCode.InvalidAssociation, Strings.CsdlParser_InvalidAssociationIncorrectNumberOfEnds(string.Concat(this.Namespace, ".", this.Name))); IEdmAssociationEnd badAssociationEnd = new BadAssociationEnd(this, "End1", edmError); csdlSemanticsAssociationEnd = badAssociationEnd; } if (this.association.End2 != null) { edmAssociationEnd = new CsdlSemanticsAssociationEnd(this.context, this, this.association.End2); } else { EdmError[] edmErrorArray = new EdmError[1]; edmErrorArray[0] = new EdmError(base.Location, EdmErrorCode.InvalidAssociation, Strings.CsdlParser_InvalidAssociationIncorrectNumberOfEnds(string.Concat(this.Namespace, ".", this.Name))); IEdmAssociationEnd badAssociationEnd1 = new BadAssociationEnd(this, "End2", edmErrorArray); edmAssociationEnd = badAssociationEnd1; } return TupleInternal.Create<IEdmAssociationEnd, IEdmAssociationEnd>(csdlSemanticsAssociationEnd, edmAssociationEnd); }
private IEdmAssociationEnd ComputePrincipal() { IEdmAssociationEnd end1 = this.context.End1; if (end1.Name != this.constraint.Principal.Role) { end1 = this.context.End2; } if (end1.Name != this.constraint.Principal.Role) { EdmError[] edmError = new EdmError[1]; edmError[0] = new EdmError(base.Location, EdmErrorCode.BadNonComputableAssociationEnd, Strings.Bad_UncomputableAssociationEnd(this.constraint.Principal.Role)); end1 = new BadAssociationEnd(this.context, this.constraint.Principal.Role, edmError); } return end1; }
private IEnumerable<IEdmStructuralProperty> ComputeDependentProperties() { List<IEdmStructuralProperty> edmStructuralProperties = new List<IEdmStructuralProperty>(); IEdmEntityType entityType = this.DependentEnd.EntityType; var principalRoleType = this.PrincipalEnd.EntityType; CsdlReferentialConstraintRole principal = this.constraint.Principal; CsdlReferentialConstraintRole dependent = this.constraint.Dependent; if (principalRoleType.Key().Count<IEdmStructuralProperty>() != principal.Properties.Count<CsdlPropertyReference>() || principal.Properties.Count<CsdlPropertyReference>() != dependent.Properties.Count<CsdlPropertyReference>() || this.PrincipalKeyPropertiesNotFoundInPrincipalProperties.Count<string>() != 0 || this.DependentPropertiesNotFoundInDependentType.Count<string>() != 0) { edmStructuralProperties = new List<IEdmStructuralProperty>(); foreach (CsdlPropertyReference property in dependent.Properties) { EdmError[] edmError = new EdmError[1]; edmError[0] = new EdmError(base.Location, EdmErrorCode.TypeMismatchRelationshipConstraint, Strings.CsdlSemantics_ReferentialConstraintMismatch); edmStructuralProperties.Add(new BadProperty(entityType, property.PropertyName, edmError)); } } else { IEnumerator<IEdmStructuralProperty> enumerator = this.PrincipalEnd.EntityType.Key().GetEnumerator(); using (enumerator) { Func<CsdlPropertyReference, bool> func = null; while (enumerator.MoveNext()) { IEdmStructuralProperty current = enumerator.Current; IEnumerable<CsdlPropertyReference> properties = principal.Properties; if (func == null) { func = (CsdlPropertyReference reference) => principalRoleType.FindProperty(reference.PropertyName).Equals(current); } CsdlPropertyReference csdlPropertyReference = properties.Where<CsdlPropertyReference>(func).FirstOrDefault<CsdlPropertyReference>(); int num = principal.IndexOf(csdlPropertyReference); CsdlPropertyReference csdlPropertyReference1 = dependent.Properties.ElementAt<CsdlPropertyReference>(num); IEdmStructuralProperty edmStructuralProperty = entityType.FindProperty(csdlPropertyReference1.PropertyName) as IEdmStructuralProperty; edmStructuralProperties.Add(edmStructuralProperty); } } } return edmStructuralProperties; }
private IEdmEntitySet ComputeEntitySet() { if (this.end != null) { return this.context.Container.FindEntitySet(this.end.EntitySet) ?? new UnresolvedEntitySet(this.end.EntitySet, this.context.Container, this.Location); } else { IEnumerable<EdmError> errors = new EdmError[] { new EdmError( this.Location, EdmErrorCode.NoEntitySetsFoundForType, Strings.EdmModel_Validator_Semantic_NoEntitySetsFoundForType(this.context.Container.FullName() + this.context.Name, this.role.EntityType.FullName(), this.Role.Name)) }; return this.context.Container.EntitySets().Where(set => set.ElementType == this.role.EntityType).FirstOrDefault() ?? new BadEntitySet("UnresolvedEntitySet", this.context.Container, errors); } }
/// <summary> /// Determines if the type of an expression is compatible with the provided type /// </summary> /// <param name="expression">The expression to assert the type of.</param> /// <param name="type">The type to assert the expression as.</param> /// <param name="context">The context paths are to be evaluated in.</param> /// <param name="matchExactly">A value indicating whether the expression must match the asserted type exactly, or simply be compatible.</param> /// <param name="discoveredErrors">Errors produced if the expression does not match the specified type.</param> /// <returns>A value indicating whether the expression is valid for the given type or not.</returns> /// <remarks>If the expression has an associated type, this function will check that it matches the expected type and stop looking further. /// If an expression claims a type, it must be validated that the type is valid for the expression. If the expression does not claim a type /// this method will attempt to check the validity of the expression itself with the asserted type.</remarks> public static bool TryAssertType(this IEdmExpression expression, IEdmTypeReference type, IEdmType context, bool matchExactly, out IEnumerable <EdmError> discoveredErrors) { EdmUtil.CheckArgumentNull(expression, "expression"); // If we don't have a type to assert this passes vacuously. if (type == null || type.TypeKind() == EdmTypeKind.None) { discoveredErrors = Enumerable.Empty <EdmError>(); return(true); } switch (expression.ExpressionKind) { case EdmExpressionKind.IntegerConstant: case EdmExpressionKind.StringConstant: case EdmExpressionKind.BinaryConstant: case EdmExpressionKind.BooleanConstant: case EdmExpressionKind.DateTimeConstant: case EdmExpressionKind.DateTimeOffsetConstant: case EdmExpressionKind.DecimalConstant: case EdmExpressionKind.FloatingConstant: case EdmExpressionKind.GuidConstant: case EdmExpressionKind.TimeConstant: IEdmPrimitiveValue primitiveValue = (IEdmPrimitiveValue)expression; if (primitiveValue.Type != null) { return(TestTypeReferenceMatch(primitiveValue.Type, type, expression.Location(), matchExactly, out discoveredErrors)); } return(TryAssertPrimitiveAsType(primitiveValue, type, out discoveredErrors)); case EdmExpressionKind.Null: return(TryAssertNullAsType((IEdmNullExpression)expression, type, out discoveredErrors)); case EdmExpressionKind.Path: return(TryAssertPathAsType((IEdmPathExpression)expression, type, context, matchExactly, out discoveredErrors)); case EdmExpressionKind.FunctionApplication: IEdmApplyExpression applyExpression = (IEdmApplyExpression)expression; if (applyExpression.AppliedFunction != null) { IEdmFunctionBase function = applyExpression.AppliedFunction as IEdmFunctionBase; if (function != null) { return(TestTypeReferenceMatch(function.ReturnType, type, expression.Location(), matchExactly, out discoveredErrors)); } } // If we don't have the applied function we just assume that it will work. discoveredErrors = Enumerable.Empty <EdmError>(); return(true); case EdmExpressionKind.If: return(TryAssertIfAsType((IEdmIfExpression)expression, type, context, matchExactly, out discoveredErrors)); case EdmExpressionKind.IsType: return(TestTypeReferenceMatch(EdmCoreModel.Instance.GetBoolean(false), type, expression.Location(), matchExactly, out discoveredErrors)); case EdmExpressionKind.Record: IEdmRecordExpression recordExpression = (IEdmRecordExpression)expression; if (recordExpression.DeclaredType != null) { return(TestTypeReferenceMatch(recordExpression.DeclaredType, type, expression.Location(), matchExactly, out discoveredErrors)); } return(TryAssertRecordAsType(recordExpression, type, context, matchExactly, out discoveredErrors)); case EdmExpressionKind.Collection: IEdmCollectionExpression collectionExpression = (IEdmCollectionExpression)expression; if (collectionExpression.DeclaredType != null) { return(TestTypeReferenceMatch(collectionExpression.DeclaredType, type, expression.Location(), matchExactly, out discoveredErrors)); } return(TryAssertCollectionAsType(collectionExpression, type, context, matchExactly, out discoveredErrors)); case EdmExpressionKind.Labeled: return(TryAssertType(((IEdmLabeledExpression)expression).Expression, type, context, matchExactly, out discoveredErrors)); case EdmExpressionKind.AssertType: return(TestTypeReferenceMatch(((IEdmAssertTypeExpression)expression).Type, type, expression.Location(), matchExactly, out discoveredErrors)); case EdmExpressionKind.LabeledExpressionReference: return(TryAssertType(((IEdmLabeledExpressionReferenceExpression)expression).ReferencedLabeledExpression, type, out discoveredErrors)); default: discoveredErrors = new EdmError[] { new EdmError(expression.Location(), EdmErrorCode.ExpressionNotValidForTheAssertedType, Edm.Strings.EdmModel_Validator_Semantic_ExpressionNotValidForTheAssertedType) }; return(false); } }
internal static bool SignificantToSerialization(EdmError error) { if (!ValidationHelper.IsInterfaceCritical(error)) { EdmErrorCode errorCode = error.ErrorCode; if (errorCode > EdmErrorCode.RowTypeMustNotHaveBaseType) { if (errorCode > EdmErrorCode.EnumMemberTypeMustMatchEnumUnderlyingType) { if (errorCode != EdmErrorCode.ReferencedTypeMustHaveValidName) { if (errorCode == EdmErrorCode.InvalidFunctionImportParameterMode || errorCode == EdmErrorCode.TypeMustNotHaveKindOfNone || errorCode == EdmErrorCode.PrimitiveTypeMustNotHaveKindOfNone || errorCode == EdmErrorCode.PropertyMustNotHaveKindOfNone || errorCode == EdmErrorCode.TermMustNotHaveKindOfNone || errorCode == EdmErrorCode.SchemaElementMustNotHaveKindOfNone || errorCode == EdmErrorCode.EntityContainerElementMustNotHaveKindOfNone || errorCode == EdmErrorCode.BinaryValueCannotHaveEmptyValue) { return true; } if (errorCode != EdmErrorCode.EnumMustHaveIntegerUnderlyingType) { return false; } } } else { if (errorCode == EdmErrorCode.OnlyInputParametersAllowedInFunctions || errorCode == EdmErrorCode.FunctionImportParameterIncorrectType) { return true; } else if (errorCode == EdmErrorCode.ComplexTypeMustHaveProperties) { return false; } if (errorCode == EdmErrorCode.EnumMemberTypeMustMatchEnumUnderlyingType) { return true; } return false; } } else { if (errorCode > EdmErrorCode.NameTooLong) { if (errorCode != EdmErrorCode.FunctionImportEntitySetExpressionIsInvalid) { if (errorCode == EdmErrorCode.SystemNamespaceEncountered || errorCode == EdmErrorCode.InvalidNamespaceName) { return true; } else if ((int)errorCode == 162) { return false; } if (errorCode == EdmErrorCode.RowTypeMustNotHaveBaseType) { return true; } return false; } } else { if (errorCode == EdmErrorCode.InvalidName || errorCode == EdmErrorCode.NameTooLong) { return true; } return false; } } return true; } else { return true; } }
private static IEnumerable<EdmError> ConversionError(EdmLocation location, string typeName, string typeKindName) { EdmError[] edmErrorArray = new EdmError[1]; EdmError[] edmError = edmErrorArray; int num = 0; EdmLocation edmLocation = location; int num1 = 230; string str = typeName; object obj = str; if (str == null) { obj = "UnnamedType"; } edmError[num] = new EdmError(edmLocation, (EdmErrorCode)num1, Strings.TypeSemantics_CouldNotConvertTypeReference(obj, typeKindName)); return edmErrorArray; }
/// <summary> /// Register an error with the validation context. /// </summary> /// <param name="error">Error to register.</param> public void AddError(EdmError error) { this.errors.Add(error); }
private IEdmEntitySet ComputeEntitySet() { Func<IEdmEntitySet, bool> func = null; if (this.end == null) { EdmError[] edmError = new EdmError[1]; edmError[0] = new EdmError(base.Location, EdmErrorCode.NoEntitySetsFoundForType, Strings.EdmModel_Validator_Semantic_NoEntitySetsFoundForType(string.Concat(this.context.Container.FullName(), this.context.Name), this.role.EntityType.FullName(), this.Role.Name)); IEnumerable<EdmError> edmErrors = edmError; IEnumerable<IEdmEntitySet> edmEntitySets = this.context.Container.EntitySets(); if (func == null) { func = (IEdmEntitySet set) => set.ElementType == this.role.EntityType; } IEdmEntitySet edmEntitySet = edmEntitySets.Where<IEdmEntitySet>(func).FirstOrDefault<IEdmEntitySet>(); IEdmEntitySet badEntitySet = edmEntitySet; if (edmEntitySet == null) { badEntitySet = new BadEntitySet("UnresolvedEntitySet", this.context.Container, edmErrors); } return badEntitySet; } else { IEdmEntitySet edmEntitySet1 = this.context.Container.FindEntitySet(this.end.EntitySet); IEdmEntitySet unresolvedEntitySet = edmEntitySet1; if (edmEntitySet1 == null) { unresolvedEntitySet = new UnresolvedEntitySet(this.end.EntitySet, this.context.Container, base.Location); } return unresolvedEntitySet; } }
private IEdmAssociationEnd ComputeFrom() { IEdmAssociation association = this.Association; string fromRole = this.navigationProperty.FromRole; if (association.End1.Name != fromRole) { if (association.End2.Name != fromRole) { EdmError[] edmError = new EdmError[1]; edmError[0] = new EdmError(base.Location, EdmErrorCode.BadNavigationProperty, Strings.EdmModel_Validator_Semantic_BadNavigationPropertyUndefinedRole(this.Name, fromRole, association.Name)); return new CsdlSemanticsNavigationProperty.BadCsdlSemanticsNavigationPropertyToEnd(this.Association, fromRole, edmError); } else { return association.End2; } } else { return association.End1; } }
internal static bool SignificantToSerialization(EdmError error) { if (ValidationHelper.IsInterfaceCritical(error)) { return true; } switch (error.ErrorCode) { case EdmErrorCode.InvalidName: case EdmErrorCode.NameTooLong: case EdmErrorCode.InvalidNamespaceName: case EdmErrorCode.SystemNamespaceEncountered: case EdmErrorCode.RowTypeMustNotHaveBaseType: case EdmErrorCode.ReferencedTypeMustHaveValidName: case EdmErrorCode.FunctionImportEntitySetExpressionIsInvalid: case EdmErrorCode.FunctionImportParameterIncorrectType: case EdmErrorCode.OnlyInputParametersAllowedInFunctions: case EdmErrorCode.InvalidFunctionImportParameterMode: case EdmErrorCode.TypeMustNotHaveKindOfNone: case EdmErrorCode.PrimitiveTypeMustNotHaveKindOfNone: case EdmErrorCode.PropertyMustNotHaveKindOfNone: case EdmErrorCode.TermMustNotHaveKindOfNone: case EdmErrorCode.SchemaElementMustNotHaveKindOfNone: case EdmErrorCode.EntityContainerElementMustNotHaveKindOfNone: case EdmErrorCode.BinaryValueCannotHaveEmptyValue: case EdmErrorCode.EnumMustHaveIntegerUnderlyingType: case EdmErrorCode.EnumMemberTypeMustMatchEnumUnderlyingType: return true; } return false; }
private IEdmTypeReference ComputeType() { EdmMultiplicity multiplicity = this.partner.From.Multiplicity; switch (multiplicity) { case EdmMultiplicity.ZeroOrOne: { return new EdmEntityTypeReference(this.partner.DeclaringEntityType(), true); } case EdmMultiplicity.One: { return new EdmEntityTypeReference(this.partner.DeclaringEntityType(), false); } case EdmMultiplicity.Many: { return new EdmCollectionTypeReference(new EdmCollectionType(new EdmEntityTypeReference(this.partner.DeclaringEntityType(), false)), false); } } EdmError[] edmError = new EdmError[1]; edmError[0] = new EdmError(this.partner.To.Location(), EdmErrorCode.NavigationPropertyTypeInvalidBecauseOfBadAssociation, Strings.EdmModel_Validator_Semantic_BadNavigationPropertyCouldNotDetermineType(this.partner.DeclaringEntityType().Name)); return new BadEntityTypeReference(this.partner.DeclaringEntityType().FullName(), false, edmError); }
public static bool TryParse(IEnumerable<XmlReader> csdlReaders, out CsdlModel entityModel, out IEnumerable<EdmError> errors) { bool flag; EdmUtil.CheckArgumentNull<IEnumerable<XmlReader>>(csdlReaders, "csdlReaders"); CsdlParser csdlParser = new CsdlParser(); int num = 0; IEnumerator<XmlReader> enumerator = csdlReaders.GetEnumerator(); using (enumerator) { while (enumerator.MoveNext()) { XmlReader current = enumerator.Current; if (current == null) { entityModel = null; EdmError[] edmError = new EdmError[1]; edmError[0] = new EdmError(null, EdmErrorCode.NullXmlReader, Strings.CsdlParser_NullXmlReader); errors = edmError; flag = false; return flag; } else { try { csdlParser.AddReader(current); } catch (XmlException xmlException1) { XmlException xmlException = xmlException1; entityModel = null; EdmError[] edmErrorArray = new EdmError[1]; edmErrorArray[0] = new EdmError(new CsdlLocation(xmlException.LineNumber, xmlException.LinePosition), EdmErrorCode.XmlError, xmlException.Message); errors = edmErrorArray; flag = false; return flag; } num++; } } goto Label0; } return flag; Label0: if (num != 0) { bool result = csdlParser.GetResult(out entityModel, out errors); if (!result) { entityModel = null; } return result; } else { entityModel = null; EdmError[] edmError1 = new EdmError[1]; edmError1[0] = new EdmError(null, EdmErrorCode.NoReadersProvided, Strings.CsdlParser_NoReadersProvided); errors = edmError1; return false; } }
internal static bool IsInterfaceCritical(EdmError error) { if (error.ErrorCode < EdmErrorCode.InterfaceCriticalPropertyValueMustNotBeNull) { return false; } else { return error.ErrorCode <= EdmErrorCode.InterfaceCriticalCycleInTypeHierarchy; } }
internal static bool ValidateValueCanBeWrittenAsXmlElementAnnotation(IEdmValue value, string annotationNamespace, string annotationName, out EdmError error) { bool flag; IEdmStringValue edmStringValue = value as IEdmStringValue; if (edmStringValue != null) { string str = edmStringValue.Value; XmlReader xmlReader = XmlReader.Create(new StringReader(str)); try { if (xmlReader.NodeType != XmlNodeType.Element) { while (xmlReader.Read() && xmlReader.NodeType != XmlNodeType.Element) { } } if (!xmlReader.EOF) { string namespaceURI = xmlReader.NamespaceURI; string localName = xmlReader.LocalName; if (EdmUtil.IsNullOrWhiteSpaceInternal(namespaceURI) || EdmUtil.IsNullOrWhiteSpaceInternal(localName)) { error = new EdmError(value.Location(), EdmErrorCode.InvalidElementAnnotation, Strings.EdmModel_Validator_Semantic_InvalidElementAnnotationNullNamespaceOrName); flag = false; } else { if ((annotationNamespace == null || namespaceURI == annotationNamespace) && (annotationName == null || localName == annotationName)) { while (xmlReader.Read()) { } error = null; flag = true; } else { error = new EdmError(value.Location(), EdmErrorCode.InvalidElementAnnotation, Strings.EdmModel_Validator_Semantic_InvalidElementAnnotationMismatchedTerm); flag = false; } } } else { error = new EdmError(value.Location(), EdmErrorCode.InvalidElementAnnotation, Strings.EdmModel_Validator_Semantic_InvalidElementAnnotationValueInvalidXml); flag = false; } } catch (Exception exception) { error = new EdmError(value.Location(), EdmErrorCode.InvalidElementAnnotation, Strings.EdmModel_Validator_Semantic_InvalidElementAnnotationValueInvalidXml); flag = false; } return flag; } else { error = new EdmError(value.Location(), EdmErrorCode.InvalidElementAnnotation, Strings.EdmModel_Validator_Semantic_InvalidElementAnnotationNotIEdmStringValue); return false; } }
/// <summary> /// Register an error with the validation context. /// </summary> /// <param name="error">Error to register.</param> public void AddError(EdmError error) { this.errors.Add(error); }
private static bool TryAssertStringConstantAsType(IEdmStringConstantExpression expression, IEdmTypeReference type, out IEnumerable<EdmError> discoveredErrors) { if (type.IsString()) { IEdmStringTypeReference edmStringTypeReference = type.AsString(); int? maxLength = edmStringTypeReference.MaxLength; if (maxLength.HasValue) { int? nullable = edmStringTypeReference.MaxLength; if (expression.Value.Length > nullable.Value) { EdmError[] edmError = new EdmError[1]; int? maxLength1 = edmStringTypeReference.MaxLength; edmError[0] = new EdmError(expression.Location(), EdmErrorCode.StringConstantLengthOutOfRange, Strings.EdmModel_Validator_Semantic_StringConstantLengthOutOfRange(expression.Value.Length, maxLength1.Value)); discoveredErrors = edmError; return false; } } discoveredErrors = Enumerable.Empty<EdmError>(); return true; } else { EdmError[] edmErrorArray = new EdmError[1]; edmErrorArray[0] = new EdmError(expression.Location(), EdmErrorCode.ExpressionPrimitiveKindNotValidForAssertedType, Strings.EdmModel_Validator_Semantic_ExpressionPrimitiveKindNotValidForAssertedType); discoveredErrors = edmErrorArray; return false; } }