internal override void WriteTypeDefinitionAttributes(IEdmTypeDefinitionReference reference)
{
IEdmTypeReference actualTypeReference = reference.AsActualTypeReference();
if (actualTypeReference.IsBinary())
{
this.WriteBinaryTypeAttributes(actualTypeReference.AsBinary());
}
else if (actualTypeReference.IsString())
{
this.WriteStringTypeAttributes(actualTypeReference.AsString());
}
else if (actualTypeReference.IsTemporal())
{
this.WriteTemporalTypeAttributes(actualTypeReference.AsTemporal());
}
else if (actualTypeReference.IsDecimal())
{
this.WriteDecimalTypeAttributes(actualTypeReference.AsDecimal());
}
else if (actualTypeReference.IsSpatial())
{
this.WriteSpatialTypeAttributes(actualTypeReference.AsSpatial());
}
}
private static bool TryAssertBinaryConstantAsType(IEdmBinaryConstantExpression expression, IEdmTypeReference type, out IEnumerable <EdmError> discoveredErrors)
{
if (type.IsBinary())
{
IEdmBinaryTypeReference edmBinaryTypeReference = type.AsBinary();
int?maxLength = edmBinaryTypeReference.MaxLength;
if (maxLength.HasValue)
{
int?nullable = edmBinaryTypeReference.MaxLength;
if ((int)expression.Value.Length > nullable.Value)
{
EdmError[] edmError = new EdmError[1];
int? maxLength1 = edmBinaryTypeReference.MaxLength;
edmError[0] = new EdmError(expression.Location(), EdmErrorCode.BinaryConstantLengthOutOfRange, Strings.EdmModel_Validator_Semantic_BinaryConstantLengthOutOfRange((int)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);
}
}
private static IEdmTypeReference CreatePrimitveStockTypeReference(IEdmTypeReference edmTypeReference, EdmModel stockModel)
{
IEdmTypeReference stockTypeReference = null;
switch (edmTypeReference.PrimitiveKind())
{
case EdmPrimitiveTypeKind.Binary:
var binaryTypeReference = edmTypeReference.AsBinary();
stockTypeReference = EdmCoreModel.Instance.GetBinary(binaryTypeReference.IsUnbounded, binaryTypeReference.MaxLength, binaryTypeReference.IsNullable);
break;
case EdmPrimitiveTypeKind.String:
var stringTypeReference = edmTypeReference.AsString();
stockTypeReference = EdmCoreModel.Instance.GetString(stringTypeReference.IsUnbounded, stringTypeReference.MaxLength, stringTypeReference.IsUnicode ?? true, stringTypeReference.IsNullable);
break;
case EdmPrimitiveTypeKind.DateTimeOffset:
case EdmPrimitiveTypeKind.Duration:
var temporalTypeReference = edmTypeReference.AsTemporal();
stockTypeReference = EdmCoreModel.Instance.GetTemporal(temporalTypeReference.PrimitiveKind(), temporalTypeReference.Precision ?? 0, temporalTypeReference.IsNullable);
break;
case EdmPrimitiveTypeKind.Decimal:
var decimalTypeReference = edmTypeReference.AsDecimal();
stockTypeReference = EdmCoreModel.Instance.GetDecimal(decimalTypeReference.Precision, decimalTypeReference.Scale, decimalTypeReference.IsNullable);
break;
default:
stockTypeReference = EdmCoreModel.Instance.GetPrimitive(edmTypeReference.PrimitiveKind(), edmTypeReference.IsNullable);
break;
}
return(stockTypeReference);
}
private static bool TryAssertBinaryConstantAsType(IEdmBinaryConstantExpression expression, IEdmTypeReference type, out IEnumerable <EdmError> discoveredErrors)
{
if (!type.IsBinary())
{
discoveredErrors = new EdmError[] { new EdmError(expression.Location(), EdmErrorCode.ExpressionPrimitiveKindNotValidForAssertedType, Edm.Strings.EdmModel_Validator_Semantic_ExpressionPrimitiveKindNotValidForAssertedType) };
return(false);
}
IEdmBinaryTypeReference binaryType = type.AsBinary();
if (binaryType.MaxLength.HasValue && expression.Value.Length > binaryType.MaxLength.Value)
{
discoveredErrors = new EdmError[] { new EdmError(expression.Location(), EdmErrorCode.BinaryConstantLengthOutOfRange, Edm.Strings.EdmModel_Validator_Semantic_BinaryConstantLengthOutOfRange(expression.Value.Length, binaryType.MaxLength.Value)) };
return(false);
}
discoveredErrors = Enumerable.Empty <EdmError>();
return(true);
}
// The As*** functions never return null -- if the supplied type does not have the appropriate shape, an encoding of a bad type is returned.
#region AsPrimitive, AsCollection, AsStructured, ...
/// <summary>
/// If this reference is of a primitive type, this will return a valid primitive type reference to the type definition. Otherwise, it will return a bad primitive type reference.
/// </summary>
/// <param name="type">Reference to the calling object.</param>
/// <returns>A valid primitive type reference if the definition of the reference is of a primitive type. Otherwise a bad primitive type reference.</returns>
public static IEdmPrimitiveTypeReference AsPrimitive(this IEdmTypeReference type)
{
EdmUtil.CheckArgumentNull(type, "type");
IEdmPrimitiveTypeReference reference = type as IEdmPrimitiveTypeReference;
if (reference != null)
{
return(reference);
}
IEdmType typeDefinition = type.Definition;
if (typeDefinition.TypeKind == EdmTypeKind.Primitive)
{
var primitiveDefinition = typeDefinition as IEdmPrimitiveType;
if (primitiveDefinition != null)
{
switch (primitiveDefinition.PrimitiveKind)
{
case EdmPrimitiveTypeKind.Boolean:
case EdmPrimitiveTypeKind.Byte:
case EdmPrimitiveTypeKind.Double:
case EdmPrimitiveTypeKind.Guid:
case EdmPrimitiveTypeKind.Int16:
case EdmPrimitiveTypeKind.Int32:
case EdmPrimitiveTypeKind.Int64:
case EdmPrimitiveTypeKind.SByte:
case EdmPrimitiveTypeKind.Single:
case EdmPrimitiveTypeKind.Stream:
return(new EdmPrimitiveTypeReference(primitiveDefinition, type.IsNullable));
case EdmPrimitiveTypeKind.Binary:
return(type.AsBinary());
case EdmPrimitiveTypeKind.Decimal:
return(type.AsDecimal());
case EdmPrimitiveTypeKind.String:
return(type.AsString());
case EdmPrimitiveTypeKind.Duration:
case EdmPrimitiveTypeKind.DateTimeOffset:
return(type.AsTemporal());
case EdmPrimitiveTypeKind.Geography:
case EdmPrimitiveTypeKind.GeographyPoint:
case EdmPrimitiveTypeKind.GeographyLineString:
case EdmPrimitiveTypeKind.GeographyPolygon:
case EdmPrimitiveTypeKind.GeographyCollection:
case EdmPrimitiveTypeKind.GeographyMultiPolygon:
case EdmPrimitiveTypeKind.GeographyMultiLineString:
case EdmPrimitiveTypeKind.GeographyMultiPoint:
case EdmPrimitiveTypeKind.Geometry:
case EdmPrimitiveTypeKind.GeometryPoint:
case EdmPrimitiveTypeKind.GeometryLineString:
case EdmPrimitiveTypeKind.GeometryPolygon:
case EdmPrimitiveTypeKind.GeometryCollection:
case EdmPrimitiveTypeKind.GeometryMultiPolygon:
case EdmPrimitiveTypeKind.GeometryMultiLineString:
case EdmPrimitiveTypeKind.GeometryMultiPoint:
return(type.AsSpatial());
case EdmPrimitiveTypeKind.None:
break;
}
}
}
string typeFullName = type.FullName();
List <EdmError> errors = new List <EdmError>(type.Errors());
if (errors.Count == 0)
{
errors.AddRange(ConversionError(type.Location(), typeFullName, EdmConstants.Type_Primitive));
}
return(new BadPrimitiveTypeReference(typeFullName, type.IsNullable, errors));
}
private static bool MatchesType(IEdmTypeReference targetType, IEdmValue operand, bool testPropertyTypes)
{
IEdmTypeReference operandType = operand.Type;
EdmValueKind operandKind = operand.ValueKind;
if (operandType != null && operandKind != EdmValueKind.Null && operandType.Definition.IsOrInheritsFrom(targetType.Definition))
{
return(true);
}
switch (operandKind)
{
case EdmValueKind.Binary:
if (targetType.IsBinary())
{
IEdmBinaryTypeReference targetBinary = targetType.AsBinary();
return(targetBinary.IsUnbounded || !targetBinary.MaxLength.HasValue || targetBinary.MaxLength.Value >= ((IEdmBinaryValue)operand).Value.Length);
}
break;
case EdmValueKind.Boolean:
return(targetType.IsBoolean());
case EdmValueKind.Date:
return(targetType.IsDate());
case EdmValueKind.DateTimeOffset:
return(targetType.IsDateTimeOffset());
case EdmValueKind.Decimal:
return(targetType.IsDecimal());
case EdmValueKind.Guid:
return(targetType.IsGuid());
case EdmValueKind.Null:
return(targetType.IsNullable);
case EdmValueKind.Duration:
return(targetType.IsDuration());
case EdmValueKind.String:
if (targetType.IsString())
{
IEdmStringTypeReference targetString = targetType.AsString();
return(targetString.IsUnbounded || !targetString.MaxLength.HasValue || targetString.MaxLength.Value >= ((IEdmStringValue)operand).Value.Length);
}
break;
case EdmValueKind.TimeOfDay:
return(targetType.IsTimeOfDay());
case EdmValueKind.Floating:
return(targetType.IsDouble() || (targetType.IsSingle() && FitsInSingle(((IEdmFloatingValue)operand).Value)));
case EdmValueKind.Integer:
if (targetType.TypeKind() == EdmTypeKind.Primitive)
{
switch (targetType.AsPrimitive().PrimitiveKind())
{
case EdmPrimitiveTypeKind.Int16:
return(InRange(((IEdmIntegerValue)operand).Value, Int16.MinValue, Int16.MaxValue));
case EdmPrimitiveTypeKind.Int32:
return(InRange(((IEdmIntegerValue)operand).Value, Int32.MinValue, Int32.MaxValue));
case EdmPrimitiveTypeKind.SByte:
return(InRange(((IEdmIntegerValue)operand).Value, SByte.MinValue, SByte.MaxValue));
case EdmPrimitiveTypeKind.Byte:
return(InRange(((IEdmIntegerValue)operand).Value, Byte.MinValue, Byte.MaxValue));
case EdmPrimitiveTypeKind.Int64:
case EdmPrimitiveTypeKind.Single:
case EdmPrimitiveTypeKind.Double:
return(true);
}
}
break;
case EdmValueKind.Collection:
if (targetType.IsCollection())
{
IEdmTypeReference targetElementType = targetType.AsCollection().ElementType();
// This enumerates the entire collection, which is unfortunate.
foreach (IEdmDelayedValue elementValue in ((IEdmCollectionValue)operand).Elements)
{
if (!MatchesType(targetElementType, elementValue.Value))
{
return(false);
}
}
return(true);
}
break;
case EdmValueKind.Enum:
return(((IEdmEnumValue)operand).Type.Definition.IsEquivalentTo(targetType.Definition));
case EdmValueKind.Structured:
if (targetType.IsStructured())
{
return(AssertOrMatchStructuredType(targetType.AsStructured(), (IEdmStructuredValue)operand, testPropertyTypes, null));
}
break;
}
return(false);
}
private static bool TryCastBinaryConstantAsType(IEdmBinaryConstantExpression expression, IEdmTypeReference type, out IEnumerable<EdmError> discoveredErrors)
{
if (!type.IsBinary())
{
discoveredErrors = new EdmError[] { new EdmError(expression.Location(), EdmErrorCode.ExpressionPrimitiveKindNotValidForAssertedType, Edm.Strings.EdmModel_Validator_Semantic_ExpressionPrimitiveKindNotValidForAssertedType) };
return false;
}
IEdmBinaryTypeReference binaryType = type.AsBinary();
if (binaryType.MaxLength.HasValue && expression.Value.Length > binaryType.MaxLength.Value)
{
discoveredErrors = new EdmError[] { new EdmError(expression.Location(), EdmErrorCode.BinaryConstantLengthOutOfRange, Edm.Strings.EdmModel_Validator_Semantic_BinaryConstantLengthOutOfRange(expression.Value.Length, binaryType.MaxLength.Value)) };
return false;
}
discoveredErrors = Enumerable.Empty<EdmError>();
return true;
}
public static IEdmPrimitiveTypeReference AsPrimitive(this IEdmTypeReference type)
{
string str;
List <EdmError> edmErrors;
EdmUtil.CheckArgumentNull <IEdmTypeReference>(type, "type");
IEdmPrimitiveTypeReference edmPrimitiveTypeReference = type as IEdmPrimitiveTypeReference;
if (edmPrimitiveTypeReference == null)
{
IEdmType definition = type.Definition;
if (definition.TypeKind == EdmTypeKind.Primitive)
{
IEdmPrimitiveType edmPrimitiveType = definition as IEdmPrimitiveType;
if (edmPrimitiveType != null)
{
EdmPrimitiveTypeKind primitiveKind = edmPrimitiveType.PrimitiveKind;
if (primitiveKind == EdmPrimitiveTypeKind.None)
{
str = type.FullName();
edmErrors = new List <EdmError>(type.Errors());
if (edmErrors.Count == 0)
{
edmErrors.AddRange(EdmTypeSemantics.ConversionError(type.Location(), str, "Primitive"));
}
return(new BadPrimitiveTypeReference(str, type.IsNullable, edmErrors));
}
else if (primitiveKind == EdmPrimitiveTypeKind.Binary)
{
return(type.AsBinary());
}
else if (primitiveKind == EdmPrimitiveTypeKind.Boolean || primitiveKind == EdmPrimitiveTypeKind.Byte || primitiveKind == EdmPrimitiveTypeKind.Double || primitiveKind == EdmPrimitiveTypeKind.Guid || primitiveKind == EdmPrimitiveTypeKind.Int16 || primitiveKind == EdmPrimitiveTypeKind.Int32 || primitiveKind == EdmPrimitiveTypeKind.Int64 || primitiveKind == EdmPrimitiveTypeKind.SByte || primitiveKind == EdmPrimitiveTypeKind.Single || primitiveKind == EdmPrimitiveTypeKind.Stream)
{
return(new EdmPrimitiveTypeReference(edmPrimitiveType, type.IsNullable));
}
else if (primitiveKind == EdmPrimitiveTypeKind.DateTime || primitiveKind == EdmPrimitiveTypeKind.DateTimeOffset || primitiveKind == EdmPrimitiveTypeKind.Time)
{
return(type.AsTemporal());
}
else if (primitiveKind == EdmPrimitiveTypeKind.Decimal)
{
return(type.AsDecimal());
}
else if (primitiveKind == EdmPrimitiveTypeKind.String)
{
return(type.AsString());
}
else if (primitiveKind == EdmPrimitiveTypeKind.Geography || primitiveKind == EdmPrimitiveTypeKind.GeographyPoint || primitiveKind == EdmPrimitiveTypeKind.GeographyLineString || primitiveKind == EdmPrimitiveTypeKind.GeographyPolygon || primitiveKind == EdmPrimitiveTypeKind.GeographyCollection || primitiveKind == EdmPrimitiveTypeKind.GeographyMultiPolygon || primitiveKind == EdmPrimitiveTypeKind.GeographyMultiLineString || primitiveKind == EdmPrimitiveTypeKind.GeographyMultiPoint || primitiveKind == EdmPrimitiveTypeKind.Geometry || primitiveKind == EdmPrimitiveTypeKind.GeometryPoint || primitiveKind == EdmPrimitiveTypeKind.GeometryLineString || primitiveKind == EdmPrimitiveTypeKind.GeometryPolygon || primitiveKind == EdmPrimitiveTypeKind.GeometryCollection || primitiveKind == EdmPrimitiveTypeKind.GeometryMultiPolygon || primitiveKind == EdmPrimitiveTypeKind.GeometryMultiLineString || primitiveKind == EdmPrimitiveTypeKind.GeometryMultiPoint)
{
return(type.AsSpatial());
}
}
}
str = type.FullName();
edmErrors = new List <EdmError>(type.Errors());
if (edmErrors.Count == 0)
{
edmErrors.AddRange(EdmTypeSemantics.ConversionError(type.Location(), str, "Primitive"));
}
return(new BadPrimitiveTypeReference(str, type.IsNullable, edmErrors));
}
else
{
return(edmPrimitiveTypeReference);
}
}
private static IEdmTypeReference CreatePrimitveStockTypeReference(IEdmTypeReference edmTypeReference, EdmModel stockModel)
{
IEdmTypeReference stockTypeReference = null;
switch (edmTypeReference.PrimitiveKind())
{
case EdmPrimitiveTypeKind.Binary:
var binaryTypeReference = edmTypeReference.AsBinary();
stockTypeReference = EdmCoreModel.Instance.GetBinary(binaryTypeReference.IsUnbounded, binaryTypeReference.MaxLength, binaryTypeReference.IsNullable);
break;
case EdmPrimitiveTypeKind.String:
var stringTypeReference = edmTypeReference.AsString();
stockTypeReference = EdmCoreModel.Instance.GetString(stringTypeReference.IsUnbounded, stringTypeReference.MaxLength, stringTypeReference.IsUnicode ?? true, stringTypeReference.IsNullable);
break;
case EdmPrimitiveTypeKind.DateTimeOffset:
case EdmPrimitiveTypeKind.Duration:
var temporalTypeReference = edmTypeReference.AsTemporal();
stockTypeReference = EdmCoreModel.Instance.GetTemporal(temporalTypeReference.PrimitiveKind(), temporalTypeReference.Precision ?? 0, temporalTypeReference.IsNullable);
break;
case EdmPrimitiveTypeKind.Decimal:
var decimalTypeReference = edmTypeReference.AsDecimal();
stockTypeReference = EdmCoreModel.Instance.GetDecimal(decimalTypeReference.Precision, decimalTypeReference.Scale, decimalTypeReference.IsNullable);
break;
default:
stockTypeReference = EdmCoreModel.Instance.GetPrimitive(edmTypeReference.PrimitiveKind(), edmTypeReference.IsNullable);
break;
}
return stockTypeReference;
}
private static bool MatchesType(IEdmTypeReference targetType, IEdmValue operand, bool testPropertyTypes)
{
bool flag;
IEdmTypeReference type = operand.Type;
EdmValueKind valueKind = operand.ValueKind;
if (type == null || valueKind == EdmValueKind.Null || !type.Definition.IsOrInheritsFrom(targetType.Definition))
{
EdmValueKind edmValueKind = valueKind;
switch (edmValueKind)
{
case EdmValueKind.Binary:
{
if (!targetType.IsBinary())
{
break;
}
IEdmBinaryTypeReference edmBinaryTypeReference = targetType.AsBinary();
if (!edmBinaryTypeReference.IsUnbounded)
{
int?maxLength = edmBinaryTypeReference.MaxLength;
if (maxLength.HasValue)
{
int?nullable = edmBinaryTypeReference.MaxLength;
return(nullable.Value >= (int)((IEdmBinaryValue)operand).Value.Length);
}
}
return(true);
}
case EdmValueKind.Boolean:
{
return(targetType.IsBoolean());
}
case EdmValueKind.Collection:
{
if (!targetType.IsCollection())
{
break;
}
IEdmTypeReference edmTypeReference = targetType.AsCollection().ElementType();
IEnumerator <IEdmDelayedValue> enumerator = ((IEdmCollectionValue)operand).Elements.GetEnumerator();
using (enumerator)
{
while (enumerator.MoveNext())
{
IEdmDelayedValue current = enumerator.Current;
if (EdmExpressionEvaluator.MatchesType(edmTypeReference, current.Value))
{
continue;
}
flag = false;
return(flag);
}
return(true);
}
return(flag);
}
case EdmValueKind.DateTimeOffset:
{
return(targetType.IsDateTimeOffset());
}
case EdmValueKind.DateTime:
{
return(targetType.IsDateTime());
}
case EdmValueKind.Decimal:
{
return(targetType.IsDecimal());
}
case EdmValueKind.Enum:
{
return(((IEdmEnumValue)operand).Type.Definition.IsEquivalentTo(targetType.Definition));
}
case EdmValueKind.Floating:
{
if (targetType.IsDouble())
{
return(true);
}
else
{
if (!targetType.IsSingle())
{
return(false);
}
else
{
return(EdmExpressionEvaluator.FitsInSingle(((IEdmFloatingValue)operand).Value));
}
}
}
case EdmValueKind.Guid:
{
return(targetType.IsGuid());
}
case EdmValueKind.Integer:
{
if (targetType.TypeKind() != EdmTypeKind.Primitive)
{
break;
}
EdmPrimitiveTypeKind edmPrimitiveTypeKind = targetType.AsPrimitive().PrimitiveKind();
if (edmPrimitiveTypeKind == EdmPrimitiveTypeKind.Byte)
{
return(EdmExpressionEvaluator.InRange(((IEdmIntegerValue)operand).Value, (long)0, (long)0xff));
}
else if (edmPrimitiveTypeKind == EdmPrimitiveTypeKind.DateTime || edmPrimitiveTypeKind == EdmPrimitiveTypeKind.DateTimeOffset || edmPrimitiveTypeKind == EdmPrimitiveTypeKind.Decimal || edmPrimitiveTypeKind == EdmPrimitiveTypeKind.Guid)
{
break;
}
else if (edmPrimitiveTypeKind == EdmPrimitiveTypeKind.Double || edmPrimitiveTypeKind == EdmPrimitiveTypeKind.Int64 || edmPrimitiveTypeKind == EdmPrimitiveTypeKind.Single)
{
return(true);
}
else if (edmPrimitiveTypeKind == EdmPrimitiveTypeKind.Int16)
{
return(EdmExpressionEvaluator.InRange(((IEdmIntegerValue)operand).Value, (long)-32768, (long)0x7fff));
}
else if (edmPrimitiveTypeKind == EdmPrimitiveTypeKind.Int32)
{
return(EdmExpressionEvaluator.InRange(((IEdmIntegerValue)operand).Value, (long)-2147483648, (long)0x7fffffff));
}
else if (edmPrimitiveTypeKind == EdmPrimitiveTypeKind.SByte)
{
return(EdmExpressionEvaluator.InRange(((IEdmIntegerValue)operand).Value, (long)-128, (long)127));
}
break;
}
case EdmValueKind.Null:
{
return(targetType.IsNullable);
}
case EdmValueKind.String:
{
if (!targetType.IsString())
{
break;
}
IEdmStringTypeReference edmStringTypeReference = targetType.AsString();
if (!edmStringTypeReference.IsUnbounded)
{
int?maxLength1 = edmStringTypeReference.MaxLength;
if (maxLength1.HasValue)
{
int?nullable1 = edmStringTypeReference.MaxLength;
return(nullable1.Value >= ((IEdmStringValue)operand).Value.Length);
}
}
return(true);
}
case EdmValueKind.Structured:
{
if (!targetType.IsStructured())
{
break;
}
return(EdmExpressionEvaluator.AssertOrMatchStructuredType(targetType.AsStructured(), (IEdmStructuredValue)operand, testPropertyTypes, null));
}
case EdmValueKind.Time:
{
return(targetType.IsTime());
}
}
return(false);
}
else
{
return(true);
}
return(true);
}
private static bool TryAssertBinaryConstantAsType(IEdmBinaryConstantExpression expression, IEdmTypeReference type, out IEnumerable<EdmError> discoveredErrors)
{
if (type.IsBinary())
{
IEdmBinaryTypeReference edmBinaryTypeReference = type.AsBinary();
int? maxLength = edmBinaryTypeReference.MaxLength;
if (maxLength.HasValue)
{
int? nullable = edmBinaryTypeReference.MaxLength;
if ((int)expression.Value.Length > nullable.Value)
{
EdmError[] edmError = new EdmError[1];
int? maxLength1 = edmBinaryTypeReference.MaxLength;
edmError[0] = new EdmError(expression.Location(), EdmErrorCode.BinaryConstantLengthOutOfRange, Strings.EdmModel_Validator_Semantic_BinaryConstantLengthOutOfRange((int)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;
}
}
