The Labs \ Source Viewer \ SSCLI \ System \ UInt32

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

Developer Fusion