// <summary>
        // Search for a Mapping metadata with the specified type key.
        // </summary>
        // <returns> Returns false if no match found. </returns>
        internal override bool TryGetMap(GlobalItem item, out MappingBase map)
        {
            if (item == null)
            {
                map = null;
                return(false);
            }

            var typeSpace = item.DataSpace;

            //For transient types just create a map on fly and return
            var edmType = item as EdmType;

            if (edmType != null)
            {
                if (Helper.IsTransientType(edmType))
                {
                    map = GetOCMapForTransientType(edmType, typeSpace);
                    if (map != null)
                    {
                        return(true);
                    }
                    else
                    {
                        return(false);
                    }
                }
            }
            return(TryGetMap(item.Identity, typeSpace, out map));
        }
예제 #2
0
 internal virtual bool TryGetMap(
     string identity,
     DataSpace typeSpace,
     bool ignoreCase,
     out MappingBase map)
 {
     throw Error.NotSupported();
 }
예제 #3
0
        internal override bool TryGetMap(GlobalItem item, out MappingBase map)
        {
            if (item == null)
            {
                map = (MappingBase)null;
                return(false);
            }
            DataSpace dataSpace = item.DataSpace;
            EdmType   edmType   = item as EdmType;

            if (edmType == null || !Helper.IsTransientType(edmType))
            {
                return(this.TryGetMap(item.Identity, dataSpace, out map));
            }
            map = this.GetOCMapForTransientType(edmType, dataSpace);
            return(map != null);
        }
 // <summary>
 // Search for a Mapping metadata with the specified type key.
 // </summary>
 // <param name="identity"> identity of the type </param>
 // <param name="typeSpace"> The dataspace that the type for which map needs to be returned belongs to </param>
 // <returns> Returns false if no match found. </returns>
 internal override bool TryGetMap(string identity, DataSpace typeSpace, out MappingBase map)
 {
     return(TryGetMap(identity, typeSpace, false /*ignoreCase*/, out map));
 }
 // <summary>
 // Search for a Mapping metadata with the specified type key.
 // </summary>
 // <returns> Returns false if no match found. </returns>
 internal override bool TryGetMap(GlobalItem item, out MappingBase map)
 {
     if (item == null)
     {
         map = null;
         return false;
     }
     var typeSpace = item.DataSpace;
     if (typeSpace != DataSpace.CSpace)
     {
         map = null;
         return false;
     }
     return TryGetMap(item.Identity, typeSpace, out map);
 }
 // <summary>
 // Search for a Mapping metadata with the specified type key.
 // </summary>
 // <param name="identity"> identity of the type </param>
 // <param name="typeSpace"> The dataspace that the type for which map needs to be returned belongs to </param>
 // <returns> Returns false if no match found. </returns>
 internal override bool TryGetMap(string identity, DataSpace typeSpace, out MappingBase map)
 {
     return TryGetMap(identity, typeSpace, false /*ignoreCase*/, out map);
 }
 // <summary>
 // Search for a Mapping metadata with the specified type key.
 // </summary>
 // <param name="identity"> identity of the type </param>
 // <param name="typeSpace"> The dataspace that the type for which map needs to be returned belongs to </param>
 // <param name="ignoreCase"> true for case-insensitive lookup </param>
 // <returns> Returns false if no match found. </returns>
 internal override bool TryGetMap(string identity, DataSpace typeSpace, bool ignoreCase, out MappingBase map)
 {
     if (typeSpace != DataSpace.CSpace)
     {
         throw new InvalidOperationException(Strings.Mapping_Storage_InvalidSpace(typeSpace));
     }
     return TryGetItem(identity, ignoreCase, out map);
 }
 // Add to the cache. If it is already present, then throw an exception
 private void AddInternal(MappingBase storageMap)
 {
     storageMap.DataSpace = DataSpace.CSSpace;
     try
     {
         base.AddInternal(storageMap);
     }
     catch (ArgumentException e)
     {
         throw new MappingException(Strings.Mapping_Duplicate_Type(storageMap.EdmItem.Identity), e);
     }
 }
예제 #9
0
 // <summary>
 // Search for a Mapping metadata with the specified type key.
 // </summary>
 // <param name="identity"> identity of the type </param>
 // <param name="typeSpace"> The dataspace that the type for which map needs to be returned belongs to </param>
 // <param name="ignoreCase"> true for case-insensitive lookup </param>
 // <returns> Returns false if no match found. </returns>
 internal virtual bool TryGetMap(string identity, DataSpace typeSpace, bool ignoreCase, out MappingBase map)
 {
     //will only be implemented by Mapping Item Collections
     throw Error.NotSupported();
 }
