source: tags/3.3.13/HeuristicLab.ExtLibs/HeuristicLab.NRefactory/5.5.0/NRefactory-5.5.0/TypeSystem/FullTypeName.cs

// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team
// 
// Permission is hereby granted, free of charge, to any person obtaining a copy of this
// software and associated documentation files (the "Software"), to deal in the Software
// without restriction, including without limitation the rights to use, copy, modify, merge,
// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons
// to whom the Software is furnished to do so, subject to the following conditions:
// 
// The above copyright notice and this permission notice shall be included in all copies or
// substantial portions of the Software.
// 
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
// DEALINGS IN THE SOFTWARE.

using System;
using System.Collections.Generic;
using System.Text;

namespace ICSharpCode.NRefactory.TypeSystem
{
  /// <summary>
  /// Holds the full name of a type definition.
  /// A full type name uniquely identifies a type definition within a single assembly.
  /// </summary>
  /// <remarks>
  /// A full type name can only represent type definitions, not arbitrary types.
  /// It does not include any type arguments, and can not refer to array or pointer types.
  /// 
  /// A full type name represented as reflection name has the syntax:
  /// <c>NamespaceName '.' TopLevelTypeName ['`'#] { '+' NestedTypeName ['`'#] }</c>
  /// </remarks>
  [Serializable]
  public struct FullTypeName : IEquatable<FullTypeName>
  {
    [Serializable]
    struct NestedTypeName
    {
      public readonly string Name;
      public readonly int AdditionalTypeParameterCount;
      
      public NestedTypeName(string name, int additionalTypeParameterCount)
      {
        if (name == null)
          throw new ArgumentNullException("name");
        this.Name = name;
        this.AdditionalTypeParameterCount = additionalTypeParameterCount;
      }
    }
    
    readonly TopLevelTypeName topLevelType;
    readonly NestedTypeName[] nestedTypes;
    
    FullTypeName(TopLevelTypeName topLevelTypeName, NestedTypeName[] nestedTypes)
    {
      this.topLevelType = topLevelTypeName;
      this.nestedTypes = nestedTypes;
    }
    
    /// <summary>
    /// Constructs a FullTypeName representing the given top-level type.
    /// </summary>
    /// <remarks>
    /// FullTypeName has an implicit conversion operator from TopLevelTypeName,
    /// so you can simply write:
    /// <c>FullTypeName f = new TopLevelTypeName(...);</c>
    /// </remarks>
    public FullTypeName(TopLevelTypeName topLevelTypeName)
    {
      this.topLevelType = topLevelTypeName;
      this.nestedTypes = null;
    }
    
    /// <summary>
    /// Constructs a FullTypeName by parsing the given reflection name.
    /// Note that FullTypeName can only represent type definition names. If the reflection name
    /// might refer to a parameterized type or array etc., use
    /// <see cref="ReflectionHelper.ParseReflectionName(string)"/> instead.
    /// </summary>
    /// <remarks>
    /// Expected syntax: <c>NamespaceName '.' TopLevelTypeName ['`'#] { '+' NestedTypeName ['`'#] }</c>
    /// where # are type parameter counts
    /// </remarks>
    public FullTypeName(string reflectionName)
    {
      int pos = reflectionName.IndexOf('+');
      if (pos < 0) {
        // top-level type
        this.topLevelType = new TopLevelTypeName(reflectionName);
        this.nestedTypes = null;
      } else {
        // nested type
        string[] parts = reflectionName.Split('+');
        this.topLevelType = new TopLevelTypeName(parts[0]);
        this.nestedTypes = new NestedTypeName[parts.Length - 1];
        for (int i = 0; i < nestedTypes.Length; i++) {
          int tpc;
          string name = ReflectionHelper.SplitTypeParameterCountFromReflectionName(parts[i + 1], out tpc);
          nestedTypes[i] = new NestedTypeName(name, tpc);
        }
      }
    }
    
    /// <summary>
    /// Gets the top-level type name.
    /// </summary>
    public TopLevelTypeName TopLevelTypeName {
      get { return topLevelType; }
    }
    
    /// <summary>
    /// Gets whether this is a nested type.
    /// </summary>
    public bool IsNested {
      get {
        return nestedTypes != null;
      }
    }
    
    /// <summary>
    /// Gets the nesting level.
    /// </summary>
    public int NestingLevel {
      get {
        return nestedTypes != null ? nestedTypes.Length : 0;
      }
    }
    
    /// <summary>
    /// Gets the name of the type.
    /// For nested types, this is the name of the innermost type.
    /// </summary>
    public string Name {
      get {
        if (nestedTypes != null)
          return nestedTypes[nestedTypes.Length - 1].Name;
        else
          return topLevelType.Name;
      }
    }
    
    public string ReflectionName {
      get {
        if (nestedTypes == null)
          return topLevelType.ReflectionName;
        StringBuilder b = new StringBuilder(topLevelType.ReflectionName);
        foreach (NestedTypeName nt in nestedTypes) {
          b.Append('+');
          b.Append(nt.Name);
          if (nt.AdditionalTypeParameterCount > 0) {
            b.Append('`');
            b.Append(nt.AdditionalTypeParameterCount);
          }
        }
        return b.ToString();
      }
    }
    
