The Labs \ Source Viewer \ SSCLI \ System.Xml.Serialization \ CaseInsensitiveKeyComparer

  1. //------------------------------------------------------------------------------
  2. // <copyright file="CodeIdentifiers.cs" company="Microsoft">
  3. //
  4. // Copyright (c) 2006 Microsoft Corporation. All rights reserved.
  5. //
  6. // The use and distribution terms for this software are contained in the file
  7. // named license.txt, which can be found in the root of this distribution.
  8. // By using this software in any fashion, you are agreeing to be bound by the
  9. // terms of this license.
  10. //
  11. // You must not remove this notice, or any other, from this software.
  12. //
  13. // </copyright>
  14. // <owner current="true" primary="true">ElenaK</owner>
  15. //------------------------------------------------------------------------------
  16. namespace System.Xml.Serialization
  17. {
  18.    
  19.     using System;
  20.     using System.Collections;
  21.     using System.IO;
  22.     using System.Globalization;
  23.    
  24.     class CaseInsensitiveKeyComparer : CaseInsensitiveComparer, IEqualityComparer
  25.     {
  26.         public CaseInsensitiveKeyComparer() : base(CultureInfo.CurrentCulture)
  27.         {
  28.         }
  29.        
  30.         bool IEqualityComparer.Equals(object x, object y)
  31.         {
  32.             return (Compare(x, y) == 0);
  33.         }
  34.        
  35.         int IEqualityComparer.GetHashCode(object obj)
  36.         {
  37.             string s = obj as string;
  38.             if (s == null)
  39.                 throw new ArgumentException(null, "obj");
  40.            
  41.             return s.ToUpper(CultureInfo.CurrentCulture).GetHashCode();
  42.         }
  43.     }
  44.    
  45.     /// <include file='doc\CodeIdentifiers.uex' path='docs/doc[@for="CodeIdentifiers"]/*' />
  46.     ///<internalonly/>
  47.     /// <devdoc>
  48.     /// <para>[To be supplied.]</para>
  49.     /// </devdoc>
  50.     public class CodeIdentifiers
  51.     {
  52.         Hashtable identifiers;
  53.         Hashtable reservedIdentifiers;
  54.         ArrayList list;
  55.         bool camelCase;
  56.        
  57.         public CodeIdentifiers() : this(true)
  58.         {
  59.         }
  60.        
  61.         public CodeIdentifiers(bool caseSensitive)
  62.         {
  63.             if (caseSensitive) {
  64.                 identifiers = new Hashtable();
  65.                 reservedIdentifiers = new Hashtable();
  66.             }
  67.             else {
  68.                 IEqualityComparer comparer = new CaseInsensitiveKeyComparer();
  69.                 identifiers = new Hashtable(comparer);
  70.                 reservedIdentifiers = new Hashtable(comparer);
  71.             }
  72.            
  73.             list = new ArrayList();
  74.         }
  75.        
  76.         /// <include file='doc\CodeIdentifiers.uex' path='docs/doc[@for="CodeIdentifiers.Clear"]/*' />
  77.         public void Clear()
  78.         {
  79.             identifiers.Clear();
  80.             list.Clear();
  81.         }
  82.        
  83.         /// <include file='doc\CodeIdentifiers.uex' path='docs/doc[@for="CodeIdentifiers.UseCamelCasing"]/*' />
  84.         /// <devdoc>
  85.         /// <para>[To be supplied.]</para>
  86.         /// </devdoc>
  87.         public bool UseCamelCasing {
  88.             get { return camelCase; }
  89.             set { camelCase = value; }
  90.         }
  91.        
  92.         /// <include file='doc\CodeIdentifiers.uex' path='docs/doc[@for="CodeIdentifiers.MakeRightCase"]/*' />
  93.         /// <devdoc>
  94.         /// <para>[To be supplied.]</para>
  95.         /// </devdoc>
  96.         public string MakeRightCase(string identifier)
  97.         {
  98.             if (camelCase)
  99.                 return CodeIdentifier.MakeCamel(identifier);
  100.             else
  101.                 return CodeIdentifier.MakePascal(identifier);
  102.         }
  103.        
  104.         /// <include file='doc\CodeIdentifiers.uex' path='docs/doc[@for="CodeIdentifiers.MakeUnique"]/*' />
  105.         /// <devdoc>
  106.         /// <para>[To be supplied.]</para>
  107.         /// </devdoc>
  108.         public string MakeUnique(string identifier)
  109.         {
  110.             if (IsInUse(identifier)) {
  111.                 for (int i = 1;; i++) {
  112.                     string newIdentifier = identifier + i.ToString(CultureInfo.InvariantCulture);
  113.                     if (!IsInUse(newIdentifier)) {
  114.                         identifier = newIdentifier;
  115.                         break;
  116.                     }
  117.                 }
  118.             }
  119.             // Check that we did not violate the identifier length after appending the suffix.
  120.             if (identifier.Length > CodeIdentifier.MaxIdentifierLength) {
  121.                 return MakeUnique("Item");
  122.             }
  123.             return identifier;
  124.         }
  125.        
  126.         /// <include file='doc\CodeIdentifiers.uex' path='docs/doc[@for="CodeIdentifiers.AddReserved"]/*' />
  127.         /// <devdoc>
  128.         /// <para>[To be supplied.]</para>
  129.         /// </devdoc>
  130.         public void AddReserved(string identifier)
  131.         {
  132.             reservedIdentifiers.Add(identifier, identifier);
  133.         }
  134.        
  135.         /// <include file='doc\CodeIdentifiers.uex' path='docs/doc[@for="CodeIdentifiers.RemoveReserved"]/*' />
  136.         /// <devdoc>
  137.         /// <para>[To be supplied.]</para>
  138.         /// </devdoc>
  139.         public void RemoveReserved(string identifier)
  140.         {
  141.             reservedIdentifiers.Remove(identifier);
  142.         }
  143.        
  144.         /// <include file='doc\CodeIdentifiers.uex' path='docs/doc[@for="CodeIdentifiers.AddUnique"]/*' />
  145.         /// <devdoc>
  146.         /// <para>[To be supplied.]</para>
  147.         /// </devdoc>
  148.         public string AddUnique(string identifier, object value)
  149.         {
  150.             identifier = MakeUnique(identifier);
  151.             Add(identifier, value);
  152.             return identifier;
  153.         }
  154.        
  155.         /// <include file='doc\CodeIdentifiers.uex' path='docs/doc[@for="CodeIdentifiers.IsInUse"]/*' />
  156.         /// <devdoc>
  157.         /// <para>[To be supplied.]</para>
  158.         /// </devdoc>
  159.         public bool IsInUse(string identifier)
  160.         {
  161.             return identifiers.Contains(identifier) || reservedIdentifiers.Contains(identifier);
  162.         }
  163.        
  164.         /// <include file='doc\CodeIdentifiers.uex' path='docs/doc[@for="CodeIdentifiers.Add"]/*' />
  165.         /// <devdoc>
  166.         /// <para>[To be supplied.]</para>
  167.         /// </devdoc>
  168.         public void Add(string identifier, object value)
  169.         {
  170.             identifiers.Add(identifier, value);
  171.             list.Add(value);
  172.         }
  173.        
  174.         /// <include file='doc\CodeIdentifiers.uex' path='docs/doc[@for="CodeIdentifiers.Remove"]/*' />
  175.         /// <devdoc>
  176.         /// <para>[To be supplied.]</para>
  177.         /// </devdoc>
  178.         public void Remove(string identifier)
  179.         {
  180.             list.Remove(identifiers[identifier]);
  181.             identifiers.Remove(identifier);
  182.         }
  183.        
  184.         /// <include file='doc\CodeIdentifiers.uex' path='docs/doc[@for="CodeIdentifiers.ToArray"]/*' />
  185.         /// <devdoc>
  186.         /// <para>[To be supplied.]</para>
  187.         /// </devdoc>
  188.         public object ToArray(Type type)
  189.         {
  190.             //Array array = Array.CreateInstance(type, identifiers.Values.Count);
  191.             //identifiers.Values.CopyTo(array, 0);
  192.             Array array = Array.CreateInstance(type, list.Count);
  193.             list.CopyTo(array, 0);
  194.             return array;
  195.         }
  196.        
  197.         internal CodeIdentifiers Clone()
  198.         {
  199.             CodeIdentifiers newIdentifiers = new CodeIdentifiers();
  200.             newIdentifiers.identifiers = (Hashtable)this.identifiers.Clone();
  201.             newIdentifiers.reservedIdentifiers = (Hashtable)this.reservedIdentifiers.Clone();
  202.             newIdentifiers.list = (ArrayList)this.list.Clone();
  203.             newIdentifiers.camelCase = this.camelCase;
  204.            
  205.             return newIdentifiers;
  206.         }
  207.     }
  208. }

Developer Fusion