The Labs \ Source Viewer \ SSCLI \ System \ UInt16

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

Developer Fusion