The Labs \ Source Viewer \ SSCLI \ System \ UInt64

  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:  UInt64
  18. **
  19. ** Purpose: This class will encapsulate an unsigned long and
  20. **          provide an Object representation of it.
  21. **
  22. **
  23. ===========================================================*/
  24. namespace System
  25. {
  26.     using System.Globalization;
  27.     using System;
  28.     using System.Runtime.InteropServices;
  29.    
  30.     // Wrapper for unsigned 64 bit integers.
  31.     [Serializable(), CLSCompliant(false), System.Runtime.InteropServices.StructLayout(LayoutKind.Sequential)]
  32.     [System.Runtime.InteropServices.ComVisible(true)]
  33.     public struct UInt64 : IComparable, IFormattable, IConvertible, IComparable<UInt64>, IEquatable<UInt64>
  34.     {
  35.         private ulong m_value;
  36.        
  37.         public const ulong MaxValue = (ulong)18446744073709551615ul;
  38.         public const ulong MinValue = 0;
  39.        
  40.         // Compares this object to another object, returning an integer that
  41.         // indicates the relationship.
  42.         // Returns a value less than zero if this object
  43.         // null is considered to be less than any instance.
  44.         // If object is not of type UInt64, this method throws an ArgumentException.
  45.         //
  46.         public int CompareTo(object value)
  47.         {
  48.             if (value == null) {
  49.                 return 1;
  50.             }
  51.             if (value is UInt64) {
  52.                 // Need to use compare because subtraction will wrap
  53.                 // to positive for very large neg numbers, etc.
  54.                 ulong i = (ulong)value;
  55.                 if (m_value < i)
  56.                     return -1;
  57.                 if (m_value > i)
  58.                     return 1;
  59.                 return 0;
  60.             }
  61.             throw new ArgumentException(Environment.GetResourceString("Arg_MustBeUInt64"));
  62.         }
  63.        
  64.         public int CompareTo(UInt64 value)
  65.         {
  66.             // Need to use compare because subtraction will wrap
  67.             // to positive for very large neg numbers, etc.
  68.             if (m_value < value)
  69.                 return -1;
  70.             if (m_value > value)
  71.                 return 1;
  72.             return 0;
  73.         }
  74.        
  75.         public override bool Equals(object obj)
  76.         {
  77.             if (!(obj is UInt64)) {
  78.                 return false;
  79.             }
  80.             return m_value == ((UInt64)obj).m_value;
  81.         }
  82.        
  83.         public bool Equals(UInt64 obj)
  84.         {
  85.             return m_value == obj;
  86.         }
  87.        
  88.         // The value of the lower 32 bits XORed with the uppper 32 bits.
  89.         public override int GetHashCode()
  90.         {
  91.             return ((int)m_value) ^ (int)(m_value >> 32);
  92.         }
  93.        
  94.         public override string ToString()
  95.         {
  96.             return Number.FormatUInt64(m_value, null, NumberFormatInfo.CurrentInfo);
  97.         }
  98.        
  99.         public string ToString(IFormatProvider provider)
  100.         {
  101.             return Number.FormatUInt64(m_value, null, NumberFormatInfo.GetInstance(provider));
  102.         }
  103.        
  104.         public string ToString(string format)
  105.         {
  106.             return Number.FormatUInt64(m_value, format, NumberFormatInfo.CurrentInfo);
  107.         }
  108.        
  109.         public string ToString(string format, IFormatProvider provider)
  110.         {
  111.             return Number.FormatUInt64(m_value, format, NumberFormatInfo.GetInstance(provider));
  112.         }
  113.        
  114.         [CLSCompliant(false)]
  115.         public static ulong Parse(string s)
  116.         {
  117.             return Number.ParseUInt64(s, NumberStyles.Integer, NumberFormatInfo.CurrentInfo);
  118.         }
  119.        
  120.         [CLSCompliant(false)]
  121.         public static ulong Parse(string s, NumberStyles style)
  122.         {
  123.             NumberFormatInfo.ValidateParseStyleInteger(style);
  124.             return Number.ParseUInt64(s, style, NumberFormatInfo.CurrentInfo);
  125.         }
  126.        
  127.         [CLSCompliant(false)]
  128.         public static ulong Parse(string s, IFormatProvider provider)
  129.         {
  130.             return Number.ParseUInt64(s, NumberStyles.Integer, NumberFormatInfo.GetInstance(provider));
  131.         }
  132.        
  133.         [CLSCompliant(false)]
  134.         public static ulong Parse(string s, NumberStyles style, IFormatProvider provider)
  135.         {
  136.             NumberFormatInfo.ValidateParseStyleInteger(style);
  137.             return Number.ParseUInt64(s, style, NumberFormatInfo.GetInstance(provider));
  138.         }
  139.        
  140.         [CLSCompliant(false)]
  141.         public static bool TryParse(string s, out UInt64 result)
  142.         {
  143.             return Number.TryParseUInt64(s, NumberStyles.Integer, NumberFormatInfo.CurrentInfo, out result);
  144.         }
  145.        
  146.         [CLSCompliant(false)]
  147.         public static bool TryParse(string s, NumberStyles style, IFormatProvider provider, out UInt64 result)
  148.         {
  149.             NumberFormatInfo.ValidateParseStyleInteger(style);
  150.             return Number.TryParseUInt64(s, style, NumberFormatInfo.GetInstance(provider), out result);
  151.         }
  152.        
  153.         //
  154.         // IValue implementation
  155.         //
  156.        
  157.         public TypeCode GetTypeCode()
  158.         {
  159.             return TypeCode.UInt64;
  160.         }
  161.        
  162.         /// <internalonly/>
  163.         bool IConvertible.ToBoolean(IFormatProvider provider)
  164.         {
  165.             return Convert.ToBoolean(m_value);
  166.         }
  167.        
  168.         /// <internalonly/>
  169.         char IConvertible.ToChar(IFormatProvider provider)
  170.         {
  171.             return Convert.ToChar(m_value);
  172.         }
  173.        
  174.         /// <internalonly/>
  175.         sbyte IConvertible.ToSByte(IFormatProvider provider)
  176.         {
  177.             return Convert.ToSByte(m_value);
  178.         }
  179.        
  180.         /// <internalonly/>
  181.         byte IConvertible.ToByte(IFormatProvider provider)
  182.         {
  183.             return Convert.ToByte(m_value);
  184.         }
  185.        
  186.         /// <internalonly/>
  187.         short IConvertible.ToInt16(IFormatProvider provider)
  188.         {
  189.             return Convert.ToInt16(m_value);
  190.         }
  191.        
  192.         /// <internalonly/>
  193.         ushort IConvertible.ToUInt16(IFormatProvider provider)
  194.         {
  195.             return Convert.ToUInt16(m_value);
  196.         }
  197.        
  198.         /// <internalonly/>
  199.         int IConvertible.ToInt32(IFormatProvider provider)
  200.         {
  201.             return Convert.ToInt32(m_value);
  202.         }
  203.        
  204.         /// <internalonly/>
  205.         uint IConvertible.ToUInt32(IFormatProvider provider)
  206.         {
  207.             return Convert.ToUInt32(m_value);
  208.         }
  209.        
  210.         /// <internalonly/>
  211.         long IConvertible.ToInt64(IFormatProvider provider)
  212.         {
  213.             return Convert.ToInt64(m_value);
  214.         }
  215.        
  216.         /// <internalonly/>
  217.         ulong IConvertible.ToUInt64(IFormatProvider provider)
  218.         {
  219.             return m_value;
  220.         }
  221.        
  222.         /// <internalonly/>
  223.         float IConvertible.ToSingle(IFormatProvider provider)
  224.         {
  225.             return Convert.ToSingle(m_value);
  226.         }
  227.        
  228.         /// <internalonly/>
  229.         double IConvertible.ToDouble(IFormatProvider provider)
  230.         {
  231.             return Convert.ToDouble(m_value);
  232.         }
  233.        
  234.         /// <internalonly/>
  235.         decimal IConvertible.ToDecimal(IFormatProvider provider)
  236.         {
  237.             return Convert.ToDecimal(m_value);
  238.         }
  239.        
  240.         /// <internalonly/>
  241.         DateTime IConvertible.ToDateTime(IFormatProvider provider)
  242.         {
  243.             throw new InvalidCastException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("InvalidCast_FromTo"), "UInt64", "DateTime"));
  244.         }
  245.        
  246.         /// <internalonly/>
  247.         object IConvertible.ToType(Type type, IFormatProvider provider)
  248.         {
  249.             return Convert.DefaultToType((IConvertible)this, type, provider);
  250.         }
  251.     }
  252. }

Developer Fusion