    /// <summary>
    /// Gets the total type parameter count.
    /// </summary>
    public int TypeParameterCount {
      get {
        int tpc = topLevelType.TypeParameterCount;
        if (nestedTypes != null) {
          foreach (var nt in nestedTypes) {
            tpc += nt.AdditionalTypeParameterCount;
          }
        }
        return tpc;
      }
    }
    
    /// <summary>
    /// Gets the name of the nested type at the given level.
    /// </summary>
    public string GetNestedTypeName(int nestingLevel)
    {
      if (nestedTypes == null)
        throw new InvalidOperationException();
      return nestedTypes[nestingLevel].Name;
    }
    
    /// <summary>
    /// Gets the number of additional type parameters of the nested type at the given level.
    /// </summary>
    public int GetNestedTypeAdditionalTypeParameterCount(int nestingLevel)
    {
      if (nestedTypes == null)
        throw new InvalidOperationException();
      return nestedTypes[nestingLevel].AdditionalTypeParameterCount;
    }
    
    /// <summary>
    /// Gets the declaring type name.
    /// </summary>
    /// <exception cref="InvalidOperationException">This is a top-level type name.</exception>
    /// <example><c>new FullTypeName("NS.A+B+C").GetDeclaringType()</c> will return <c>new FullTypeName("NS.A+B")</c></example>
    public FullTypeName GetDeclaringType()
    {
      if (nestedTypes == null)
        throw new InvalidOperationException();
      if (nestedTypes.Length == 1)
        return topLevelType;
      NestedTypeName[] outerNestedTypeNames = new NestedTypeName[nestedTypes.Length - 1];
      Array.Copy(nestedTypes, 0, outerNestedTypeNames, 0, outerNestedTypeNames.Length);
      return new FullTypeName(topLevelType, nestedTypes);
    }
    
    /// <summary>
    /// Creates a nested type name.
    /// </summary>
    /// <example><c>new FullTypeName("NS.A+B").NestedType("C", 1)</c> will return <c>new FullTypeName("NS.A+B+C`1")</c></example>
    public FullTypeName NestedType(string name, int additionalTypeParameterCount)
    {
      if (name == null)
        throw new ArgumentNullException("name");
      var newNestedType = new NestedTypeName(name, additionalTypeParameterCount);
      if (nestedTypes == null)
        return new FullTypeName(topLevelType, new[] { newNestedType });
      NestedTypeName[] newNestedTypeNames = new NestedTypeName[nestedTypes.Length + 1];
      nestedTypes.CopyTo(newNestedTypeNames, 0);
      newNestedTypeNames[newNestedTypeNames.Length - 1] = newNestedType;
      return new FullTypeName(topLevelType, newNestedTypeNames);
    }
    
    public static implicit operator FullTypeName(TopLevelTypeName topLevelTypeName)
    {
      return new FullTypeName(topLevelTypeName);
    }
    
    public override string ToString()
    {
      return this.ReflectionName;
    }
    
    #region Equals and GetHashCode implementation
    public override bool Equals(object obj)
    {
      return obj is FullTypeName && Equals((FullTypeName)obj);
    }
    
    public bool Equals(FullTypeName other)
    {
      return FullTypeNameComparer.Ordinal.Equals(this, other);
    }
    
    public override int GetHashCode()
    {
      return FullTypeNameComparer.Ordinal.GetHashCode(this);
    }
    
    public static bool operator ==(FullTypeName left, FullTypeName right)
    {
      return left.Equals(right);
    }
    
    public static bool operator !=(FullTypeName left, FullTypeName right)
    {
      return !left.Equals(right);
    }
    #endregion
  }
  
  [Serializable]
  public sealed class FullTypeNameComparer : IEqualityComparer<FullTypeName>
  {
    public static readonly FullTypeNameComparer Ordinal = new FullTypeNameComparer(StringComparer.Ordinal);
    public static readonly FullTypeNameComparer OrdinalIgnoreCase = new FullTypeNameComparer(StringComparer.OrdinalIgnoreCase);
    
    public readonly StringComparer NameComparer;
    
    public FullTypeNameComparer(StringComparer nameComparer)
    {
      this.NameComparer = nameComparer;
    }
    
    public bool Equals(FullTypeName x, FullTypeName y)
    {
      if (x.NestingLevel != y.NestingLevel)
        return false;
      TopLevelTypeName topX = x.TopLevelTypeName;
      TopLevelTypeName topY = y.TopLevelTypeName;
      if (topX.TypeParameterCount == topY.TypeParameterCount
          && NameComparer.Equals(topX.Name, topY.Name)
          && NameComparer.Equals(topX.Namespace, topY.Namespace))
      {
        for (int i = 0; i < x.NestingLevel; i++) {
          if (x.GetNestedTypeAdditionalTypeParameterCount(i) != y.GetNestedTypeAdditionalTypeParameterCount(i))
            return false;
          if (!NameComparer.Equals(x.GetNestedTypeName(i), y.GetNestedTypeName(i)))
            return false;
        }
        return true;
      }
      return false;
    }
    
    public int GetHashCode(FullTypeName obj)
    {
      TopLevelTypeName top = obj.TopLevelTypeName;
      int hash = NameComparer.GetHashCode(top.Name) ^ NameComparer.GetHashCode(top.Namespace) ^ top.TypeParameterCount;
      unchecked {
        for (int i = 0; i < obj.NestingLevel; i++) {
          hash *= 31;
          hash += NameComparer.GetHashCode(obj.Name) ^ obj.TypeParameterCount;
        }
      }
      return hash;
    }
  }
}