private static PrimitiveType ConvertFromLegacyStoreEdmType( LegacyMetadata.PrimitiveType legacyPrimitiveType, DbProviderManifest providerManifest) { Debug.Assert(legacyPrimitiveType != null, "legacyPrimitiveType != null"); Debug.Assert(providerManifest != null, "providerManifest != null"); Debug.Assert( (LegacyMetadata.DataSpace) typeof(LegacyMetadata.EdmType) .GetProperty("DataSpace", BindingFlags.Instance | BindingFlags.NonPublic) .GetValue(legacyPrimitiveType) == LegacyMetadata.DataSpace.SSpace, "Expected SSpace type."); var newPrimitiveType = (PrimitiveType)_primitiveTypeConstructor.Invoke( BindingFlags.CreateInstance, null, new object[] { legacyPrimitiveType.Name, legacyPrimitiveType.NamespaceName, DataSpace.SSpace, FromLegacyPrimitiveType((LegacyMetadata.PrimitiveType)legacyPrimitiveType.BaseType), providerManifest }, CultureInfo.InvariantCulture ); SetReadOnlyMethod.Invoke(newPrimitiveType, new object[0]); return(newPrimitiveType); }
/// <summary> /// The constructor for PrimitiveType, it takes in a CLR type containing the identity information /// </summary> /// <param name="clrType">The CLR type object for this primitive type</param> /// <param name="baseType">The base type for this primitive type</param> /// <param name="providerManifest">The ProviderManifest of the provider of this type</param> internal PrimitiveType(Type clrType, PrimitiveType baseType, DbProviderManifest providerManifest) : this(EntityUtil.GenericCheckArgumentNull(clrType, "clrType").Name, clrType.Namespace, DataSpace.OSpace, baseType, providerManifest) { Debug.Assert(clrType == ClrEquivalentType, "not equivalent to ClrEquivalentType"); }
/// <summary> /// Initializes a new instance of the EnumType class by using the specified <paramref name="name"/>, /// <paramref name="namespaceName"/> and <paramref name="isFlags"/>. /// </summary> /// <param name="name">The name of this enum type.</param> /// <param name="namespaceName">The namespace this enum type belongs to.</param> /// <param name="isFlags">Indicates whether the enum type is defined as flags (i.e. can be treated as a bit field).</param> /// <param name="underlyingType">Underlying type of this enumeration type.</param> /// <param name="dataSpace">DataSpace this enum type lives in. Can be either CSpace or OSpace</param> /// <exception cref="System.ArgumentNullException">Thrown if name or namespace arguments are null</exception> /// <remarks>Note that enums live only in CSpace.</remarks> internal EnumType(string name, string namespaceName, PrimitiveType underlyingType, bool isFlags, DataSpace dataSpace) : base(name, namespaceName, dataSpace) { Debug.Assert(underlyingType != null, "underlyingType != null"); Debug.Assert(Helper.IsSupportedEnumUnderlyingType(underlyingType.PrimitiveTypeKind), "Unsupported underlying type for enum."); Debug.Assert(dataSpace == DataSpace.CSpace || dataSpace == DataSpace.OSpace, "Enums can be only defined in CSpace or OSpace."); _isFlags = isFlags; _underlyingType = underlyingType; }
/// <summary> /// Returns the primitive type corresponding to the given CLR type /// </summary> /// <param name="clrType">The CLR type for which the PrimitiveType object is retrieved</param> /// <param name="primitiveType">The retrieved primitive type</param> /// <returns>True if a primitive type is returned</returns> internal bool TryGetPrimitiveType(Type clrType, out PrimitiveType primitiveType) { primitiveType = null; PrimitiveTypeKind resolvedTypeKind; if (TryGetPrimitiveTypeKind(clrType, out resolvedTypeKind)) { InitializePrimitiveTypes(); primitiveType = _primitiveTypes[(int)resolvedTypeKind]; return true; } return false; }
/// <summary> /// The constructor for PrimitiveType. It takes the required information to identify this type. /// </summary> /// <param name="name">The name of this type</param> /// <param name="namespaceName">The namespace name of this type</param> /// <param name="version">The version of this type</param> /// <param name="dataSpace">dataSpace in which this primitive type belongs to</param> /// <param name="baseType">The primitive type that this type is derived from</param> /// <param name="providerManifest">The ProviderManifest of the provider of this type</param> /// <exception cref="System.ArgumentNullException">Thrown if name, namespaceName, version, baseType or providerManifest arguments are null</exception> internal PrimitiveType(string name, string namespaceName, DataSpace dataSpace, PrimitiveType baseType, DbProviderManifest providerManifest) : base(name, namespaceName, dataSpace) { EntityUtil.GenericCheckArgumentNull(baseType, "baseType"); EntityUtil.GenericCheckArgumentNull(providerManifest, "providerManifest"); this.BaseType = baseType; Initialize(this, baseType.PrimitiveTypeKind, false, // isDefault providerManifest); }
/// <summary> /// Add the given primitive type to the primitive type cache /// </summary> /// <param name="type">The primitive type to add</param> internal void Add(PrimitiveType type) { // Get to the list List<PrimitiveType> primitiveTypes = EntityUtil.CheckArgumentOutOfRange(_primitiveTypeMap, (int)type.PrimitiveTypeKind, "primitiveTypeKind"); // If there isn't a list for the given model type, create one and add it if (primitiveTypes == null) { primitiveTypes = new List<PrimitiveType>(); primitiveTypes.Add(type); _primitiveTypeMap[(int)type.PrimitiveTypeKind] = primitiveTypes; } else { primitiveTypes.Add(type); } }
/// <summary> /// Attempts to get the primitive store type for the given type name. This method takes the target .NET Framework /// into account and only returns primitive types that are supported by the Framework that is being targeted. /// If a type is recognized but excluded because it is not supported by the target Framework then the excludedForTarget /// flag is set to true. /// </summary> internal bool TryGetStorePrimitiveType(string typeName, out PrimitiveType primitiveType, out bool excludedForTarget) { excludedForTarget = false; var success = ItemCollection.TryGetItem<PrimitiveType>(StoreNamespace + "." + typeName, false, out primitiveType); // If targetting 4.0 using 4.5 then we need to ignore geometry and geography types just like we would have done when // generating with 4.0. We can only get the base spatial types since we won't reverse engineer to derived spatial // types. We don't need to do anything for enums because we will never reverse engineer to an enum. if (success && _targetEntityFrameworkVersion.CompareTo(EntityFrameworkVersions.Version3) < 0 && (primitiveType.PrimitiveTypeKind == PrimitiveTypeKind.Geography || primitiveType.PrimitiveTypeKind == PrimitiveTypeKind.Geometry)) { excludedForTarget = true; primitiveType = null; return false; } return success; }
private static bool IsSubTypeOf(PrimitiveType subPrimitiveType, PrimitiveType superPrimitiveType) { if (object.ReferenceEquals(subPrimitiveType, superPrimitiveType)) { return true; } if (Helper.AreSameSpatialUnionType(subPrimitiveType, superPrimitiveType)) { return true; } objectModel.ReadOnlyCollection<PrimitiveType> superTypes = EdmProviderManifest.Instance.GetPromotionTypes(subPrimitiveType); return (-1 != superTypes.IndexOf(superPrimitiveType)); }
/// <summary> /// Converts a variable of type 'DataType' to type 'System.Type' /// </summary> /// <param name="type">type to convert</param> /// <returns>System.Type representation of type</returns> private static Type DataTypeToSystemType(PrimitiveType type, bool makeNullable) { if (makeNullable && type.ClrEquivalentType != typeof(string) && type.ClrEquivalentType != typeof(byte[])) { return typeof(Nullable<>).MakeGenericType(type.ClrEquivalentType); } return type.ClrEquivalentType; }
/// <summary> /// Initializes all the primitive types /// </summary> private void InitializePrimitiveTypes() { if (_primitiveTypes != null) { return; } PrimitiveType[] primitiveTypes = new PrimitiveType[s_PrimitiveTypeCount]; primitiveTypes[(int)PrimitiveTypeKind.Binary] = CreatePrimitiveType(typeof(Byte[]), PrimitiveTypeKind.Binary); primitiveTypes[(int)PrimitiveTypeKind.Boolean] = CreatePrimitiveType(typeof(Boolean), PrimitiveTypeKind.Boolean); primitiveTypes[(int)PrimitiveTypeKind.Byte] = CreatePrimitiveType(typeof(Byte), PrimitiveTypeKind.Byte); primitiveTypes[(int)PrimitiveTypeKind.DateTime] = CreatePrimitiveType(typeof(DateTime), PrimitiveTypeKind.DateTime); primitiveTypes[(int)PrimitiveTypeKind.Time] = CreatePrimitiveType(typeof(TimeSpan), PrimitiveTypeKind.Time); primitiveTypes[(int)PrimitiveTypeKind.DateTimeOffset] = CreatePrimitiveType(typeof(DateTimeOffset), PrimitiveTypeKind.DateTimeOffset); primitiveTypes[(int)PrimitiveTypeKind.Decimal] = CreatePrimitiveType(typeof(Decimal), PrimitiveTypeKind.Decimal); primitiveTypes[(int)PrimitiveTypeKind.Double] = CreatePrimitiveType(typeof(Double), PrimitiveTypeKind.Double); primitiveTypes[(int)PrimitiveTypeKind.Geography] = CreatePrimitiveType(typeof(DbGeography), PrimitiveTypeKind.Geography); primitiveTypes[(int)PrimitiveTypeKind.Geometry] = CreatePrimitiveType(typeof(DbGeometry), PrimitiveTypeKind.Geometry); primitiveTypes[(int)PrimitiveTypeKind.Guid] = CreatePrimitiveType(typeof(Guid), PrimitiveTypeKind.Guid); primitiveTypes[(int)PrimitiveTypeKind.Int16] = CreatePrimitiveType(typeof(Int16), PrimitiveTypeKind.Int16); primitiveTypes[(int)PrimitiveTypeKind.Int32] = CreatePrimitiveType(typeof(Int32), PrimitiveTypeKind.Int32); primitiveTypes[(int)PrimitiveTypeKind.Int64] = CreatePrimitiveType(typeof(Int64), PrimitiveTypeKind.Int64); primitiveTypes[(int)PrimitiveTypeKind.SByte] = CreatePrimitiveType(typeof(SByte), PrimitiveTypeKind.SByte); primitiveTypes[(int)PrimitiveTypeKind.Single] = CreatePrimitiveType(typeof(Single), PrimitiveTypeKind.Single); primitiveTypes[(int)PrimitiveTypeKind.String] = CreatePrimitiveType(typeof(String), PrimitiveTypeKind.String); System.Collections.ObjectModel.ReadOnlyCollection<PrimitiveType> readOnlyTypes = new System.Collections.ObjectModel.ReadOnlyCollection<PrimitiveType>(primitiveTypes); // Set the result to _primitiveTypes at the end Interlocked.CompareExchange<System.Collections.ObjectModel.ReadOnlyCollection<PrimitiveType>>(ref _primitiveTypes, readOnlyTypes, null); }
/// <summary> /// Try and get the mapped type for the given primitiveTypeKind in the given dataspace /// </summary> /// <param name="primitiveTypeKind">The primitive type kind of the primitive type to retrieve</param> /// <param name="facets">The facets to use in picking the primitive type</param> /// <param name="type">The resulting type</param> /// <returns>Whether a type was retrieved or not</returns> internal bool TryGetType(PrimitiveTypeKind primitiveTypeKind, IEnumerable<Facet> facets, out PrimitiveType type) { type = null; // Now, see if we have any types for this model type, if so, loop through to find the best matching one List<PrimitiveType> primitiveTypes = EntityUtil.CheckArgumentOutOfRange(_primitiveTypeMap, (int)primitiveTypeKind, "primitiveTypeKind"); if ((null != primitiveTypes) && (0 < primitiveTypes.Count)) { if (primitiveTypes.Count == 1) { type = primitiveTypes[0]; return true; } if (facets == null) { FacetDescription[] facetDescriptions = EdmProviderManifest.GetInitialFacetDescriptions(primitiveTypeKind); if (facetDescriptions == null) { type = primitiveTypes[0]; return true; } Debug.Assert(facetDescriptions.Length > 0); facets = CacheForPrimitiveTypes.CreateInitialFacets(facetDescriptions); } Debug.Assert(type == null, "type must be null here"); bool isMaxLengthSentinel = false; // Create a dictionary of facets for easy lookup foreach (Facet facet in facets) { if ((primitiveTypeKind == PrimitiveTypeKind.String || primitiveTypeKind == PrimitiveTypeKind.Binary) && facet.Value != null && facet.Name == EdmProviderManifest.MaxLengthFacetName && Helper.IsUnboundedFacetValue(facet)) { // MaxLength has the sentinel value. So this facet need not be added. isMaxLengthSentinel = true; continue; } } int maxLength = 0; // Find a primitive type with the matching constraint foreach (PrimitiveType primitiveType in primitiveTypes) { if (isMaxLengthSentinel) { if (type == null) { type = primitiveType; maxLength = Helper.GetFacet(primitiveType.FacetDescriptions, EdmProviderManifest.MaxLengthFacetName).MaxValue.Value; } else { int newMaxLength = Helper.GetFacet(primitiveType.FacetDescriptions, EdmProviderManifest.MaxLengthFacetName).MaxValue.Value; if (newMaxLength > maxLength) { type = primitiveType; maxLength = newMaxLength; } } } else { type = primitiveType; break; } } Debug.Assert(type != null); return true; } return false; }
protected override void Visit(PrimitiveType primitiveType) { int index; if (!this.AddObjectToSeenListAndHashBuilder(primitiveType, out index)) { return; } this.AddObjectStartDumpToHashBuilder(primitiveType, index); #region Inner data visit this.AddObjectContentToHashBuilder(primitiveType.Name); this.AddObjectContentToHashBuilder(primitiveType.NamespaceName); base.Visit(primitiveType); #endregion this.AddObjectEndDumpToHashBuilder(); }
protected virtual void Visit(PrimitiveType primitiveType) { }
private static PrimitiveType FromLegacyPrimitiveType(LegacyMetadata.PrimitiveType legacyPrimitiveType) { return (PrimitiveType.GetEdmPrimitiveType((PrimitiveTypeKind)(int)legacyPrimitiveType.PrimitiveTypeKind)); }
/// <summary> /// Returns the list of super-types for the given primitiveType /// </summary> /// <param name="primitiveType"></param> /// <returns></returns> internal ReadOnlyCollection<PrimitiveType> GetPromotionTypes(PrimitiveType primitiveType) { InitializePromotableTypes(); return _promotionTypes[(int)primitiveType.PrimitiveTypeKind]; }
/// <summary> /// Perform initialization that's common across all constructors /// </summary> /// <param name="primitiveType">The primitive type to initialize</param> /// <param name="primitiveTypeKind">The primitive type kind of this primitive type</param> /// <param name="isDefaultType">When true this is the default type to return when a type is asked for by PrimitiveTypeKind</param> /// <param name="providerManifest">The ProviderManifest of the provider of this type</param> internal static void Initialize(PrimitiveType primitiveType, PrimitiveTypeKind primitiveTypeKind, bool isDefaultType, DbProviderManifest providerManifest) { primitiveType._primitiveTypeKind = primitiveTypeKind; primitiveType._providerManifest = providerManifest; }
protected bool TryGetPrimitiveType(Type type, out PrimitiveType primitiveType) { return ClrProviderManifest.Instance.TryGetPrimitiveType(Nullable.GetUnderlyingType(type) ?? type, out primitiveType); }
/// <summary> /// Boostrapping all the primitive types for the EDM Provider Manifest /// </summary> private void InitializePrimitiveTypes() { if (_primitiveTypes != null) { return; } PrimitiveType[] primitiveTypes = new PrimitiveType[EdmConstants.NumPrimitiveTypes]; primitiveTypes[(int)PrimitiveTypeKind.Binary] = new PrimitiveType(); primitiveTypes[(int)PrimitiveTypeKind.Boolean] = new PrimitiveType(); primitiveTypes[(int)PrimitiveTypeKind.Byte] = new PrimitiveType(); primitiveTypes[(int)PrimitiveTypeKind.DateTime] = new PrimitiveType(); primitiveTypes[(int)PrimitiveTypeKind.Decimal] = new PrimitiveType(); primitiveTypes[(int)PrimitiveTypeKind.Double] = new PrimitiveType(); primitiveTypes[(int)PrimitiveTypeKind.Single] = new PrimitiveType(); primitiveTypes[(int)PrimitiveTypeKind.Guid] = new PrimitiveType(); primitiveTypes[(int)PrimitiveTypeKind.Int16] = new PrimitiveType(); primitiveTypes[(int)PrimitiveTypeKind.Int32] = new PrimitiveType(); primitiveTypes[(int)PrimitiveTypeKind.Int64] = new PrimitiveType(); primitiveTypes[(int)PrimitiveTypeKind.SByte] = new PrimitiveType(); primitiveTypes[(int)PrimitiveTypeKind.String] = new PrimitiveType(); primitiveTypes[(int)PrimitiveTypeKind.Time] = new PrimitiveType(); primitiveTypes[(int)PrimitiveTypeKind.DateTimeOffset] = new PrimitiveType(); primitiveTypes[(int)PrimitiveTypeKind.Geometry] = new PrimitiveType(); primitiveTypes[(int)PrimitiveTypeKind.GeometryPoint] = new PrimitiveType(); primitiveTypes[(int)PrimitiveTypeKind.GeometryLineString] = new PrimitiveType(); primitiveTypes[(int)PrimitiveTypeKind.GeometryPolygon] = new PrimitiveType(); primitiveTypes[(int)PrimitiveTypeKind.GeometryMultiPoint] = new PrimitiveType(); primitiveTypes[(int)PrimitiveTypeKind.GeometryMultiLineString] = new PrimitiveType(); primitiveTypes[(int)PrimitiveTypeKind.GeometryMultiPolygon] = new PrimitiveType(); primitiveTypes[(int)PrimitiveTypeKind.GeometryCollection] = new PrimitiveType(); primitiveTypes[(int)PrimitiveTypeKind.Geography] = new PrimitiveType(); primitiveTypes[(int)PrimitiveTypeKind.GeographyPoint] = new PrimitiveType(); primitiveTypes[(int)PrimitiveTypeKind.GeographyLineString] = new PrimitiveType(); primitiveTypes[(int)PrimitiveTypeKind.GeographyPolygon] = new PrimitiveType(); primitiveTypes[(int)PrimitiveTypeKind.GeographyMultiPoint] = new PrimitiveType(); primitiveTypes[(int)PrimitiveTypeKind.GeographyMultiLineString] = new PrimitiveType(); primitiveTypes[(int)PrimitiveTypeKind.GeographyMultiPolygon] = new PrimitiveType(); primitiveTypes[(int)PrimitiveTypeKind.GeographyCollection] = new PrimitiveType(); InitializePrimitiveType(primitiveTypes[(int)PrimitiveTypeKind.Binary], PrimitiveTypeKind.Binary, EdmConstants.Binary, typeof(Byte[])); InitializePrimitiveType(primitiveTypes[(int)PrimitiveTypeKind.Boolean], PrimitiveTypeKind.Boolean, EdmConstants.Boolean, typeof(Boolean)); InitializePrimitiveType(primitiveTypes[(int)PrimitiveTypeKind.Byte], PrimitiveTypeKind.Byte, EdmConstants.Byte, typeof(Byte)); InitializePrimitiveType(primitiveTypes[(int)PrimitiveTypeKind.DateTime], PrimitiveTypeKind.DateTime, EdmConstants.DateTime, typeof(DateTime)); InitializePrimitiveType(primitiveTypes[(int)PrimitiveTypeKind.Decimal], PrimitiveTypeKind.Decimal, EdmConstants.Decimal, typeof(Decimal)); InitializePrimitiveType(primitiveTypes[(int)PrimitiveTypeKind.Double], PrimitiveTypeKind.Double, EdmConstants.Double, typeof(Double)); InitializePrimitiveType(primitiveTypes[(int)PrimitiveTypeKind.Single], PrimitiveTypeKind.Single, EdmConstants.Single, typeof(Single)); InitializePrimitiveType(primitiveTypes[(int)PrimitiveTypeKind.Guid], PrimitiveTypeKind.Guid, EdmConstants.Guid, typeof(Guid)); InitializePrimitiveType(primitiveTypes[(int)PrimitiveTypeKind.Int16], PrimitiveTypeKind.Int16, EdmConstants.Int16, typeof(Int16)); InitializePrimitiveType(primitiveTypes[(int)PrimitiveTypeKind.Int32], PrimitiveTypeKind.Int32, EdmConstants.Int32, typeof(Int32)); InitializePrimitiveType(primitiveTypes[(int)PrimitiveTypeKind.Int64], PrimitiveTypeKind.Int64, EdmConstants.Int64, typeof(Int64)); InitializePrimitiveType(primitiveTypes[(int)PrimitiveTypeKind.SByte], PrimitiveTypeKind.SByte, EdmConstants.SByte, typeof(SByte)); InitializePrimitiveType(primitiveTypes[(int)PrimitiveTypeKind.String], PrimitiveTypeKind.String, EdmConstants.String, typeof(String)); InitializePrimitiveType(primitiveTypes[(int)PrimitiveTypeKind.Time], PrimitiveTypeKind.Time, EdmConstants.Time, typeof(TimeSpan)); InitializePrimitiveType(primitiveTypes[(int)PrimitiveTypeKind.DateTimeOffset], PrimitiveTypeKind.DateTimeOffset, EdmConstants.DateTimeOffset, typeof(DateTimeOffset)); InitializePrimitiveType(primitiveTypes[(int)PrimitiveTypeKind.Geography], PrimitiveTypeKind.Geography, EdmConstants.Geography, typeof(DbGeography)); InitializePrimitiveType(primitiveTypes[(int)PrimitiveTypeKind.GeographyPoint], PrimitiveTypeKind.GeographyPoint, EdmConstants.GeographyPoint, typeof(DbGeography)); InitializePrimitiveType(primitiveTypes[(int)PrimitiveTypeKind.GeographyLineString], PrimitiveTypeKind.GeographyLineString, EdmConstants.GeographyLineString, typeof(DbGeography)); InitializePrimitiveType(primitiveTypes[(int)PrimitiveTypeKind.GeographyPolygon], PrimitiveTypeKind.GeographyPolygon, EdmConstants.GeographyPolygon, typeof(DbGeography)); InitializePrimitiveType(primitiveTypes[(int)PrimitiveTypeKind.GeographyMultiPoint], PrimitiveTypeKind.GeographyMultiPoint, EdmConstants.GeographyMultiPoint, typeof(DbGeography)); InitializePrimitiveType(primitiveTypes[(int)PrimitiveTypeKind.GeographyMultiLineString], PrimitiveTypeKind.GeographyMultiLineString, EdmConstants.GeographyMultiLineString, typeof(DbGeography)); InitializePrimitiveType(primitiveTypes[(int)PrimitiveTypeKind.GeographyMultiPolygon], PrimitiveTypeKind.GeographyMultiPolygon, EdmConstants.GeographyMultiPolygon, typeof(DbGeography)); InitializePrimitiveType(primitiveTypes[(int)PrimitiveTypeKind.GeographyCollection], PrimitiveTypeKind.GeographyCollection, EdmConstants.GeographyCollection, typeof(DbGeography)); InitializePrimitiveType(primitiveTypes[(int)PrimitiveTypeKind.Geometry], PrimitiveTypeKind.Geometry, EdmConstants.Geometry, typeof(DbGeometry)); InitializePrimitiveType(primitiveTypes[(int)PrimitiveTypeKind.GeometryPoint], PrimitiveTypeKind.GeometryPoint, EdmConstants.GeometryPoint, typeof(DbGeometry)); InitializePrimitiveType(primitiveTypes[(int)PrimitiveTypeKind.GeometryLineString], PrimitiveTypeKind.GeometryLineString, EdmConstants.GeometryLineString, typeof(DbGeometry)); InitializePrimitiveType(primitiveTypes[(int)PrimitiveTypeKind.GeometryPolygon], PrimitiveTypeKind.GeometryPolygon, EdmConstants.GeometryPolygon, typeof(DbGeometry)); InitializePrimitiveType(primitiveTypes[(int)PrimitiveTypeKind.GeometryMultiPoint], PrimitiveTypeKind.GeometryMultiPoint, EdmConstants.GeometryMultiPoint, typeof(DbGeometry)); InitializePrimitiveType(primitiveTypes[(int)PrimitiveTypeKind.GeometryMultiLineString], PrimitiveTypeKind.GeometryMultiLineString, EdmConstants.GeometryMultiLineString, typeof(DbGeometry)); InitializePrimitiveType(primitiveTypes[(int)PrimitiveTypeKind.GeometryMultiPolygon], PrimitiveTypeKind.GeometryMultiPolygon, EdmConstants.GeometryMultiPolygon, typeof(DbGeometry)); InitializePrimitiveType(primitiveTypes[(int)PrimitiveTypeKind.GeometryCollection], PrimitiveTypeKind.GeometryCollection, EdmConstants.GeometryCollection, typeof(DbGeometry)); // Set all primitive types to be readonly foreach (PrimitiveType primitiveType in primitiveTypes) { primitiveType.ProviderManifest = this; primitiveType.SetReadOnly(); } System.Collections.ObjectModel.ReadOnlyCollection<PrimitiveType> readOnlyTypes = new System.Collections.ObjectModel.ReadOnlyCollection<PrimitiveType>(primitiveTypes); // Set the result to _primitiveTypes at the end Interlocked.CompareExchange<System.Collections.ObjectModel.ReadOnlyCollection<PrimitiveType>>(ref _primitiveTypes, readOnlyTypes, null); }
/// <summary> /// returns the primitive type for a given primitive type kind. /// </summary> /// <param name="primitiveTypeKind"></param> /// <param name="primitiveType"></param> /// <returns></returns> internal virtual bool TryGetMappedPrimitiveType(PrimitiveTypeKind primitiveTypeKind, out PrimitiveType primitiveType) { primitiveType = m_metadataWorkspace.GetMappedPrimitiveType(primitiveTypeKind, DataSpace.CSpace); return (null != primitiveType); }
/// <summary> /// Initialize all the primitive type with the given primitive type kind and name /// </summary> /// <param name="primitiveType">The primitive type to initialize</param> /// <param name="primitiveTypeKind">Type of the primitive type which is getting initialized</param> /// <param name="name">name of the built in type</param> /// <param name="clrType">the CLR Type of that maps to the EDM PrimitiveType</param> private void InitializePrimitiveType(PrimitiveType primitiveType, PrimitiveTypeKind primitiveTypeKind, string name, Type clrType) { // Only null types are not abstract and they are sealed, all others are abstract and unsealed EdmType.Initialize(primitiveType, name, EdmConstants.EdmNamespace, DataSpace.CSpace, true /* isabstract */, null /* baseType */); PrimitiveType.Initialize(primitiveType, primitiveTypeKind, true, // isDefault this); Debug.Assert(clrType == primitiveType.ClrEquivalentType, "ClrEquivalentType mismatch"); }
/// <summary> /// Initialize the primitive type with the given /// </summary> /// <param name="clrType">The CLR type of this type</param> /// <param name="primitiveTypeKind">The primitive type kind of the primitive type</param> private PrimitiveType CreatePrimitiveType(Type clrType, PrimitiveTypeKind primitiveTypeKind) { // Figures out the base type PrimitiveType baseType = MetadataItem.EdmProviderManifest.GetPrimitiveType(primitiveTypeKind); PrimitiveType primitiveType = new PrimitiveType(clrType, baseType, this); primitiveType.SetReadOnly(); return primitiveType; }
/// <summary> /// Returns the list of super-types for the given primitiveType /// </summary> /// <param name="primitiveType"></param> /// <returns></returns> internal System.Collections.ObjectModel.ReadOnlyCollection<PrimitiveType> GetPromotionTypes(PrimitiveType primitiveType) { InitializePromotableTypes(); return _promotionTypes[(int)primitiveType.PrimitiveTypeKind]; }
private static object GetSpatialValueFromProviderValue(object spatialValue, PrimitiveType parameterType, EntityConnection connection) { DbProviderServices providerServices = DbProviderServices.GetProviderServices(connection.StoreConnection); StoreItemCollection storeItemCollection = (StoreItemCollection)connection.GetMetadataWorkspace().GetItemCollection(DataSpace.SSpace); DbSpatialServices spatialServices = providerServices.GetSpatialServices(storeItemCollection.StoreProviderManifestToken); if (Helper.IsGeographicType(parameterType)) { return spatialServices.GeographyFromProviderValue(spatialValue); } else { Debug.Assert(Helper.IsGeometricType(parameterType)); return spatialServices.GeometryFromProviderValue(spatialValue); } }
internal static bool TryGetDbTypeFromPrimitiveType(PrimitiveType type, out DbType dbType) { switch (type.PrimitiveTypeKind) { case PrimitiveTypeKind.Binary: dbType = DbType.Binary; return true; case PrimitiveTypeKind.Boolean: dbType = DbType.Boolean; return true; case PrimitiveTypeKind.Byte: dbType = DbType.Byte; return true; case PrimitiveTypeKind.DateTime: dbType = DbType.DateTime; return true; case PrimitiveTypeKind.Time: dbType = DbType.Time; return true; case PrimitiveTypeKind.DateTimeOffset: dbType = DbType.DateTimeOffset; return true; case PrimitiveTypeKind.Decimal: dbType = DbType.Decimal; return true; case PrimitiveTypeKind.Double: dbType = DbType.Double; return true; case PrimitiveTypeKind.Guid: dbType = DbType.Guid; return true; case PrimitiveTypeKind.Single: dbType = DbType.Single; return true; case PrimitiveTypeKind.SByte: dbType = DbType.SByte; return true; case PrimitiveTypeKind.Int16: dbType = DbType.Int16; return true; case PrimitiveTypeKind.Int32: dbType = DbType.Int32; return true; case PrimitiveTypeKind.Int64: dbType = DbType.Int64; return true; case PrimitiveTypeKind.String: dbType = DbType.String; return true; default: dbType = default(DbType); return false; } }
/// <summary> /// Initializes a new instance of the EnumType class. This default constructor is used for bootstraping /// </summary> internal EnumType() { _underlyingType = PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32); _isFlags = false; }
/// <summary> /// Construct an internal (not from schema) CDM scalar type /// </summary> /// <param name="parentElement">the owning schema</param> /// <param name="typeName">the naem of the type</param> /// <param name="primitiveType">the PrimitiveTypeKind of the type</param> internal ScalarType(Schema parentElement, string typeName, PrimitiveType primitiveType) : base(parentElement) { Name = typeName; _primitiveType = primitiveType; }
/// <summary> /// Returns the list of common super types of two primitive types. /// </summary> /// <param name="primitiveType1"></param> /// <param name="primitiveType2"></param> /// <returns></returns> private static objectModel.ReadOnlyCollection<PrimitiveType> GetPrimitiveCommonSuperTypes(PrimitiveType primitiveType1, PrimitiveType primitiveType2) { ComputeCommonTypeClosure(); return _commonTypeClosure[(int)primitiveType1.PrimitiveTypeKind, (int)primitiveType2.PrimitiveTypeKind]; }
// Find "sanctioned" default value private static void GetPropagatorResultForPrimitiveType(PrimitiveType primitiveType, out PropagatorResult result) { object value; PrimitiveTypeKind primitiveTypeKind = primitiveType.PrimitiveTypeKind; if (!s_typeDefaultMap.TryGetValue(primitiveTypeKind, out value)) { // If none exists, default to lowest common denominator for constants value = default(byte); } // Return a new constant expression flagged as unknown since the value is only there for // show. (Not entirely for show, because null constraints may require a value for a record, // whether that record is a placeholder or not). result = PropagatorResult.CreateSimpleValue(PropagatorFlags.NoFlags, value); }
private static bool TryGetCommonType(PrimitiveType primitiveType1, PrimitiveType primitiveType2, out EdmType commonType) { commonType = null; if (IsSubTypeOf(primitiveType1, primitiveType2)) { commonType = primitiveType2; return true; } if (IsSubTypeOf(primitiveType2, primitiveType1)) { commonType = primitiveType1; return true; } objectModel.ReadOnlyCollection<PrimitiveType> superTypes = GetPrimitiveCommonSuperTypes(primitiveType1, primitiveType2); if (superTypes.Count > 0) { commonType = superTypes[0]; return true; } return false; }
/// <summary> /// Validate an GetPrimitiveType object /// </summary> /// <param name="item">The GetPrimitiveType object to validate</param> /// <param name="errors">An error collection for adding validation errors</param> /// <param name="validatedItems">A dictionary keeping track of items that have been validated</param> private void ValidatePrimitiveType(PrimitiveType item, List <EdmItemError> errors, HashSet <MetadataItem> validatedItems) { ValidateSimpleType(item, errors, validatedItems); }