public static bool IsTime(this IEdmTypeReference type)
{
EdmUtil.CheckArgumentNull <IEdmTypeReference>(type, "type");
return(type.PrimitiveKind() == EdmPrimitiveTypeKind.Time);
}
public static bool IsSpatial(this IEdmTypeReference type)
{
EdmUtil.CheckArgumentNull <IEdmTypeReference>(type, "type");
return(type.Definition.IsSpatial());
}
public static bool IsTemporal(this IEdmTypeReference type)
{
EdmUtil.CheckArgumentNull <IEdmTypeReference>(type, "type");
return(type.PrimitiveKind().IsTemporal());
}
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);
}
}
public static bool IsRow(this IEdmTypeReference type)
{
EdmUtil.CheckArgumentNull <IEdmTypeReference>(type, "type");
return(type.TypeKind() == EdmTypeKind.Row);
}
/// <summary>
/// Returns true if this reference refers to an enumeration type.
/// </summary>
/// <param name="type">Type reference.</param>
/// <returns>This reference refers to an enumeration type.</returns>
public static bool IsEnum(this IEdmTypeReference type)
{
EdmUtil.CheckArgumentNull(type, "type");
return(type.TypeKind() == EdmTypeKind.Enum);
}
public static IEdmRowTypeReference ApplyType(this IEdmRowType rowType, bool isNullable)
{
EdmUtil.CheckArgumentNull <IEdmRowType>(rowType, "type");
return(new EdmRowTypeReference(rowType, isNullable));
}
/// <summary>
/// Returns true if this reference refers to a stream type.
/// </summary>
/// <param name="type">Type reference.</param>
/// <returns>This reference refers to a stream type.</returns>
public static bool IsStream(this IEdmTypeReference type)
{
EdmUtil.CheckArgumentNull(type, "type");
return(type.PrimitiveKind() == EdmPrimitiveTypeKind.Stream);
}
// 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, AsAssociation, ...
/// <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.Time:
case EdmPrimitiveTypeKind.DateTime:
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));
}
/// <summary>
/// Returns true if this reference refers to a collection.
/// </summary>
/// <param name="type">Type reference.</param>
/// <returns>This reference refers to a collection.</returns>
public static bool IsCollection(this IEdmTypeReference type)
{
EdmUtil.CheckArgumentNull(type, "type");
return(type.TypeKind() == EdmTypeKind.Collection);
}
/// <summary>
/// Returns true if this reference refers to a DateTimeOffset type.
/// </summary>
/// <param name="type">Type reference.</param>
/// <returns>This reference refers to a DateTimeOffset type.</returns>
public static bool IsDateTimeOffset(this IEdmTypeReference type)
{
EdmUtil.CheckArgumentNull(type, "type");
return(type.PrimitiveKind() == EdmPrimitiveTypeKind.DateTimeOffset);
}
/// <summary>
/// Returns true if this reference refers to a primitive type.
/// </summary>
/// <param name="type">Type reference.</param>
/// <returns>This reference refers to a primitive type.</returns>
public static bool IsPrimitive(this IEdmTypeReference type)
{
EdmUtil.CheckArgumentNull(type, "type");
return(type.TypeKind() == EdmTypeKind.Primitive);
}
/// <summary>
/// Returns the text representation of the current object.
/// </summary>
/// <param name="property">Reference to the calling object.</param>
/// <returns>The text representation of the current object.</returns>
public static string ToTraceString(this IEdmProperty property)
{
EdmUtil.CheckArgumentNull(property, "property");
return((property.Name != null ? property.Name : "") + ":" + (property.Type != null ? property.Type.ToTraceString() : ""));
}
public static string FullyQualifiedName(IEdmVocabularyAnnotatable element)
{
IEdmSchemaElement edmSchemaElement = element as IEdmSchemaElement;
if (edmSchemaElement == null)
{
IEdmEntityContainerElement edmEntityContainerElement = element as IEdmEntityContainerElement;
if (edmEntityContainerElement == null)
{
IEdmProperty edmProperty = element as IEdmProperty;
if (edmProperty == null)
{
IEdmFunctionParameter edmFunctionParameter = element as IEdmFunctionParameter;
if (edmFunctionParameter != null)
{
string str = EdmUtil.FullyQualifiedName(edmFunctionParameter.DeclaringFunction);
if (str != null)
{
return(string.Concat(str, "/", edmFunctionParameter.Name));
}
}
}
else
{
IEdmSchemaType declaringType = edmProperty.DeclaringType as IEdmSchemaType;
if (declaringType != null)
{
string str1 = EdmUtil.FullyQualifiedName(declaringType);
if (str1 != null)
{
return(string.Concat(str1, "/", edmProperty.Name));
}
}
}
return(null);
}
else
{
IEdmFunctionImport edmFunctionImport = edmEntityContainerElement as IEdmFunctionImport;
if (edmFunctionImport == null)
{
return(string.Concat(edmEntityContainerElement.Container.FullName(), "/", edmEntityContainerElement.Name));
}
else
{
return(string.Concat(edmFunctionImport.Container.FullName(), "/", EdmUtil.ParameterizedName(edmFunctionImport)));
}
}
}
else
{
IEdmFunction edmFunction = edmSchemaElement as IEdmFunction;
if (edmFunction == null)
{
return(edmSchemaElement.FullName());
}
else
{
return(EdmUtil.ParameterizedName(edmFunction));
}
}
}
