path: root/mcs/class/referencesource/System.Data.Entity/System/Data/Metadata/Helper.cs

//---------------------------------------------------------------------
// <copyright file="Helper.cs" company="Microsoft">
//      Copyright (c) Microsoft Corporation.  All rights reserved.
// </copyright>
//
// @owner       Microsoft
// @backupOwner Microsoft
//---------------------------------------------------------------------

namespace System.Data.Metadata.Edm
{
    using System.Collections;
    using System.Collections.Generic;
    using System.Diagnostics;
    using System.Linq;
    using System.Text;
    using System.Xml;
    using System.Xml.XPath;

    /// <summary>
    /// Helper Class for EDM Metadata - this class contains all the helper methods
    /// which only accesses public methods/properties. The other partial class contains all 
    /// helper methods which just uses internal methods/properties. The reason why we 
    /// did this for allowing view gen to happen at compile time - all the helper
    /// methods that view gen or mapping uses are in this class. Rest of the
    /// methods are in this class
    /// </summary>
    internal static partial class Helper
    {
        #region Fields
        internal static readonly EdmMember[] EmptyArrayEdmProperty = new EdmMember[0];

        #endregion

        #region Methods
        /// <summary>
        /// The method wraps the GetAttribute method on XPathNavigator.
        /// The problem with using the method directly is that the 
        /// Get Attribute method does not differentiate the absence of an attribute and
        /// having an attribute with Empty string value. In both cases the value returned is an empty string.
        /// So in case of optional attributes, it becomes hard to distinguish the case whether the 
        /// xml contains the attribute with empty string or doesn't contain the attribute
        /// This method will return null if the attribute is not present and otherwise will return the
        /// attribute value.
        /// </summary>
        /// <param name="nav"></param>
        /// <param name="attributeName">name of the attribute</param>
        /// <returns></returns>
        static internal string GetAttributeValue(XPathNavigator nav, 
                                                 string attributeName)
        {
            //Clone the navigator so that there wont be any sideeffects on the passed in Navigator
            nav = nav.Clone();
            string attributeValue = null;
            if (nav.MoveToAttribute(attributeName, string.Empty))
            {
                attributeValue = nav.Value;
            }
            return attributeValue;
        }

        /// <summary>
        /// The method returns typed attribute value of the specified xml attribute.
        /// The method does not do any specific casting but uses the methods on XPathNavigator.
        /// </summary>
        /// <param name="nav"></param>
        /// <param name="attributeName"></param>
        /// <param name="clrType"></param>
        /// <returns></returns>
        internal static object GetTypedAttributeValue(XPathNavigator nav, 
                                                     string attributeName,
                                                     Type clrType) 
        {
            //Clone the navigator so that there wont be any sideeffects on the passed in Navigator
            nav = nav.Clone();
            object attributeValue = null;
            if (nav.MoveToAttribute(attributeName, string.Empty))
            {
                attributeValue = nav.ValueAs(clrType);
            }
            return attributeValue;
        }
        
        /// <summary>
        /// Searches for Facet Description with the name specified. 
        /// </summary>
        /// <param name="facetCollection">Collection of facet description</param>
        /// <param name="facetName">name of the facet</param>
        /// <returns></returns>
        internal static FacetDescription GetFacet(IEnumerable<FacetDescription> facetCollection, string facetName)
        {
            foreach (FacetDescription facetDescription in facetCollection)
            {
                if (facetDescription.FacetName == facetName)
                {
                    return facetDescription;
                }
            }

            return null;
        }

        // requires: firstType is not null
        // effects: Returns true iff firstType is assignable from secondType
        internal static bool IsAssignableFrom(EdmType firstType, EdmType secondType)
        {
            Debug.Assert(firstType != null, "firstType should not be not null");
            if (secondType == null)
            {
                return false;
            }
            return firstType.Equals(secondType) || IsSubtypeOf(secondType, firstType);
        }

        // requires: firstType is not null
        // effects: if otherType is among the base types, return true, 
        // otherwise returns false.
        // when othertype is same as the current type, return false.
        internal static bool IsSubtypeOf(EdmType firstType, EdmType secondType)
        {
            Debug.Assert(firstType != null, "firstType should not be not null");
            if (secondType == null)
            {
                return false;
            }

            // walk up my type hierarchy list
            for (EdmType t = firstType.BaseType; t != null; t = t.BaseType)
            {
                if (t == secondType)
                    return true;
            }
            return false;
        }