예제 #10
0
        internal override bool TryGetMap(
            string identity,
            DataSpace typeSpace,
            bool ignoreCase,
            out MappingBase map)
        {
            EdmType edmType1 = (EdmType)null;
            EdmType edmType2 = (EdmType)null;

            switch (typeSpace)
            {
            case DataSpace.OSpace:
                if (ignoreCase)
                {
                    if (!this._objectCollection.TryGetItem <EdmType>(identity, true, out edmType2))
                    {
                        map = (MappingBase)null;
                        return(false);
                    }
                    identity = edmType2.Identity;
                }
                int index1;
                if (this._clrTypeIndexes.TryGetValue(identity, out index1))
                {
                    map = (MappingBase)this[index1];
                    return(true);
                }
                if (edmType2 != null || this._objectCollection.TryGetItem <EdmType>(identity, ignoreCase, out edmType2))
                {
                    this._edmCollection.TryGetItem <EdmType>(ObjectItemCollection.TryGetMappingCSpaceTypeIdentity(edmType2), out edmType1);
                    break;
                }
                break;

            case DataSpace.CSpace:
                if (ignoreCase)
                {
                    if (!this._edmCollection.TryGetItem <EdmType>(identity, true, out edmType1))
                    {
                        map = (MappingBase)null;
                        return(false);
                    }
                    identity = edmType1.Identity;
                }
                int index2;
                if (this._edmTypeIndexes.TryGetValue(identity, out index2))
                {
                    map = (MappingBase)this[index2];
                    return(true);
                }
                if (edmType1 != null || this._edmCollection.TryGetItem <EdmType>(identity, ignoreCase, out edmType1))
                {
                    this._objectCollection.TryGetOSpaceType(edmType1, out edmType2);
                    break;
                }
                break;
            }
            if (edmType2 == null || edmType1 == null)
            {
                map = (MappingBase)null;
                return(false);
            }
            map = this.GetDefaultMapping(edmType1, edmType2);
            return(true);
        }
예제 #11
0
 internal override bool TryGetMap(string identity, DataSpace typeSpace, out MappingBase map)
 {
     return(this.TryGetMap(identity, typeSpace, false, out map));
 }
        // <summary>
        // Search for a Mapping metadata with the specified type key.
        // </summary>
        // <param name="identity"> identity of the type </param>
        // <param name="typeSpace"> The dataspace that the type for which map needs to be returned belongs to </param>
        // <param name="ignoreCase"> true for case-insensitive lookup </param>
        // <returns> Returns false if no match found. </returns>
        internal override bool TryGetMap(string identity, DataSpace typeSpace, bool ignoreCase, out MappingBase map)
        {
            EdmType cdmType = null;
            EdmType clrType = null;
            if (typeSpace == DataSpace.CSpace)
            {
                if (ignoreCase)
                {
                    // Get the correct casing of the identity first if we are asked to do ignore case
                    if (!_edmCollection.TryGetItem(identity, true, out cdmType))
                    {
                        map = null;
                        return false;
                    }

                    identity = cdmType.Identity;
                }

                int index;
                if (_edmTypeIndexes.TryGetValue(identity, out index))
                {
                    map = (MappingBase)this[index];
                    return true;
                }

                if (cdmType != null
                    ||
                    _edmCollection.TryGetItem(identity, ignoreCase, out cdmType))
                {
                    // If the mapping is not already loaded, then get the mapping ospace type
                    _objectCollection.TryGetOSpaceType(cdmType, out clrType);
                }
            }
            else if (typeSpace == DataSpace.OSpace)
            {
                if (ignoreCase)
                {
                    // Get the correct casing of the identity first if we are asked to do ignore case
                    if (!_objectCollection.TryGetItem(identity, true, out clrType))
                    {
                        map = null;
                        return false;
                    }

                    identity = clrType.Identity;
                }

                int index;
                if (_clrTypeIndexes.TryGetValue(identity, out index))
                {
                    map = (MappingBase)this[index];
                    return true;
                }

                if (clrType != null
                    ||
                    _objectCollection.TryGetItem(identity, ignoreCase, out clrType))
                {
                    // If the mapping is not already loaded, get the mapping cspace type
                    var cspaceTypeName = ObjectItemCollection.TryGetMappingCSpaceTypeIdentity(clrType);
                    _edmCollection.TryGetItem(cspaceTypeName, out cdmType);
                }
            }

            if ((clrType == null)
                || (cdmType == null))
            {
                map = null;
                return false;
            }
            else
            {
                map = GetDefaultMapping(cdmType, clrType);
                return true;
            }
        }
        // <summary>
        // Search for a Mapping metadata with the specified type key.
        // </summary>
        // <returns> Returns false if no match found. </returns>
        internal override bool TryGetMap(GlobalItem item, out MappingBase map)
        {
            if (item == null)
            {
                map = null;
                return false;
            }

            var typeSpace = item.DataSpace;

            //For transient types just create a map on fly and return
            var edmType = item as EdmType;
            if (edmType != null)
            {
                if (Helper.IsTransientType(edmType))
                {
                    map = GetOCMapForTransientType(edmType, typeSpace);
                    if (map != null)
                    {
                        return true;
                    }
                    else
                    {
                        return false;
                    }
                }
            }
            return TryGetMap(item.Identity, typeSpace, out map);
        }
