Imported Upstream version 4.6.0.125

Former-commit-id: a2155e9bd80020e49e72e86c44da02a8ac0e57a4

mcs/class/referencesource/System.Data.Entity.Design/System/Data/EntityModel/Emitters/Utils.cs

@@ -0,0 +1,371 @@
+//---------------------------------------------------------------------
+// <copyright file="Utils.cs" company="Microsoft">
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+// </copyright>
+//
+// @owner       [....]
+// @backupOwner [....]
+//---------------------------------------------------------------------
+
+using System;
+using System.Collections.Specialized;
+using System.Collections.Generic;
+using System.Text;
+using System.Data;
+using System.Data.Metadata.Edm;
+using System.Data.EntityModel.SchemaObjectModel;
+using System.Data.Entity.Design.Common;
+using System.Diagnostics;
+using System.Reflection;
+
+
+namespace System.Data.EntityModel.Emitters
+{
+    /// <summary>
+    /// Summary description for Utils
+    /// </summary>
+    internal static class Utils
+    {
+        #region Static Fields
+
+        public const string AdoFrameworkNamespace = "System.Data.Objects";
+        public const string AdoFrameworkDataClassesNamespace = "System.Data.Objects.DataClasses";
+        public const string AdoFrameworkMetadataEdmNamespace = "System.Data.Metadata.Edm";
+        public const string AdoEntityClientNamespace = "System.Data.EntityClient";
+
+        public const string SetValidValueMethodName = "SetValidValue";
+        public const string ReportPropertyChangingMethodName = "ReportPropertyChanging";
+        public const string ReportPropertyChangedMethodName = "ReportPropertyChanged";
+        public const string GetValidValueMethodName = "GetValidValue";
+        public const string VerifyComplexObjectIsNotNullName = "VerifyComplexObjectIsNotNull";
+
+
+        // to guarantee uniqueness these must all be unique, begin with and end with an underscore and not contain internal underscores
+        private static string[] _privateMemberPrefixes = new string[(int)PrivateMemberPrefixId.Count]
+        {
+            "_",
+            "_Initialize_",
+            "PropertyInfo",
+            "_pi",
+        };
+
+        // suffix that is added to field names to create a boolean field used to indicate whether or
+        // not a complex property has been explicitly initialized 
+        private static string _complexPropertyInitializedSuffix = "Initialized";
+        private static List<KeyValuePair<string, Type>> _typeReservedNames = InitializeTypeReservedNames();
+
+        /// <summary>
+        /// Initialize some statics that cannot be initialized in member declaration...
+        /// </summary>
+        static List<KeyValuePair<string, Type>> InitializeTypeReservedNames()
+        {
+            Dictionary<string, Type> typeReservedNames = new Dictionary<string, Type>(StringComparer.Ordinal);
+            BindingFlags bindingFlags = BindingFlags.FlattenHierarchy | BindingFlags.NonPublic | BindingFlags.Public 
+                    | BindingFlags.Instance | BindingFlags.Static;
+            foreach (MemberInfo member in TypeReference.ComplexTypeBaseClassType.GetMembers(bindingFlags))
+            {
+                if (ShouldReserveName(member))
+                {
+                    if (!typeReservedNames.ContainsKey(member.Name))
+                    {
+                        typeReservedNames.Add(member.Name, typeof(ComplexType));
+                    }
+                }
+            }
+
+            foreach (MemberInfo member in TypeReference.EntityTypeBaseClassType.GetMembers(bindingFlags))
+            {
+                if (ShouldReserveName(member))
+                {
+                    if (typeReservedNames.ContainsKey(member.Name))
+                    {
+                        if (typeReservedNames[member.Name] == typeof(ComplexType))
+                        {
+                            // apply to all types
+                            typeReservedNames[member.Name] = null;
+                        }
+                    }
+                    else
+                    {
+                        typeReservedNames.Add(member.Name, typeof(EntityType));
+                    }
+                }
+            }
+
+            List<KeyValuePair<string, Type>> pairs = new List<KeyValuePair<string, Type>>();
+            foreach (KeyValuePair<string, Type> pair in typeReservedNames)
+            {
+                pairs.Add(pair);
+            }
+
+            return pairs;
+        }
+
+        private static bool ShouldReserveName(MemberInfo member)
+        {
+            if (member is EventInfo)
+            {
+                return ShouldReserveName((EventInfo)member);
+            }
+            else if(member is FieldInfo)
+            {
+                return ShouldReserveName((FieldInfo)member);
+            }
+            else if(member is MethodBase)
+            {
+                return ShouldReserveName((MethodBase)member);
+            }
+            else if(member is PropertyInfo)
+            {
+                return ShouldReserveName((PropertyInfo)member);
+            }
+            else
+            {
+                Debug.Assert(member is Type, "Did you add a new type of member?");
+                return ShouldReserveName((Type)member);
+            }
+
+        }
+
+        private static bool ShouldReserveName(EventInfo member)
+        {
+            bool hasNonPrivate = false;
+
+            MethodInfo miAdd = member.GetAddMethod();
+            if (miAdd != null)
+            {
+                hasNonPrivate |= ShouldReserveName(miAdd, false);
+            }
+
+            MethodInfo miRemove = member.GetRemoveMethod();
+            if (miRemove != null)
+            {
+                hasNonPrivate |= ShouldReserveName(miRemove, false);
+            }
+
+            return hasNonPrivate;
+        }
+
+        private static bool ShouldReserveName(PropertyInfo member)
+        {
+            bool hasNonPrivate = false;
+
+            MethodInfo miSet = member.GetSetMethod();
+            if (miSet != null)
+            {
+                hasNonPrivate |= ShouldReserveName(miSet, false);
+            }
+
+            MethodInfo miGet = member.GetGetMethod();
+            if (miGet != null)
+            {
+                hasNonPrivate |= ShouldReserveName(miGet, false);
+            }
+
+            return hasNonPrivate;
+        }
+
+        private static bool ShouldReserveName(FieldInfo member)
+        {
+            return !member.IsPrivate && !member.IsAssembly && 
+                !member.IsSpecialName;
+        }
+
+        private static bool ShouldReserveName(MethodBase member, bool checkForSpecial)
+        {
+            return !member.IsPrivate && !member.IsAssembly &&
+                (!checkForSpecial || !member.IsSpecialName);
+        }
+
+        private static bool ShouldReserveName(MethodBase member)
+        {
+            return ShouldReserveName(member, true);
+        }
+
+        private static bool ShouldReserveName(Type member)
+        {
+            // we don't want to keep types
+            return false;
+        }
+        #endregion
+
+        #region Public Methods
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="text"></param>
+        /// <returns></returns>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Globalization", "CA1308:NormalizeStringsToUppercase")]
+        public static string CamelCase(string text)
+        {
+            if ( string.IsNullOrEmpty(text) )
+                return text;
+
+            if ( text.Length == 1 )
+                return text[0].ToString(System.Globalization.CultureInfo.InvariantCulture).ToLowerInvariant();
+
+            return text[0].ToString(System.Globalization.CultureInfo.InvariantCulture).ToLowerInvariant()+text.Substring(1);
+        }
+
+        public static string FixParameterName(string name)
+        {
+            // FxCop consider 'iD' as violation, we will change any property that is 'id'(case insensitive) to 'ID'
+            if (StringComparer.OrdinalIgnoreCase.Equals(name, "id"))
+            {
+                // it is an abreviation not an acronym so it should be all lower case
+                return "id";
+            }
+            return CamelCase(name);
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="propName"></param>
+        /// <returns></returns>
+        public static string FieldNameFromPropName(string propName)
+        {
+            return PrivateMemberPrefix(PrivateMemberPrefixId.Field)+propName;
+        }
+
+        /// <summary>
+        /// Generate the name of a field that is used to indicate whether a complex property has been explicitly initialized
+        /// </summary>
+        /// <param name="propName">Name of the property associated that with this field</param>
+        /// <returns>Generated field name</returns>
+        public static string ComplexPropertyInitializedNameFromPropName(string propName)
+        {
+            return FieldNameFromPropName(propName) + _complexPropertyInitializedSuffix;
+        }
+        
+        /// <summary>
+        /// get the prefix ussed for a private member
+        /// </summary>
+        /// <param name="id"></param>
+        /// <returns></returns>
+        public static string PrivateMemberPrefix(PrivateMemberPrefixId id)
+        {
+            return _privateMemberPrefixes[(int)id];
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="name"></param>
+        /// <returns></returns>
+        public static string FQAdoFrameworkName( string name )
+        {
+            return AdoFrameworkNamespace + "." + name;
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="name"></param>
+        /// <returns></returns>
+        public static string FQAdoFrameworkDataClassesName( string name )
+        {
+            return AdoFrameworkDataClassesNamespace + "." + name;
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="name">unqualifed name of the type</param>
+        /// <returns></returns>
+        public static string FQAdoFrameworkMetadataEdmName(string name)
+        {
+            return AdoFrameworkMetadataEdmNamespace + "." + name;
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="name"></param>
+        /// <returns></returns>
+        public static string FQAdoEntityClientName(string name)
+        {
+            return AdoEntityClientNamespace + "." + name;
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="element"></param>
+        /// <param name="modelType"></param>
+        /// <returns></returns>
+        public static bool TryGetPrimitiveTypeKind(EdmType type, out PrimitiveTypeKind modelType )
+        {
+            if (!MetadataUtil.IsPrimitiveType(type))
+            {
+                // set it to something bogus because I have to
+                modelType = PrimitiveTypeKind.Binary;
+                return false;
+            }
+
+            modelType = ((PrimitiveType)type).PrimitiveTypeKind;
+            return true;
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="name"></param>
+        /// <returns></returns>
+        public static string[] SplitName(string name)
+        {
+            Debug.Assert(!string.IsNullOrEmpty(name), "name parameter is null or empty");
+
+            if ( name.Length > 0 && name[0] == '.' )
+                return name.Substring(1).Split('.');
+
+            return name.Split('.');
+        }
+
+        public static string GetFullyQualifiedCodeGenerationAttributeName(string attribute)
+        {
+            return XmlConstants.CodeGenerationSchemaNamespace + ":" + attribute;
+        }
+
+        /// <summary>
+        /// check if a name is reserved for a type
+        /// </summary>
+        /// <param name="type">the object representing the schema type being defined</param>
+        /// <param name="name">the member name</param>
+        /// <returns>true if the name is reserved by the type</returns>
+        public static bool DoesTypeReserveMemberName(StructuralType type, string name, StringComparison comparison)
+        {
+            Type reservingType = null;
+            if (!TryGetReservedName(name,comparison, out reservingType))
+            {
+                return false;
+            }
+
+            // if reserving types is null it means the name is reserved for all types.
+            if (reservingType == null)
+            {
+                return true;
+            }
+
+            return (reservingType == type.GetType());
+        }
+
+        public static bool TryGetReservedName(string name, StringComparison comparison, out Type applyToSpecificType)
+        {
+            applyToSpecificType = null;
+            foreach(KeyValuePair<string, Type> pair in _typeReservedNames)
+            {
+                if (pair.Key.Equals(name, comparison))
+                {
+                    applyToSpecificType = pair.Value;
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+
+        #endregion
+    }
+}