        internal static IList GetAllStructuralMembers(EdmType edmType)
        {
            switch (edmType.BuiltInTypeKind)
            {
                case BuiltInTypeKind.AssociationType:
                    return ((AssociationType)edmType).AssociationEndMembers;
                case BuiltInTypeKind.ComplexType:
                    return ((ComplexType)edmType).Properties;
                case BuiltInTypeKind.EntityType:
                    return ((EntityType)edmType).Properties;
                case BuiltInTypeKind.RowType:
                    return ((RowType)edmType).Properties;
                default:
                    return EmptyArrayEdmProperty;
            }
        }

        internal static AssociationEndMember GetEndThatShouldBeMappedToKey(AssociationType associationType)
        {
            //For 1:* and 1:0..1 associations, the end other than 1 i.e. either * or 0..1 ends need to be 
            //mapped to key columns
            if (associationType.AssociationEndMembers.Any( it =>
                it.RelationshipMultiplicity.Equals(RelationshipMultiplicity.One)))
            {
                {
                    return associationType.AssociationEndMembers.SingleOrDefault(it =>
                        ((it.RelationshipMultiplicity.Equals(RelationshipMultiplicity.Many))
                         || (it.RelationshipMultiplicity.Equals(RelationshipMultiplicity.ZeroOrOne))));
                }
            }
            //For 0..1:* associations, * end must be mapped to key.
            else if (associationType.AssociationEndMembers.Any(it => 
                (it.RelationshipMultiplicity.Equals(RelationshipMultiplicity.ZeroOrOne))))
            {
                {
                    return associationType.AssociationEndMembers.SingleOrDefault(it =>
                        ((it.RelationshipMultiplicity.Equals(RelationshipMultiplicity.Many))));
                }
            }                
            return null;
        }

        /// <summary>
        /// Creates a single comma delimited string given a list of strings
        /// </summary>
        /// <param name="stringList"></param>
        /// <returns></returns>
        internal static String GetCommaDelimitedString(IEnumerable<string> stringList)
        {
            Debug.Assert(stringList != null , "Expecting a non null list");
            StringBuilder sb = new StringBuilder();
            bool first = true;
            foreach (string part in stringList)
            {
                if (!first)
                {
                    sb.Append(", ");
                }
                else
                {
                    first = false;
                }
                
                sb.Append(part);
            }
            return sb.ToString();
        }

        
        // effects: concatenates all given enumerations
        internal static IEnumerable<T> Concat<T>(params IEnumerable<T>[] sources)
        {
            foreach (IEnumerable<T> source in sources)
            {
                if (null != source)
                {
                    foreach (T element in source)
                    {
                        yield return element;
                    }
                }
            }
        }

        internal static void DisposeXmlReaders(IEnumerable<XmlReader> xmlReaders)
        {
            Debug.Assert(xmlReaders != null);

            foreach (XmlReader xmlReader in xmlReaders)
            {
                ((IDisposable)xmlReader).Dispose();
            }
        }

        #region IsXXXType Methods
        internal static bool IsStructuralType(EdmType type)
        {
            return (IsComplexType(type) || IsEntityType(type) || IsRelationshipType(type) || IsRowType(type));
        }

        internal static bool IsCollectionType(GlobalItem item)
        {
            return (BuiltInTypeKind.CollectionType == item.BuiltInTypeKind);
        }

        internal static bool IsEntityType(EdmType type)
        {
            return (BuiltInTypeKind.EntityType == type.BuiltInTypeKind);
        }

        internal static bool IsComplexType(EdmType type)
        {
            return (BuiltInTypeKind.ComplexType == type.BuiltInTypeKind);
        }

        internal static bool IsPrimitiveType(EdmType type)
        {
            return (BuiltInTypeKind.PrimitiveType == type.BuiltInTypeKind);
        }

        internal static bool IsRefType(GlobalItem item)
        {
            return (BuiltInTypeKind.RefType == item.BuiltInTypeKind);
        }