예제 #14
0
 // <summary>
 // Given a map, dereference the EdmItem, ensure that it is
 // an EdmType and return a TypeUsage for the type, otherwise
 // return null.
 // </summary>
 // <param name="map"> The OC map to use to get the EdmType </param>
 // <returns> A TypeUsage for the mapped EdmType or null if no EdmType was mapped </returns>
 private static TypeUsage GetMappedTypeUsage(MappingBase map)
 {
     TypeUsage typeUsage = null;
     if (null != map)
     {
         var item = map.EdmItem;
         var edmItem = item as EdmType;
         if (null != item
             && edmItem != null)
         {
             typeUsage = TypeUsage.Create(edmItem);
         }
     }
     return typeUsage;
 }
예제 #15
0
 // <summary>
 // Search for a Mapping metadata with the specified type key.
 // </summary>
 // <returns> Returns false if no match found. </returns>
 internal virtual bool TryGetMap(GlobalItem item, out MappingBase map)
 {
     //will only be implemented by Mapping Item Collections
     throw Error.NotSupported();
 }
        // <summary>
        // Search for a Mapping metadata with the specified type key.
        // </summary>
        // <param name="identity"> identity of the type </param>
        // <param name="typeSpace"> The dataspace that the type for which map needs to be returned belongs to </param>
        // <param name="ignoreCase"> true for case-insensitive lookup </param>
        // <returns> Returns false if no match found. </returns>
        internal override bool TryGetMap(string identity, DataSpace typeSpace, bool ignoreCase, out MappingBase map)
        {
            EdmType cdmType = null;
            EdmType clrType = null;

            if (typeSpace == DataSpace.CSpace)
            {
                if (ignoreCase)
                {
                    // Get the correct casing of the identity first if we are asked to do ignore case
                    if (!_edmCollection.TryGetItem(identity, true, out cdmType))
                    {
                        map = null;
                        return(false);
                    }

                    identity = cdmType.Identity;
                }

                int index;
                if (_edmTypeIndexes.TryGetValue(identity, out index))
                {
                    map = (MappingBase)this[index];
                    return(true);
                }

                if (cdmType != null
                    ||
                    _edmCollection.TryGetItem(identity, ignoreCase, out cdmType))
                {
                    // If the mapping is not already loaded, then get the mapping ospace type
                    _objectCollection.TryGetOSpaceType(cdmType, out clrType);
                }
            }
            else if (typeSpace == DataSpace.OSpace)
            {
                if (ignoreCase)
                {
                    // Get the correct casing of the identity first if we are asked to do ignore case
                    if (!_objectCollection.TryGetItem(identity, true, out clrType))
                    {
                        map = null;
                        return(false);
                    }

                    identity = clrType.Identity;
                }

                int index;
                if (_clrTypeIndexes.TryGetValue(identity, out index))
                {
                    map = (MappingBase)this[index];
                    return(true);
                }

                if (clrType != null
                    ||
                    _objectCollection.TryGetItem(identity, ignoreCase, out clrType))
                {
                    // If the mapping is not already loaded, get the mapping cspace type
                    var cspaceTypeName = ObjectItemCollection.TryGetMappingCSpaceTypeIdentity(clrType);
                    _edmCollection.TryGetItem(cspaceTypeName, out cdmType);
                }
            }

            if ((clrType == null) ||
                (cdmType == null))
            {
                map = null;
                return(false);
            }
            else
            {
                map = GetDefaultMapping(cdmType, clrType);
                return(true);
            }
        }
예제 #17
0
 internal virtual bool TryGetMap(GlobalItem item, out MappingBase map)
 {
     throw Error.NotSupported();
 }