/// <summary>
/// Gets the the CLR value for a primitive property.
/// </summary>
/// <param name="structuredValue">The structured value.</param>
/// <param name="propertyName">Name of the property.</param>
/// <returns>The clr value of the property.</returns>
internal static object GetPrimitivePropertyClrValue(this IEdmStructuredValue structuredValue, string propertyName)
{
Debug.Assert(structuredValue != null, "entityInstance != null");
IEdmStructuredTypeReference valueType = structuredValue.Type.AsStructured();
IEdmPropertyValue propertyValue = structuredValue.FindPropertyValue(propertyName);
if (propertyValue == null)
{
throw new ODataException(ErrorStrings.EdmValueUtils_PropertyDoesntExist(valueType.FullName(), propertyName));
}
if (propertyValue.Value.ValueKind == EdmValueKind.Null)
{
return(null);
}
IEdmPrimitiveValue primitiveValue = propertyValue.Value as IEdmPrimitiveValue;
if (primitiveValue == null)
{
throw new ODataException(ErrorStrings.EdmValueUtils_NonPrimitiveValue(propertyValue.Name, valueType.FullName()));
}
return(primitiveValue.ToClrValue());
}
public EdmEnumMember(IEdmEnumType declaringType, string name, IEdmPrimitiveValue value) : base(name)
{
EdmUtil.CheckArgumentNull <IEdmEnumType>(declaringType, "declaringType");
EdmUtil.CheckArgumentNull <IEdmPrimitiveValue>(value, "value");
this.declaringType = declaringType;
this.@value = value;
}
/// <summary>
/// Converts the IEdmPrimitiveValue to a String.
/// </summary>
/// <param name="v">The value to convert.</param>
/// <returns>A string representation of the IEdmPrimitiveValue.</returns>
internal static string PrimitiveValueAsXml(IEdmPrimitiveValue v)
{
switch (v.ValueKind)
{
case EdmValueKind.Boolean:
return(BooleanAsXml(((IEdmBooleanValue)v).Value));
case EdmValueKind.Integer:
return(LongAsXml(((IEdmIntegerValue)v).Value));
case EdmValueKind.Floating:
return(FloatAsXml(((IEdmFloatingValue)v).Value));
case EdmValueKind.Guid:
return(GuidAsXml(((IEdmGuidValue)v).Value));
case EdmValueKind.Binary:
return(BinaryAsXml(((IEdmBinaryValue)v).Value));
case EdmValueKind.Decimal:
return(DecimalAsXml(((IEdmDecimalValue)v).Value));
case EdmValueKind.String:
return(StringAsXml(((IEdmStringValue)v).Value));
case EdmValueKind.DateTimeOffset:
return(DateTimeOffsetAsXml(((IEdmDateTimeOffsetValue)v).Value));
case EdmValueKind.Duration:
return(DurationAsXml(((IEdmDurationValue)v).Value));
default:
throw new NotSupportedException(Edm.Strings.ValueWriter_NonSerializableValue(v.ValueKind));
}
}
public EdmEnumMember AddMember(string name, IEdmPrimitiveValue value)
{
EdmEnumMember edmEnumMember = new EdmEnumMember(this, name, value);
this.AddMember(edmEnumMember);
return(edmEnumMember);
}
internal static string PrimitiveValueAsXml(IEdmPrimitiveValue v)
{
switch (v.ValueKind)
{
case EdmValueKind.Boolean:
return BooleanAsXml(((IEdmBooleanValue)v).Value);
case EdmValueKind.Integer:
return LongAsXml(((IEdmIntegerValue)v).Value);
case EdmValueKind.Floating:
return FloatAsXml(((IEdmFloatingValue)v).Value);
case EdmValueKind.Guid:
return GuidAsXml(((IEdmGuidValue)v).Value);
case EdmValueKind.Binary:
return BinaryAsXml(((IEdmBinaryValue)v).Value);
case EdmValueKind.Decimal:
return DecimalAsXml(((IEdmDecimalValue)v).Value);
case EdmValueKind.String:
return StringAsXml(((IEdmStringValue)v).Value);
case EdmValueKind.DateTime:
return DateTimeAsXml(((IEdmDateTimeValue)v).Value);
case EdmValueKind.DateTimeOffset:
return DateTimeOffsetAsXml(((IEdmDateTimeOffsetValue)v).Value);
case EdmValueKind.Time:
return TimeAsXml(((IEdmTimeValue)v).Value);
default:
throw new NotSupportedException(Edm.Strings.ValueWriter_NonSerializableValue(v.ValueKind));
}
}
public EdmEnumMember(IEdmEnumType declaringType, string name, IEdmPrimitiveValue value) : base(name)
{
EdmUtil.CheckArgumentNull<IEdmEnumType>(declaringType, "declaringType");
EdmUtil.CheckArgumentNull<IEdmPrimitiveValue>(value, "value");
this.declaringType = declaringType;
this.@value = value;
}
internal static string PrimitiveValueAsXml(IEdmPrimitiveValue v)
{
EdmValueKind valueKind = v.ValueKind;
switch (valueKind)
{
case EdmValueKind.Binary:
{
return EdmValueWriter.BinaryAsXml(((IEdmBinaryValue)v).Value);
}
case EdmValueKind.Boolean:
{
return EdmValueWriter.BooleanAsXml(((IEdmBooleanValue)v).Value);
}
case EdmValueKind.Collection:
case EdmValueKind.Enum:
case EdmValueKind.Null:
case EdmValueKind.Structured:
{
throw new NotSupportedException(Strings.ValueWriter_NonSerializableValue(v.ValueKind));
}
case EdmValueKind.DateTimeOffset:
{
return EdmValueWriter.DateTimeOffsetAsXml(((IEdmDateTimeOffsetValue)v).Value);
}
case EdmValueKind.DateTime:
{
return EdmValueWriter.DateTimeAsXml(((IEdmDateTimeValue)v).Value);
}
case EdmValueKind.Decimal:
{
return EdmValueWriter.DecimalAsXml(((IEdmDecimalValue)v).Value);
}
case EdmValueKind.Floating:
{
return EdmValueWriter.FloatAsXml(((IEdmFloatingValue)v).Value);
}
case EdmValueKind.Guid:
{
return EdmValueWriter.GuidAsXml(((IEdmGuidValue)v).Value);
}
case EdmValueKind.Integer:
{
return EdmValueWriter.LongAsXml(((IEdmIntegerValue)v).Value);
}
case EdmValueKind.String:
{
return EdmValueWriter.StringAsXml(((IEdmStringValue)v).Value);
}
case EdmValueKind.Time:
{
return EdmValueWriter.TimeAsXml(((IEdmTimeValue)v).Value);
}
default:
{
throw new NotSupportedException(Strings.ValueWriter_NonSerializableValue((object)v.ValueKind));
}
}
}
internal void WriteAnnotationStringElement(IEdmDirectValueAnnotation annotation)
{
IEdmPrimitiveValue value = (IEdmPrimitiveValue)annotation.Value;
if (value != null)
{
this.xmlWriter.WriteRaw(((IEdmStringValue)value).Value);
}
}
internal void WriteAnnotationStringAttribute(IEdmDirectValueAnnotation annotation)
{
IEdmPrimitiveValue value = (IEdmPrimitiveValue)annotation.Value;
if (value != null)
{
this.xmlWriter.WriteAttributeString(annotation.Name, annotation.NamespaceUri, EdmValueWriter.PrimitiveValueAsXml(value));
}
}
private object ConvertToClrObject(IEdmPrimitiveValue edmPrimitiveValue)
{
IEdmIntegerValue integralValue = edmPrimitiveValue as IEdmIntegerValue;
if (integralValue != null)
{
return(integralValue.Value);
}
throw new NotSupportedException("This method supports only integral types.");
}
internal static bool TryCastPrimitiveAsType(this IEdmPrimitiveValue expression, IEdmTypeReference type, out IEnumerable <EdmError> discoveredErrors)
{
if (!type.IsPrimitive())
{
discoveredErrors = new EdmError[] { new EdmError(expression.Location(), EdmErrorCode.PrimitiveConstantExpressionNotValidForNonPrimitiveType, Edm.Strings.EdmModel_Validator_Semantic_PrimitiveConstantExpressionNotValidForNonPrimitiveType) };
return(false);
}
switch (expression.ValueKind)
{
case EdmValueKind.Binary:
return(TryCastBinaryConstantAsType((IEdmBinaryConstantExpression)expression, type, out discoveredErrors));
case EdmValueKind.Boolean:
return(TryCastBooleanConstantAsType((IEdmBooleanConstantExpression)expression, type, out discoveredErrors));
case EdmValueKind.DateTimeOffset:
return(TryCastDateTimeOffsetConstantAsType((IEdmDateTimeOffsetConstantExpression)expression, type, out discoveredErrors));
case EdmValueKind.Decimal:
return(TryCastDecimalConstantAsType((IEdmDecimalConstantExpression)expression, type, out discoveredErrors));
case EdmValueKind.Floating:
return(TryCastFloatingConstantAsType((IEdmFloatingConstantExpression)expression, type, out discoveredErrors));
case EdmValueKind.Guid:
return(TryCastGuidConstantAsType((IEdmGuidConstantExpression)expression, type, out discoveredErrors));
case EdmValueKind.Integer:
return(TryCastIntegerConstantAsType((IEdmIntegerConstantExpression)expression, type, out discoveredErrors));
case EdmValueKind.String:
return(TryCastStringConstantAsType((IEdmStringConstantExpression)expression, type, out discoveredErrors));
case EdmValueKind.Duration:
return(TryCastDurationConstantAsType((IEdmDurationConstantExpression)expression, type, out discoveredErrors));
case EdmValueKind.Date:
return(TryCastDateConstantAsType((IEdmDateConstantExpression)expression, type, out discoveredErrors));
case EdmValueKind.TimeOfDay:
return(TryCastTimeOfDayConstantAsType((IEdmTimeOfDayConstantExpression)expression, type, out discoveredErrors));
default:
discoveredErrors = new EdmError[] { new EdmError(expression.Location(), EdmErrorCode.ExpressionPrimitiveKindNotValidForAssertedType, Edm.Strings.EdmModel_Validator_Semantic_ExpressionPrimitiveKindNotValidForAssertedType) };
return(false);
}
}
/// <summary>
/// Gets the clr value of the edm value based on its type.
/// </summary>
/// <param name="edmValue">The edm value.</param>
/// <returns>The clr value</returns>
internal static object ToClrValue(this IEdmPrimitiveValue edmValue)
{
#if !ASTORIA_CLIENT
#endif
Debug.Assert(edmValue != null, "edmValue != null");
EdmPrimitiveTypeKind primitiveKind = edmValue.Type.PrimitiveKind();
switch (edmValue.ValueKind)
{
case EdmValueKind.Binary:
return(((IEdmBinaryValue)edmValue).Value);
case EdmValueKind.Boolean:
return(((IEdmBooleanValue)edmValue).Value);
case EdmValueKind.DateTimeOffset:
return(((IEdmDateTimeOffsetValue)edmValue).Value);
case EdmValueKind.Decimal:
return(((IEdmDecimalValue)edmValue).Value);
case EdmValueKind.Guid:
return(((IEdmGuidValue)edmValue).Value);
case EdmValueKind.String:
return(((IEdmStringValue)edmValue).Value);
case EdmValueKind.Duration:
return(((IEdmDurationValue)edmValue).Value);
case EdmValueKind.Floating:
return(ConvertFloatingValue((IEdmFloatingValue)edmValue, primitiveKind));
case EdmValueKind.Integer:
return(ConvertIntegerValue((IEdmIntegerValue)edmValue, primitiveKind));
case EdmValueKind.Date:
return(((IEdmDateValue)edmValue).Value);
case EdmValueKind.TimeOfDay:
return(((IEdmTimeOfDayValue)edmValue).Value);
}
throw new ODataException(ErrorStrings.EdmValueUtils_CannotConvertTypeToClrValue(edmValue.ValueKind));
}
/// <summary>
/// Converts the IEdmPrimitiveValue to a String.
/// </summary>
/// <param name="v">The value to convert.</param>
/// <returns>A string representation of the IEdmPrimitiveValue.</returns>
internal static string PrimitiveValueAsXml(IEdmPrimitiveValue v)
{
switch (v.ValueKind)
{
case EdmValueKind.Boolean:
return(BooleanAsXml(((IEdmBooleanValue)v).Value));
case EdmValueKind.Integer:
return(LongAsXml(((IEdmIntegerValue)v).Value));
case EdmValueKind.Floating:
return(FloatAsXml(((IEdmFloatingValue)v).Value));
case EdmValueKind.Guid:
return(GuidAsXml(((IEdmGuidValue)v).Value));
case EdmValueKind.Binary:
return(BinaryAsXml(((IEdmBinaryValue)v).Value));
case EdmValueKind.Decimal:
return(DecimalAsXml(((IEdmDecimalValue)v).Value));
case EdmValueKind.String:
return(StringAsXml(((IEdmStringValue)v).Value));
case EdmValueKind.DateTimeOffset:
return(DateTimeOffsetAsXml(((IEdmDateTimeOffsetValue)v).Value));
case EdmValueKind.Date:
return(DateAsXml(((IEdmDateValue)v).Value));
case EdmValueKind.Duration:
return(DurationAsXml(((IEdmDurationValue)v).Value));
case EdmValueKind.TimeOfDay:
return(TimeOfDayAsXml(((IEdmTimeOfDayValue)v).Value));
default:
return(null);
}
}
private static void ClrValueShouldMatch <TValue>(IEdmPrimitiveValue edmValue, TValue expected)
{
edmValue.ToClrValue().Should().Be(expected);
}
public EdmEnumMember AddMember(string name, IEdmPrimitiveValue value)
{
EdmEnumMember edmEnumMember = new EdmEnumMember(this, name, value);
this.AddMember(edmEnumMember);
return edmEnumMember;
}
/// <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);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="EdmEnumValue"/> class.
/// </summary>
/// <param name="type">A reference to the enumeration type that describes this value.</param>
/// <param name="value">The underlying type value.</param>
public EdmEnumValue(IEdmEnumTypeReference type, IEdmPrimitiveValue value)
: base(type)
{
this.value = value;
}
private object ConvertToClrObject(IEdmPrimitiveValue edmPrimitiveValue)
{
IEdmIntegerValue integralValue = edmPrimitiveValue as IEdmIntegerValue;
if (integralValue != null)
{
return integralValue.Value;
}
throw new NotSupportedException("This method supports only integral types.");
}
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);
}
}
public CustomEnumMember(IEdmEnumType declaringType, string name, IEdmPrimitiveValue value)
: base(name)
{
this.declaringType = declaringType;
this.value = value;
}
internal static string PrimitiveValueAsXml(IEdmPrimitiveValue v)
{
EdmValueKind valueKind = v.ValueKind;
switch (valueKind)
{
case EdmValueKind.Binary:
{
return(EdmValueWriter.BinaryAsXml(((IEdmBinaryValue)v).Value));
}
case EdmValueKind.Boolean:
{
return(EdmValueWriter.BooleanAsXml(((IEdmBooleanValue)v).Value));
}
case EdmValueKind.Collection:
case EdmValueKind.Enum:
case EdmValueKind.Null:
case EdmValueKind.Structured:
{
throw new NotSupportedException(Strings.ValueWriter_NonSerializableValue(v.ValueKind));
}
case EdmValueKind.DateTimeOffset:
{
return(EdmValueWriter.DateTimeOffsetAsXml(((IEdmDateTimeOffsetValue)v).Value));
}
case EdmValueKind.DateTime:
{
return(EdmValueWriter.DateTimeAsXml(((IEdmDateTimeValue)v).Value));
}
case EdmValueKind.Decimal:
{
return(EdmValueWriter.DecimalAsXml(((IEdmDecimalValue)v).Value));
}
case EdmValueKind.Floating:
{
return(EdmValueWriter.FloatAsXml(((IEdmFloatingValue)v).Value));
}
case EdmValueKind.Guid:
{
return(EdmValueWriter.GuidAsXml(((IEdmGuidValue)v).Value));
}
case EdmValueKind.Integer:
{
return(EdmValueWriter.LongAsXml(((IEdmIntegerValue)v).Value));
}
case EdmValueKind.String:
{
return(EdmValueWriter.StringAsXml(((IEdmStringValue)v).Value));
}
case EdmValueKind.Time:
{
return(EdmValueWriter.TimeAsXml(((IEdmTimeValue)v).Value));
}
default:
{
throw new NotSupportedException(Strings.ValueWriter_NonSerializableValue((object)v.ValueKind));
}
}
}
public CustomEnumMember(IEdmEnumType declaringType, string name, IEdmPrimitiveValue value)
: base(name)
{
this.declaringType = declaringType;
this.value = value;
}
/// <summary>
/// Initializes a new instance of the <see cref="EdmEnumValue"/> class.
/// </summary>
/// <param name="type">A reference to the enumeration type that describes this value.</param>
/// <param name="value">The underlying type value.</param>
public EdmEnumValue(IEdmEnumTypeReference type, IEdmPrimitiveValue value)
: base(type)
{
this.value = value;
}
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);
}
}
}
}