        internal static bool IsRowType(GlobalItem item)
        {
            return (BuiltInTypeKind.RowType == item.BuiltInTypeKind);
        }

        internal static bool IsAssociationType(EdmType type)
        {
            return (BuiltInTypeKind.AssociationType == type.BuiltInTypeKind);
        }

        internal static bool IsRelationshipType(EdmType type)
        {
            return (BuiltInTypeKind.AssociationType == type.BuiltInTypeKind);
        }

        internal static bool IsEdmProperty(EdmMember member)
        {
            return (BuiltInTypeKind.EdmProperty == member.BuiltInTypeKind);
        }

        internal static bool IsRelationshipEndMember(EdmMember member)
        {
            return (BuiltInTypeKind.AssociationEndMember == member.BuiltInTypeKind);
        }

        internal static bool IsAssociationEndMember(EdmMember member)
        {
            return (BuiltInTypeKind.AssociationEndMember == member.BuiltInTypeKind);
        }

        internal static bool IsNavigationProperty(EdmMember member)
        {
            return (BuiltInTypeKind.NavigationProperty == member.BuiltInTypeKind);
        }

        internal static bool IsEntityTypeBase(EdmType edmType)
        {
            return Helper.IsEntityType(edmType) ||
                   Helper.IsRelationshipType(edmType);
        }

        internal static bool IsTransientType(EdmType edmType)
        {
            return Helper.IsCollectionType(edmType) ||
                   Helper.IsRefType(edmType) ||
                   Helper.IsRowType(edmType);
        }

        internal static bool IsEntitySet(EntitySetBase entitySetBase)
        {
            return BuiltInTypeKind.EntitySet == entitySetBase.BuiltInTypeKind;
        }

        internal static bool IsRelationshipSet(EntitySetBase entitySetBase)
        {
            return BuiltInTypeKind.AssociationSet == entitySetBase.BuiltInTypeKind;
        }

        internal static bool IsEntityContainer(GlobalItem item)
        {
            return BuiltInTypeKind.EntityContainer == item.BuiltInTypeKind;
        }

        internal static bool IsEdmFunction(GlobalItem item)
        {
            return BuiltInTypeKind.EdmFunction == item.BuiltInTypeKind;
        }
               
        internal static string GetFileNameFromUri(Uri uri)
        {
            if ( uri == null )
                throw new ArgumentNullException("uri");
            if ( uri.IsFile )
                return uri.LocalPath;

            if ( uri.IsAbsoluteUri )
                return uri.AbsolutePath;

            throw new ArgumentException(System.Data.Entity.Strings.UnacceptableUri(uri),"uri");
        }

        internal static bool IsEnumType(EdmType edmType)
        {
            Debug.Assert(edmType != null, "edmType != null");
            return BuiltInTypeKind.EnumType == edmType.BuiltInTypeKind;
        }

        internal static bool IsUnboundedFacetValue(Facet facet)
        {
            return object.ReferenceEquals(facet.Value, EdmConstants.UnboundedValue);
        }

        internal static bool IsVariableFacetValue(Facet facet)
        {
            return object.ReferenceEquals(facet.Value, EdmConstants.VariableValue);
        }

        internal static bool IsScalarType(EdmType edmType)
        {
            return IsEnumType(edmType) || IsPrimitiveType(edmType);
        }

        internal static bool IsSpatialType(PrimitiveType type)
        {
            return IsGeographicType(type) || IsGeometricType(type);
        }

        internal static bool IsSpatialType(EdmType type, out bool isGeographic)
        {
            PrimitiveType pt = type as PrimitiveType;
            if (pt == null)
            {
                isGeographic = false;
                return false;
            }
            else
            {
                isGeographic = IsGeographicType(pt);
                return isGeographic || IsGeometricType(pt);
            }
        }

        internal static bool IsGeographicType(PrimitiveType type)
        {
            return IsGeographicTypeKind(type.PrimitiveTypeKind);
        }

