// <summary>
// Look up a type in the target data space based upon the fullName
// </summary>
// <param name="fullName"> fullName </param>
// <param name="ignoreCase"> true for case-insensitive lookup </param>
// <param name="typeUsage"> The type usage object to return </param>
// <returns> True if the retrieval succeeded </returns>
internal override bool TryGetTypeByName(string fullName, bool ignoreCase, out TypeUsage typeUsage)
{
typeUsage = null;
Map map = null;
// From ClrPerspective, we should not allow anything from SSpace. So make sure that the CSpace type does not
// have the Target attribute
if (MetadataWorkspace.TryGetMap(fullName, DataSpace.OSpace, ignoreCase, DataSpace.OCSpace, out map))
{
// Check if it's primitive type, if so, then use the MetadataWorkspace to get the mapped primitive type
if (map.EdmItem.BuiltInTypeKind
== BuiltInTypeKind.PrimitiveType)
{
// Reassign the variable with the provider primitive type, then create the type usage
var primitiveType = MetadataWorkspace.GetMappedPrimitiveType(
((PrimitiveType)map.EdmItem).PrimitiveTypeKind, DataSpace.CSpace);
if (primitiveType != null)
{
typeUsage = EdmProviderManifest.Instance.GetCanonicalModelTypeUsage(primitiveType.PrimitiveTypeKind);
}
}
else
{
Debug.Assert(((GlobalItem)map.EdmItem).DataSpace == DataSpace.CSpace);
typeUsage = GetMappedTypeUsage(map);
}
}
return(null != typeUsage);
}
/// <summary>
/// Retrieves a mapping to CLR type for the given EDM type. Assumes the MetadataWorkspace has no
/// </summary>
internal static ObjectTypeMapping GetObjectMapping(EdmType type, MetadataWorkspace workspace)
{
// Check if the workspace has cspace item collection registered with it. If not, then its a case
// of public materializer trying to create objects from PODR or EntityDataReader with no context.
ItemCollection collection;
if (workspace.TryGetItemCollection(DataSpace.CSpace, out collection))
{
return (ObjectTypeMapping)workspace.GetMap(type, DataSpace.OCSpace);
}
else
{
EdmType ospaceType;
EdmType cspaceType;
// If its a case of EntityDataReader with no context, the typeUsage which is passed in must contain
// a cspace type. We need to look up an OSpace type in the ospace item collection and then create
// ocMapping
if (type.DataSpace == DataSpace.CSpace)
{
// if its a primitive type, then the names will be different for CSpace type and OSpace type
if (Helper.IsPrimitiveType(type))
{
ospaceType = workspace.GetMappedPrimitiveType(((PrimitiveType)type).PrimitiveTypeKind, DataSpace.OSpace);
}
else
{
// Metadata will throw if there is no item with this identity present.
// Is this exception fine or does object materializer code wants to wrap and throw a new exception
ospaceType = workspace.GetItem<EdmType>(type.FullName, DataSpace.OSpace);
}
cspaceType = type;
}
else
{
// In case of PODR, there is no cspace at all. We must create a fake ocmapping, with ospace types
// on both the ends
ospaceType = type;
cspaceType = type;
}
// This condition must be hit only when someone is trying to materialize a legacy data reader and we
// don't have the CSpace metadata.
if (!Helper.IsPrimitiveType(ospaceType) && !Helper.IsEntityType(ospaceType) && !Helper.IsComplexType(ospaceType))
{
throw EntityUtil.MaterializerUnsupportedType();
}
ObjectTypeMapping typeMapping;
if (Helper.IsPrimitiveType(ospaceType))
{
typeMapping = new ObjectTypeMapping(ospaceType, cspaceType);
}
else
{
typeMapping = DefaultObjectMappingItemCollection.LoadObjectMapping(cspaceType, ospaceType, null);
}
return typeMapping;
}
}
// <summary>
// Retrieves a mapping to CLR type for the given EDM type. Assumes the MetadataWorkspace has no
// </summary>
internal static ObjectTypeMapping GetObjectMapping(EdmType type, MetadataWorkspace workspace)
{
// Check if the workspace has cspace item collection registered with it. If not, then its a case
// of public materializer trying to create objects from PODR or EntityDataReader with no context.
ItemCollection collection;
if (workspace.TryGetItemCollection(DataSpace.CSpace, out collection))
{
return((ObjectTypeMapping)workspace.GetMap(type, DataSpace.OCSpace));
}
else
{
EdmType ospaceType;
EdmType cspaceType;
// If its a case of EntityDataReader with no context, the typeUsage which is passed in must contain
// a cspace type. We need to look up an OSpace type in the ospace item collection and then create
// ocMapping
if (type.DataSpace
== DataSpace.CSpace)
{
// if its a primitive type, then the names will be different for CSpace type and OSpace type
if (Helper.IsPrimitiveType(type))
{
ospaceType = workspace.GetMappedPrimitiveType(((PrimitiveType)type).PrimitiveTypeKind, DataSpace.OSpace);
}
else
{
// Metadata will throw if there is no item with this identity present.
// Is this exception fine or does object materializer code wants to wrap and throw a new exception
ospaceType = workspace.GetItem <EdmType>(type.FullName, DataSpace.OSpace);
}
cspaceType = type;
}
else
{
// In case of PODR, there is no cspace at all. We must create a fake ocmapping, with ospace types
// on both the ends
ospaceType = type;
cspaceType = type;
}
// This condition must be hit only when someone is trying to materialize a legacy data reader and we
// don't have the CSpace metadata.
if (!Helper.IsPrimitiveType(ospaceType) &&
!Helper.IsEntityType(ospaceType) &&
!Helper.IsComplexType(ospaceType))
{
throw new NotSupportedException(Strings.Materializer_UnsupportedType);
}
ObjectTypeMapping typeMapping;
if (Helper.IsPrimitiveType(ospaceType))
{
typeMapping = new ObjectTypeMapping(ospaceType, cspaceType);
}
else
{
typeMapping = DefaultObjectMappingItemCollection.LoadObjectMapping(cspaceType, ospaceType, null);
}
return(typeMapping);
}
}
// <summary>
// returns the primitive type for a given primitive type kind.
// </summary>
internal virtual bool TryGetMappedPrimitiveType(PrimitiveTypeKind primitiveTypeKind, out PrimitiveType primitiveType)
{
primitiveType = _metadataWorkspace.GetMappedPrimitiveType(primitiveTypeKind, DataSpace.CSpace);
return(null != primitiveType);
}
internal static ObjectTypeMapping GetObjectMapping(
EdmType type,
MetadataWorkspace workspace)
{
ItemCollection collection;
if (workspace.TryGetItemCollection(DataSpace.CSpace, out collection))
{
return((ObjectTypeMapping)workspace.GetMap((GlobalItem)type, DataSpace.OCSpace));
}
EdmType edmType;
EdmType cdmType;
if (type.DataSpace == DataSpace.CSpace)
{
edmType = !Helper.IsPrimitiveType(type) ? workspace.GetItem <EdmType>(type.FullName, DataSpace.OSpace) : (EdmType)workspace.GetMappedPrimitiveType(((PrimitiveType)type).PrimitiveTypeKind, DataSpace.OSpace);
cdmType = type;
}
else
{
edmType = type;
cdmType = type;
}
if (!Helper.IsPrimitiveType(edmType) && !Helper.IsEntityType(edmType) && !Helper.IsComplexType(edmType))
{
throw new NotSupportedException(Strings.Materializer_UnsupportedType);
}
return(!Helper.IsPrimitiveType(edmType) ? DefaultObjectMappingItemCollection.LoadObjectMapping(cdmType, edmType, (DefaultObjectMappingItemCollection)null) : new ObjectTypeMapping(edmType, cdmType));
}
