private static bool IsPromotableTo(RowType fromRowType, RowType toRowType)
{
if (fromRowType.Properties.Count != toRowType.Properties.Count)
{
return(false);
}
for (int index = 0; index < fromRowType.Properties.Count; ++index)
{
if (!TypeSemantics.IsPromotableTo(fromRowType.Properties[index].TypeUsage, toRowType.Properties[index].TypeUsage))
{
return(false);
}
}
return(true);
}
private static bool TryGetCommonType(
CollectionType collectionType1,
CollectionType collectionType2,
out EdmType commonType)
{
TypeUsage commonType1 = (TypeUsage)null;
if (!TypeSemantics.TryGetCommonType(collectionType1.TypeUsage, collectionType2.TypeUsage, out commonType1))
{
commonType = (EdmType)null;
return(false);
}
commonType = (EdmType) new CollectionType(commonType1);
return(true);
}
private static bool IsEqualComparable(EdmType edmType)
{
if (Helper.IsPrimitiveType(edmType) || Helper.IsRefType((GlobalItem)edmType) || (Helper.IsEntityType(edmType) || Helper.IsEnumType(edmType)))
{
return(true);
}
if (!Helper.IsRowType((GlobalItem)edmType))
{
return(false);
}
foreach (EdmMember property in ((RowType)edmType).Properties)
{
if (!TypeSemantics.IsEqualComparable(property.TypeUsage))
{
return(false);
}
}
return(true);
}
// <summary>
// Validates whether cspace and sspace types are compatible.
// </summary>
// <param name="cspaceType"> Type in C-Space. Must be a primitive or enumeration type. </param>
// <param name="storeType"> C-Space equivalent of S-space Type. Must be a primitive type. </param>
// <returns>
// <c>true</c> if the types are compatible. <c>false</c> otherwise.
// </returns>
// <remarks>
// This methods validate whether cspace and sspace types are compatible. The types are
// compatible if:
// both are primitive and the cspace type is a subtype of sspace type
// or
// cspace type is an enumeration type whose underlying type is a subtype of sspace type.
// </remarks>
private static bool ValidateScalarTypesAreCompatible(TypeUsage cspaceType, TypeUsage storeType)
{
DebugCheck.NotNull(cspaceType);
DebugCheck.NotNull(storeType);
Debug.Assert(cspaceType.EdmType.DataSpace == DataSpace.CSpace, "cspace property must have a cspace type");
Debug.Assert(storeType.EdmType.DataSpace == DataSpace.CSpace, "storeType type usage must have a sspace type");
Debug.Assert(
IsScalarType(cspaceType.EdmType),
"cspace property must be of a primitive or enumeration type");
Debug.Assert(IsPrimitiveType(storeType.EdmType), "storeType property must be a primitive type");
if (IsEnumType(cspaceType.EdmType))
{
// For enum cspace type check whether its underlying type is a subtype of the store type. Note that
// TypeSemantics.IsSubTypeOf uses only TypeUsage.EdmType for primitive types so there is no need to copy facets
// from the enum type property to the underlying type TypeUsage created here since they wouldn't be used anyways.
return(TypeSemantics.IsSubTypeOf(TypeUsage.Create(GetUnderlyingEdmTypeForEnumType(cspaceType.EdmType)), storeType));
}
return(TypeSemantics.IsSubTypeOf(cspaceType, storeType));
}
private static bool CompareTypes(TypeUsage fromType, TypeUsage toType, bool equivalenceOnly)
{
if (object.ReferenceEquals((object)fromType, (object)toType))
{
return(true);
}
if (fromType.EdmType.BuiltInTypeKind != toType.EdmType.BuiltInTypeKind)
{
return(false);
}
if (fromType.EdmType.BuiltInTypeKind == BuiltInTypeKind.CollectionType)
{
return(TypeSemantics.CompareTypes(((CollectionType)fromType.EdmType).TypeUsage, ((CollectionType)toType.EdmType).TypeUsage, equivalenceOnly));
}
if (fromType.EdmType.BuiltInTypeKind == BuiltInTypeKind.RefType)
{
return(((RefType)fromType.EdmType).ElementType.EdmEquals((MetadataItem)((RefType)toType.EdmType).ElementType));
}
if (fromType.EdmType.BuiltInTypeKind != BuiltInTypeKind.RowType)
{
return(fromType.EdmType.EdmEquals((MetadataItem)toType.EdmType));
}
RowType edmType1 = (RowType)fromType.EdmType;
RowType edmType2 = (RowType)toType.EdmType;
if (edmType1.Properties.Count != edmType2.Properties.Count)
{
return(false);
}
for (int index = 0; index < edmType1.Properties.Count; ++index)
{
EdmProperty property1 = edmType1.Properties[index];
EdmProperty property2 = edmType2.Properties[index];
if (!equivalenceOnly && property1.Name != property2.Name || !TypeSemantics.CompareTypes(property1.TypeUsage, property2.TypeUsage, equivalenceOnly))
{
return(false);
}
}
return(true);
}
private static void ComputeCommonTypeClosure()
{
if (TypeSemantics._commonTypeClosure != null)
{
return;
}
ReadOnlyCollection <PrimitiveType>[,] readOnlyCollectionArray = new ReadOnlyCollection <PrimitiveType> [31, 31];
for (int index = 0; index < 31; ++index)
{
readOnlyCollectionArray[index, index] = Helper.EmptyPrimitiveTypeReadOnlyCollection;
}
ReadOnlyCollection <PrimitiveType> storeTypes = EdmProviderManifest.Instance.GetStoreTypes();
for (int index1 = 0; index1 < 31; ++index1)
{
for (int index2 = 0; index2 < index1; ++index2)
{
readOnlyCollectionArray[index1, index2] = TypeSemantics.Intersect((IList <PrimitiveType>)EdmProviderManifest.Instance.GetPromotionTypes(storeTypes[index1]), (IList <PrimitiveType>)EdmProviderManifest.Instance.GetPromotionTypes(storeTypes[index2]));
readOnlyCollectionArray[index2, index1] = readOnlyCollectionArray[index1, index2];
}
}
Interlocked.CompareExchange <ReadOnlyCollection <PrimitiveType> [, ]>(ref TypeSemantics._commonTypeClosure, readOnlyCollectionArray, (ReadOnlyCollection <PrimitiveType> [, ])null);
}
/// <summary>
/// Returns a Model type usage for a provider type
/// </summary>
/// <returns> model (CSpace) type usage </returns>
internal TypeUsage GetModelTypeUsage()
{
if (_modelTypeUsage == null)
{
var edmType = EdmType;
// If the edm type is already a cspace type, return the same type
if (edmType.DataSpace == DataSpace.CSpace ||
edmType.DataSpace == DataSpace.OSpace)
{
return(this);
}
TypeUsage result;
if (Helper.IsRowType(edmType))
{
var sspaceRowType = (RowType)edmType;
var properties = new EdmProperty[sspaceRowType.Properties.Count];
for (var i = 0; i < properties.Length; i++)
{
var sspaceProperty = sspaceRowType.Properties[i];
var newTypeUsage = sspaceProperty.TypeUsage.GetModelTypeUsage();
properties[i] = new EdmProperty(sspaceProperty.Name, newTypeUsage);
}
var edmRowType = new RowType(properties, sspaceRowType.InitializerMetadata);
result = Create(edmRowType, Facets);
}
else if (Helper.IsCollectionType(edmType))
{
var sspaceCollectionType = ((CollectionType)edmType);
var newTypeUsage = sspaceCollectionType.TypeUsage.GetModelTypeUsage();
result = Create(new CollectionType(newTypeUsage), Facets);
}
else if (Helper.IsRefType(edmType))
{
Debug.Assert(((RefType)edmType).ElementType.DataSpace == DataSpace.CSpace);
result = this;
}
else if (Helper.IsPrimitiveType(edmType))
{
result = ((PrimitiveType)edmType).ProviderManifest.GetEdmType(this);
if (result == null)
{
throw new ProviderIncompatibleException(Strings.Mapping_ProviderReturnsNullType(ToString()));
}
if (!TypeSemantics.IsNullable(this))
{
result = Create(
result.EdmType,
OverrideFacetValues(
result.Facets,
new FacetValues
{
Nullable = false
}));
}
}
else if (Helper.IsEntityTypeBase(edmType) ||
Helper.IsComplexType(edmType))
{
result = this;
}
else
{
Debug.Assert(false, "Unexpected type found in entity data reader");
return(null);
}
Interlocked.CompareExchange(ref _modelTypeUsage, result, null);
}
return(_modelTypeUsage);
}
private static bool IsPrimitiveTypePromotableTo(TypeUsage fromType, TypeUsage toType)
{
return(TypeSemantics.IsSubTypeOf((PrimitiveType)fromType.EdmType, (PrimitiveType)toType.EdmType));
}
internal static bool IsStructurallyEqualOrPromotableTo(EdmType fromType, EdmType toType)
{
return(TypeSemantics.IsStructurallyEqualOrPromotableTo(TypeUsage.Create(fromType), TypeUsage.Create(toType)));
}
internal static bool IsNullable(EdmMember edmMember)
{
return(TypeSemantics.IsNullable(edmMember.TypeUsage));
}
internal static bool IsOrderComparable(TypeUsage type)
{
return(TypeSemantics.IsOrderComparable(type.EdmType));
}
internal static bool IsBooleanType(TypeUsage type)
{
return(TypeSemantics.IsPrimitiveType(type, PrimitiveTypeKind.Boolean));
}
internal static bool IsStructurallyEqual(TypeUsage fromType, TypeUsage toType)
{
return(TypeSemantics.CompareTypes(fromType, toType, true));
}
internal static bool IsEqual(TypeUsage type1, TypeUsage type2)
{
return(TypeSemantics.CompareTypes(type1, type2, false));
}
internal static bool IsScalarType(TypeUsage type)
{
return(TypeSemantics.IsScalarType(type.EdmType));
}
internal static bool IsValidPolymorphicCast(EdmType fromEdmType, EdmType toEdmType)
{
return(TypeSemantics.IsValidPolymorphicCast(TypeUsage.Create(fromEdmType), TypeUsage.Create(toEdmType)));
}