        internal static bool AreSameSpatialUnionType(PrimitiveType firstType, PrimitiveType secondType)
        {
            // for the purposes of type checking all geographic types should be treated as if they were the Geography union type.
            if (Helper.IsGeographicTypeKind(firstType.PrimitiveTypeKind) && Helper.IsGeographicTypeKind(secondType.PrimitiveTypeKind))
            {
                return true;
            }

            // for the purposes of type checking all geometric types should be treated as if they were the Geometry union type.
            if (Helper.IsGeometricTypeKind(firstType.PrimitiveTypeKind) && Helper.IsGeometricTypeKind(secondType.PrimitiveTypeKind))
            {
                return true;
            }

            return false;
        }

        internal static bool IsGeographicTypeKind(PrimitiveTypeKind kind)
        {
            return kind == PrimitiveTypeKind.Geography || IsStrongGeographicTypeKind(kind);
        }

        internal static bool IsGeometricType(PrimitiveType type)
        {
            return IsGeometricTypeKind(type.PrimitiveTypeKind);
        }

        internal static bool IsGeometricTypeKind(PrimitiveTypeKind kind)
        {
            return kind == PrimitiveTypeKind.Geometry || IsStrongGeometricTypeKind(kind);
        }

        internal static bool IsStrongSpatialTypeKind(PrimitiveTypeKind kind)
        {
            return IsStrongGeometricTypeKind(kind) || IsStrongGeographicTypeKind(kind);
        }

        static bool IsStrongGeometricTypeKind(PrimitiveTypeKind kind)
        {
            return kind >= PrimitiveTypeKind.GeometryPoint && kind <= PrimitiveTypeKind.GeometryCollection;
        }

        static bool IsStrongGeographicTypeKind(PrimitiveTypeKind kind)
        {
            return kind >= PrimitiveTypeKind.GeographyPoint && kind <= PrimitiveTypeKind.GeographyCollection;
        }

        internal static bool IsSpatialType(TypeUsage type)
        {
            return (type.EdmType.BuiltInTypeKind == BuiltInTypeKind.PrimitiveType && IsSpatialType((PrimitiveType)type.EdmType));
        }

        internal static bool IsSpatialType(TypeUsage type, out PrimitiveTypeKind spatialType)
        {
            if (type.EdmType.BuiltInTypeKind == BuiltInTypeKind.PrimitiveType)
            {
                PrimitiveType primitiveType = (PrimitiveType)type.EdmType;
                if (IsGeographicTypeKind(primitiveType.PrimitiveTypeKind) || IsGeometricTypeKind(primitiveType.PrimitiveTypeKind))
                {
                    spatialType = primitiveType.PrimitiveTypeKind;
                    return true;
                }
            }

            spatialType = default(PrimitiveTypeKind);
            return false;
        }

        #endregion /// IsXXXType region

        /// <remarks>Performance of Enum.ToString() is slow and we use this value in building Identity</remarks>
        internal static string ToString(System.Data.ParameterDirection value)
        {
            switch (value)
            {
                case ParameterDirection.Input:
                    return "Input";
                case ParameterDirection.Output:
                    return "Output";
                case ParameterDirection.InputOutput:
                    return "InputOutput";
                case ParameterDirection.ReturnValue:
                    return "ReturnValue";
                default:
                    Debug.Assert(false, "which ParameterDirection.ToString() is missing?");
                    return value.ToString();
            }
        }

        /// <remarks>Performance of Enum.ToString() is slow and we use this value in building Identity</remarks>
        internal static string ToString(System.Data.Metadata.Edm.ParameterMode value)
        {
            switch (value)
            {
                case ParameterMode.In:
                    return EdmConstants.In;
                case ParameterMode.Out:
                    return EdmConstants.Out;
                case ParameterMode.InOut:
                    return EdmConstants.InOut;
                case ParameterMode.ReturnValue:
                    return "ReturnValue";
                default:
                    Debug.Assert(false, "which ParameterMode.ToString() is missing?");
                    return value.ToString();
            }
        }

        /// <summary>
        /// Verifies whether the given <paramref name="typeKind"/> is a valid underlying type for an enumeration type.
        /// </summary>
        /// <param name="typeKind">
        /// <see cref="PrimitiveTypeKind"/> to verifiy.
        /// </param>
        /// <returns>
        /// <c>true</c> if the <paramref name="typeKind"/> is a valid underlying type for an enumeration type. Otherwise <c>false</c>.
        /// </returns>
        internal static bool IsSupportedEnumUnderlyingType(PrimitiveTypeKind typeKind)
        {
            return typeKind == PrimitiveTypeKind.Byte ||
                   typeKind == PrimitiveTypeKind.SByte ||
                   typeKind == PrimitiveTypeKind.Int16 ||
                   typeKind == PrimitiveTypeKind.Int32 ||
                   typeKind == PrimitiveTypeKind.Int64;
        }

