Imported Upstream version 4.6.0.125

Former-commit-id: a2155e9bd80020e49e72e86c44da02a8ac0e57a4

mcs/class/referencesource/System.Data.Entity/System/Data/Metadata/Perspective.cs

@@ -0,0 +1,229 @@
+//---------------------------------------------------------------------
+// <copyright file="Perspective.cs" company="Microsoft">
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+// </copyright>
+//
+// @owner       [....]
+// @backupOwner [....]
+//---------------------------------------------------------------------
+using System.Diagnostics;
+using System.Linq;
+
+namespace System.Data.Metadata.Edm
+{
+    using System.Collections.Generic;
+
+    /// <summary>
+    /// Internal helper class for query
+    /// </summary>
+    internal abstract class Perspective
+    {
+        #region Constructors
+        /// <summary>
+        /// Creates a new instance of perspective class so that query can work
+        /// ignorant of all spaces
+        /// </summary>
+        /// <param name="metadataWorkspace">runtime metadata container</param>
+        /// <param name="targetDataspace">target dataspace for the perspective</param>
+        internal Perspective(MetadataWorkspace metadataWorkspace,
+                             DataSpace targetDataspace)
+        {
+            EntityUtil.CheckArgumentNull(metadataWorkspace, "metadataWorkspace");
+
+            m_metadataWorkspace = metadataWorkspace;
+            m_targetDataspace = targetDataspace;
+        }
+        #endregion
+
+        #region Fields
+        private MetadataWorkspace m_metadataWorkspace;
+        private DataSpace m_targetDataspace;
+        #endregion
+
+        #region Methods
+
+        /// <summary>
+        /// Given the type in the target space and the member name in the source space,
+        /// get the corresponding member in the target space
+        /// For e.g.  consider a Conceptual Type 'Foo' with a member 'Bar' and a CLR type
+        /// 'XFoo' with a member 'YBar'. If one has a reference to Foo one can
+        /// invoke GetMember(Foo,"YBar") to retrieve the member metadata for bar
+        /// </summary>
+        /// <param name="type">The type in the target perspective</param>
+        /// <param name="memberName">the name of the member in the source perspective</param>
+        /// <param name="ignoreCase">Whether to do case-sensitive member look up or not</param>
+        /// <param name="outMember">returns the member in target space, if a match is found</param>
+        internal virtual bool TryGetMember(StructuralType type, String memberName, bool ignoreCase, out EdmMember outMember)
+        {
+            EntityUtil.CheckArgumentNull(type, "type");
+            EntityUtil.CheckStringArgument(memberName, "memberName");
+            outMember = null;
+            return type.Members.TryGetValue(memberName, ignoreCase, out outMember);
+        }
+        internal bool TryGetEnumMember(EnumType type, String memberName, bool ignoreCase, out EnumMember outMember)
+        {
+            EntityUtil.CheckArgumentNull(type, "type");
+            EntityUtil.CheckStringArgument(memberName, "memberName");
+            outMember = null;
+            return type.Members.TryGetValue(memberName, ignoreCase, out outMember);
+        }
+
+        /// <summary>
+        /// Returns the extent in the target space, for the given entity container.
+        /// </summary>
+        /// <param name="entityContainer">name of the entity container in target space</param>
+        /// <param name="extentName">name of the extent</param>
+        /// <param name="ignoreCase">Whether to do case-sensitive member look up or not</param>
+        /// <param name="outSet">extent in target space, if a match is found</param>
+        /// <returns>returns true, if a match is found otherwise returns false</returns>
+        internal bool TryGetExtent(EntityContainer entityContainer, String extentName, bool ignoreCase, out EntitySetBase outSet)
+        {
+            // There are no entity containers in the OSpace. So there is no mapping involved.
+            // Hence the name should be a valid name in the CSpace.
+            return entityContainer.BaseEntitySets.TryGetValue(extentName, ignoreCase, out outSet);
+        }
+
+        /// <summary>
+        /// Returns the function import in the target space, for the given entity container.
+        /// </summary>
+        internal bool TryGetFunctionImport(EntityContainer entityContainer, String functionImportName, bool ignoreCase, out EdmFunction functionImport)
+        {
+            // There are no entity containers in the OSpace. So there is no mapping involved.
+            // Hence the name should be a valid name in the CSpace.
+            functionImport = null;
+            if (ignoreCase)
+            {
+                functionImport = entityContainer.FunctionImports.Where(fi => String.Equals(fi.Name, functionImportName, StringComparison.OrdinalIgnoreCase)).SingleOrDefault();
+            }
+            else
+            {
+                functionImport = entityContainer.FunctionImports.Where(fi => fi.Name == functionImportName).SingleOrDefault();
+            }
+            return functionImport != null;
+        }
+
+        /// <summary>
+        /// Get the default entity container
+        /// returns null for any perspective other 
+        /// than the CLR perspective
+        /// </summary>
+        /// <returns>The default container</returns>
+        internal virtual EntityContainer GetDefaultContainer()
+        {
+            return null;
+        }
+
+        /// <summary>
+        /// Get an entity container based upon the strong name of the container
+        /// If no entity container is found, returns null, else returns the first one/// </summary>
+        /// <param name="name">name of the entity container</param>
+        /// <param name="ignoreCase">true for case-insensitive lookup</param>
+        /// <param name="entityContainer">returns the entity container if a match is found</param>
+        /// <returns>returns true if a match is found, otherwise false</returns>
+        internal virtual bool TryGetEntityContainer(string name, bool ignoreCase, out EntityContainer entityContainer)
+        {
+            return MetadataWorkspace.TryGetEntityContainer(name, ignoreCase, TargetDataspace, out entityContainer);
+        }
+
+        /// <summary>
+        /// Gets a type with the given name in the target space.
+        /// </summary>
+        /// <param name="fullName">full name of the type</param>
+        /// <param name="ignoreCase">true for case-insensitive lookup</param>
+        /// <param name="typeUsage">TypeUsage for the type</param>
+        /// <returns>returns true if a match was found, otherwise false</returns>
+        internal abstract bool TryGetTypeByName(string fullName, bool ignoreCase, out TypeUsage typeUsage);
+
+        /// <summary>
+        /// Returns overloads of a function with the given name in the target space.
+        /// </summary>
+        /// <param name="namespaceName">namespace of the function</param>
+        /// <param name="functionName">name of the function</param>
+        /// <param name="ignoreCase">true for case-insensitive lookup</param>
+        /// <param name="functionOverloads">function overloads</param>
+        /// <returns>returns true if a match was found, otherwise false</returns>
+        internal bool TryGetFunctionByName(string namespaceName, string functionName, bool ignoreCase, out IList<EdmFunction> functionOverloads)
+        {
+            EntityUtil.CheckStringArgument(namespaceName, "namespaceName");
+            EntityUtil.CheckStringArgument(functionName, "functionName");
+
+            var fullName = namespaceName + "." + functionName;
+
+            // First look for a model-defined function in the target space.
+            ItemCollection itemCollection = m_metadataWorkspace.GetItemCollection(m_targetDataspace);
+            IList<EdmFunction> overloads =
+                m_targetDataspace == DataSpace.SSpace ?
+                ((StoreItemCollection)itemCollection).GetCTypeFunctions(fullName, ignoreCase) :
+                itemCollection.GetFunctions(fullName, ignoreCase);
+
+            if (m_targetDataspace == DataSpace.CSpace)
+            {
+                // Then look for a function import.
+                if (overloads == null || overloads.Count == 0)
+                {
+                    EntityContainer entityContainer;
+                    if (this.TryGetEntityContainer(namespaceName, /*ignoreCase:*/ false, out entityContainer))
+                    {
+                        EdmFunction functionImport;
+                        if (this.TryGetFunctionImport(entityContainer, functionName, /*ignoreCase:*/ false, out functionImport))
+                        {
+                            overloads = new EdmFunction[] { functionImport };
+                        }
+                    }
+                }
+
+                // Last, look in SSpace.
+                if (overloads == null || overloads.Count == 0)
+                {
+                    ItemCollection storeItemCollection;
+                    if (m_metadataWorkspace.TryGetItemCollection(DataSpace.SSpace, out storeItemCollection))
+                    {
+                        overloads = ((StoreItemCollection)storeItemCollection).GetCTypeFunctions(fullName, ignoreCase);
+                    }
+                }
+            }
+
+            functionOverloads = (overloads != null && overloads.Count > 0) ? overloads : null;
+            return functionOverloads != null;
+        }
+
+        /// <summary>
+        /// Return the metadata workspace
+        /// </summary>
+        internal MetadataWorkspace MetadataWorkspace
+        {
+            get
+            {
+                return m_metadataWorkspace;
+            }
+        }
+
+        /// <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);
+        }
+
+        //
+        // This property will be needed to construct keys for transient types
+        //
+        /// <summary>
+        /// Returns the target dataspace for this perspective
+        /// </summary>
+        internal DataSpace TargetDataspace
+        {
+            get
+            {
+                return m_targetDataspace;
+            }
+        }
+        #endregion
+    }
+}