private static IEdmValue AssertType(IEdmTypeReference targetType, IEdmValue operand)
{
IEdmTypeReference type = operand.Type;
EdmValueKind valueKind = operand.ValueKind;
if ((type == null || valueKind == EdmValueKind.Null || !type.Definition.IsOrInheritsFrom(targetType.Definition)) && targetType.TypeKind() != EdmTypeKind.None)
{
bool flag = true;
EdmValueKind edmValueKind = valueKind;
if (edmValueKind == EdmValueKind.Collection)
{
if (!targetType.IsCollection())
{
flag = false;
}
else
{
return(new EdmExpressionEvaluator.AssertTypeCollectionValue(targetType.AsCollection(), (IEdmCollectionValue)operand));
}
}
else
{
if (edmValueKind == EdmValueKind.Structured)
{
if (!targetType.IsStructured())
{
flag = false;
}
else
{
IEdmStructuredTypeReference edmStructuredTypeReference = targetType.AsStructured();
List <IEdmPropertyValue> edmPropertyValues = new List <IEdmPropertyValue>();
flag = EdmExpressionEvaluator.AssertOrMatchStructuredType(edmStructuredTypeReference, (IEdmStructuredValue)operand, true, edmPropertyValues);
if (flag)
{
return(new EdmStructuredValue(edmStructuredTypeReference, edmPropertyValues));
}
}
}
else
{
flag = EdmExpressionEvaluator.MatchesType(targetType, operand);
}
}
if (flag)
{
return(operand);
}
else
{
throw new InvalidOperationException(Strings.Edm_Evaluator_FailedTypeAssertion(targetType.ToTraceString()));
}
}
else
{
return(operand);
}
}
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);
}