        private static readonly Dictionary<PrimitiveTypeKind, long[]> _enumUnderlyingTypeRanges =
            new Dictionary<PrimitiveTypeKind, long[]>
            {
                { PrimitiveTypeKind.Byte,  new long[] { Byte.MinValue,  Byte.MaxValue  } },
                { PrimitiveTypeKind.SByte, new long[] { SByte.MinValue, SByte.MaxValue } },
                { PrimitiveTypeKind.Int16, new long[] { Int16.MinValue, Int16.MaxValue } },
                { PrimitiveTypeKind.Int32, new long[] { Int32.MinValue, Int32.MaxValue } },
                { PrimitiveTypeKind.Int64, new long[] { Int64.MinValue, Int64.MaxValue } },
            };

        /// <summary>
        /// Verifies whether a value of a member of an enumeration type is in range according to underlying type of the enumeration type.
        /// </summary>
        /// <param name="underlyingTypeKind">Underlying type of the enumeration type.</param>
        /// <param name="value">Value to check.</param>
        /// <returns>
        /// <c>true</c> if the <paramref name="value"/> is in range of the <paramref name="underlyingTypeKind"/>. <c>false</c> otherwise.
        /// </returns>
        internal static bool IsEnumMemberValueInRange(PrimitiveTypeKind underlyingTypeKind, long value)
        {
            Debug.Assert(IsSupportedEnumUnderlyingType(underlyingTypeKind), "Unsupported underlying type.");

            return value >= _enumUnderlyingTypeRanges[underlyingTypeKind][0] && value <= _enumUnderlyingTypeRanges[underlyingTypeKind][1];
        }

        /// <summary>
        /// Checks whether the <paramref name="type"/> is enum type and if this is the case returns its underlying type. Otherwise 
        /// returns <paramref name="type"/> after casting it to PrimitiveType.
        /// </summary>
        /// <param name="type">Type to convert to primitive type.</param>
        /// <returns>Underlying type if <paramref name="type"/> is enumeration type. Otherwise <paramref name="type"/> itself.</returns>
        /// <remarks>This method should be called only for primitive or enumeration types.</remarks>
        internal static PrimitiveType AsPrimitive(EdmType type)
        {
            Debug.Assert(type != null, "type != null");
            Debug.Assert(IsScalarType(type), "This method must not be called for types that are neither primitive nor enums.");

            return Helper.IsEnumType(type) ?
                GetUnderlyingEdmTypeForEnumType(type) : 
                (PrimitiveType)type;
        }

        /// <summary>
        /// Returns underlying EDM type of a given enum <paramref name="type"/>.
        /// </summary>
        /// <param name="type">Enum type whose underlying EDM type needs to be returned. Must not be null.</param>
        /// <returns>The underlying EDM type of a given enum <paramref name="type"/>.</returns>
        internal static PrimitiveType GetUnderlyingEdmTypeForEnumType(EdmType type)
        {
            Debug.Assert(type != null, "type != null");
            Debug.Assert(IsEnumType(type), "This method can be called only for enums.");

            return ((EnumType)type).UnderlyingType;
        }

        internal static PrimitiveType GetSpatialNormalizedPrimitiveType(EdmType type)
        {
            Debug.Assert(type != null, "type != null");
            Debug.Assert(IsPrimitiveType(type), "This method can be called only for enums.");
            PrimitiveType primitiveType = (PrimitiveType)type;

            if (IsGeographicType(primitiveType) && primitiveType.PrimitiveTypeKind != PrimitiveTypeKind.Geography)
            {
                return PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Geography);
            }
            else if (IsGeometricType(primitiveType) && primitiveType.PrimitiveTypeKind != PrimitiveTypeKind.Geometry)
            {
                return PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Geometry);
            }
            else 
            {
                return primitiveType;
            }
        }

        #endregion
    }
}