The Labs \ Source Viewer \ SSCLI \ System.Globalization \ SortKey

  1. // ==++==
  2. //
  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. //
  14. // ==--==
  15. ////////////////////////////////////////////////////////////////////////////
  16. //
  17. // Class: SortKey
  18. //
  19. // Purpose: This class implements a set of methods for retrieving
  20. // sort key information.
  21. //
  22. // Date: August 12, 1998
  23. //
  24. ////////////////////////////////////////////////////////////////////////////
  25. namespace System.Globalization
  26. {
  27.    
  28.     using System;
  29.     using System.Runtime.CompilerServices;
  30.    
  31.     [System.Runtime.InteropServices.ComVisible(true)]
  32.     [Serializable()]
  33.     public class SortKey
  34.     {
  35.         //--------------------------------------------------------------------//
  36.         // Internal Information //
  37.         //--------------------------------------------------------------------//
  38.        
  39.         //
  40.         // Variables.
  41.         //
  42.         internal int win32LCID;
  43.         // 32-bit Win32 locale ID. It may contain a 4-bit sort ID.
  44.         internal CompareOptions options;
  45.         // options
  46.         internal string m_String;
  47.         // original string
  48.         internal byte[] m_KeyData;
  49.         // sortkey data
  50.         // Mask used to check if the c'tor has the right flags.
  51.         private const CompareOptions ValidSortkeyCtorMaskOffFlags = ~(CompareOptions.IgnoreCase | CompareOptions.IgnoreSymbols | CompareOptions.IgnoreNonSpace | CompareOptions.IgnoreWidth | CompareOptions.IgnoreKanaType | CompareOptions.StringSort);
  52.        
  53.         ////////////////////////////////////////////////////////////////////////
  54.         //
  55.         // SortKey Constructor
  56.         //
  57.         // Implements CultureInfo.CompareInfo.GetSortKey().
  58.         // Package access only.
  59.         //
  60.         ////////////////////////////////////////////////////////////////////////
  61.        
  62.         unsafe internal SortKey(void* pSortingFile, int win32LCID, string str, CompareOptions options)
  63.         {
  64.             if (str == null) {
  65.                 throw new ArgumentNullException("str");
  66.             }
  67.            
  68.             //
  69.             //
  70.             if ((options & ValidSortkeyCtorMaskOffFlags) != 0) {
  71.                 throw new ArgumentException(Environment.GetResourceString("Argument_InvalidFlag"), "options");
  72.             }
  73.            
  74.             //This takes the sort id from CompareInfo, so we should be able to skip initializing it.
  75.             this.win32LCID = win32LCID;
  76.            
  77.             this.options = options;
  78.             m_String = str;
  79.            
  80.             //We need an initialized SortTable here, but since we're getting this as an instance
  81.             //method off of a CompareInfo, we're guaranteed that that already happened.
  82.             m_KeyData = CompareInfo.nativeCreateSortKey(pSortingFile, str, (int)options, win32LCID);
  83.         }
  84.        
  85.        
  86.        
  87.         ////////////////////////////////////////////////////////////////////////
  88.         //
  89.         // GetOriginalString
  90.         //
  91.         // Returns the original string used to create the current instance
  92.         // of SortKey.
  93.         //
  94.         ////////////////////////////////////////////////////////////////////////
  95.         public virtual string OriginalString {
  96.             get { return (m_String); }
  97.         }
  98.        
  99.        
  100.         ////////////////////////////////////////////////////////////////////////
  101.         //
  102.         // GetKeyData
  103.         //
  104.         // Returns a byte array representing the current instance of the
  105.         // sort key.
  106.         //
  107.         ////////////////////////////////////////////////////////////////////////
  108.         public virtual byte[] KeyData {
  109.             get { return (byte[])(m_KeyData.Clone()); }
  110.         }
  111.        
  112.        
  113.         ////////////////////////////////////////////////////////////////////////
  114.         //
  115.         // Compare
  116.         //
  117.         // Compares the two sort keys. Returns 0 if the two sort keys are
  118.         // equal, a number less than 0 if sortkey1 is less than sortkey2,
  119.         // and a number greater than 0 if sortkey1 is greater than sortkey2.
  120.         //
  121.         ////////////////////////////////////////////////////////////////////////
  122.         public static int Compare(SortKey sortkey1, SortKey sortkey2)
  123.         {
  124.            
  125.             if (sortkey1 == null || sortkey2 == null) {
  126.                 throw new ArgumentNullException((sortkey1 == null ? "sortkey1" : "sortkey2"));
  127.             }
  128.            
  129.             byte[] key1Data = sortkey1.m_KeyData;
  130.             byte[] key2Data = sortkey2.m_KeyData;
  131.            
  132.             BCLDebug.Assert(key1Data != null, "key1Data!=null");
  133.             BCLDebug.Assert(key2Data != null, "key2Data!=null");
  134.            
  135.             if (key1Data.Length == 0) {
  136.                 if (key2Data.Length == 0) {
  137.                     return (0);
  138.                 }
  139.                 return (-1);
  140.             }
  141.             if (key2Data.Length == 0) {
  142.                 return (1);
  143.             }
  144.            
  145.             int compLen = (key1Data.Length < key2Data.Length) ? key1Data.Length : key2Data.Length;
  146.            
  147.             for (int i = 0; i < compLen; i++) {
  148.                 if (key1Data[i] > key2Data[i]) {
  149.                     return (1);
  150.                 }
  151.                 if (key1Data[i] < key2Data[i]) {
  152.                     return (-1);
  153.                 }
  154.             }
  155.            
  156.             return 0;
  157.            
  158.         }
  159.        
  160.        
  161.         ////////////////////////////////////////////////////////////////////////
  162.         //
  163.         // Equals
  164.         //
  165.         // Implements Object.Equals(). Returns a boolean indicating whether
  166.         // or not object refers to the same SortKey as the current instance.
  167.         //
  168.         ////////////////////////////////////////////////////////////////////////
  169.         public override bool Equals(object value)
  170.         {
  171.             SortKey that = value as SortKey;
  172.            
  173.             if (that != null) {
  174.                 return Compare(this, that) == 0;
  175.             }
  176.            
  177.             return (false);
  178.         }
  179.        
  180.        
  181.         ////////////////////////////////////////////////////////////////////////
  182.         //
  183.         // GetHashCode
  184.         //
  185.         // Implements Object.GetHashCode(). Returns the hash code for the
  186.         // SortKey. The hash code is guaranteed to be the same for
  187.         // SortKey A and B where A.Equals(B) is true.
  188.         //
  189.         ////////////////////////////////////////////////////////////////////////
  190.         public override int GetHashCode()
  191.         {
  192.             return (CompareInfo.GetCompareInfo(win32LCID).GetHashCodeOfString(m_String, options));
  193.         }
  194.        
  195.        
  196.         ////////////////////////////////////////////////////////////////////////
  197.         //
  198.         // ToString
  199.         //
  200.         // Implements Object.ToString(). Returns a string describing the
  201.         // SortKey.
  202.         //
  203.         ////////////////////////////////////////////////////////////////////////
  204.         public override string ToString()
  205.         {
  206.             return ("SortKey - " + win32LCID + ", " + options + ", " + m_String);
  207.         }
  208.     }
  209. }

Developer Fusion