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)); } } }