The Labs \ Source Viewer \ SSCLI \ System \ Int16

  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:  Int16.cs
  18. **
  19. **
  20. ** Purpose: This class will encapsulate a short and provide an
  21. **          Object representation of it.
  22. **
  23. **
  24. ===========================================================*/
  25. namespace System
  26. {
  27.    
  28.     using System;
  29.     using System.Globalization;
  30.     using System.Runtime.InteropServices;
  31.    
  32.     [System.Runtime.InteropServices.ComVisible(true)]
  33.     [Serializable(), System.Runtime.InteropServices.StructLayout(LayoutKind.Sequential)]
  34.     public struct Int16 : IComparable, IFormattable, IConvertible, IComparable<Int16>, IEquatable<Int16>
  35.     {
  36.         internal short m_value;
  37.        
  38.         public const short MaxValue = (short)32767;
  39.         public const short MinValue = unchecked((short)32768);
  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 Int16, this method throws an ArgumentException.
  46.         //
  47.         public int CompareTo(object value)
  48.         {
  49.             if (value == null) {
  50.                 return 1;
  51.             }
  52.            
  53.             if (value is Int16) {
  54.                 return m_value - ((Int16)value).m_value;
  55.             }
  56.            
  57.             throw new ArgumentException(Environment.GetResourceString("Arg_MustBeInt16"));
  58.         }
  59.        
  60.         public int CompareTo(Int16 value)
  61.         {
  62.             return m_value - value;
  63.         }
  64.        
  65.         public override bool Equals(object obj)
  66.         {
  67.             if (!(obj is Int16)) {
  68.                 return false;
  69.             }
  70.             return m_value == ((Int16)obj).m_value;
  71.         }
  72.        
  73.         public bool Equals(Int16 obj)
  74.         {
  75.             return m_value == obj;
  76.         }
  77.        
  78.         // Returns a HashCode for the Int16
  79.         public override int GetHashCode()
  80.         {
  81.             return ((int)((ushort)m_value) | (((int)m_value) << 16));
  82.         }
  83.        
  84.        
  85.         public override string ToString()
  86.         {
  87.             return Number.FormatInt32(m_value, null, NumberFormatInfo.CurrentInfo);
  88.         }
  89.        
  90.         public string ToString(IFormatProvider provider)
  91.         {
  92.             return Number.FormatInt32(m_value, null, NumberFormatInfo.GetInstance(provider));
  93.         }
  94.        
  95.         public string ToString(string format)
  96.         {
  97.             return ToString(format, NumberFormatInfo.CurrentInfo);
  98.         }
  99.        
  100.         public string ToString(string format, IFormatProvider provider)
  101.         {
  102.             return ToString(format, NumberFormatInfo.GetInstance(provider));
  103.         }
  104.        
  105.         private string ToString(string format, NumberFormatInfo info)
  106.         {
  107.             if (m_value < 0 && format != null && format.Length > 0 && (format[0] == 'X' || format[0] == 'x')) {
  108.                 uint temp = (uint)(m_value & 65535);
  109.                 return Number.FormatUInt32(temp, format, info);
  110.             }
  111.             return Number.FormatInt32(m_value, format, info);
  112.         }
  113.        
  114.         public static short Parse(string s)
  115.         {
  116.             return Parse(s, NumberStyles.Integer, NumberFormatInfo.CurrentInfo);
  117.         }
  118.        
  119.         public static short Parse(string s, NumberStyles style)
  120.         {
  121.             NumberFormatInfo.ValidateParseStyleInteger(style);
  122.             return Parse(s, style, NumberFormatInfo.CurrentInfo);
  123.         }
  124.        
  125.         public static short Parse(string s, IFormatProvider provider)
  126.         {
  127.             return Parse(s, NumberStyles.Integer, NumberFormatInfo.GetInstance(provider));
  128.         }
  129.        
  130.         public static short Parse(string s, NumberStyles style, IFormatProvider provider)
  131.         {
  132.             NumberFormatInfo.ValidateParseStyleInteger(style);
  133.             return Parse(s, style, NumberFormatInfo.GetInstance(provider));
  134.         }
  135.        
  136.         private static short Parse(string s, NumberStyles style, NumberFormatInfo info)
  137.         {
  138.            
  139.             int i = 0;
  140.             try {
  141.                 i = Number.ParseInt32(s, style, info);
  142.             }
  143.             catch (OverflowException e) {
  144.                 throw new OverflowException(Environment.GetResourceString("Overflow_Int16"), e);
  145.             }
  146.            
  147.             // We need this check here since we don't allow signs to specified in hex numbers. So we fixup the result
  148.             // for negative numbers
  149.             if ((style & NumberStyles.AllowHexSpecifier) != 0) {
  150.                 // We are parsing a hexadecimal number
  151.                 if ((i < 0) || (i > UInt16.MaxValue)) {
  152.                     throw new OverflowException(Environment.GetResourceString("Overflow_Int16"));
  153.                 }
  154.                 return (short)i;
  155.             }
  156.            
  157.             if (i < MinValue || i > MaxValue)
  158.                 throw new OverflowException(Environment.GetResourceString("Overflow_Int16"));
  159.             return (short)i;
  160.         }
  161.        
  162.         public static bool TryParse(string s, out Int16 result)
  163.         {
  164.             return TryParse(s, NumberStyles.Integer, NumberFormatInfo.CurrentInfo, out result);
  165.         }
  166.        
  167.         public static bool TryParse(string s, NumberStyles style, IFormatProvider provider, out Int16 result)
  168.         {
  169.             NumberFormatInfo.ValidateParseStyleInteger(style);
  170.             return TryParse(s, style, NumberFormatInfo.GetInstance(provider), out result);
  171.         }
  172.        
  173.         private static bool TryParse(string s, NumberStyles style, NumberFormatInfo info, out Int16 result)
  174.         {
  175.            
  176.             result = 0;
  177.             int i;
  178.             if (!Number.TryParseInt32(s, style, info, out i)) {
  179.                 return false;
  180.             }
  181.            
  182.             // We need this check here since we don't allow signs to specified in hex numbers. So we fixup the result
  183.             // for negative numbers
  184.             if ((style & NumberStyles.AllowHexSpecifier) != 0) {
  185.                 // We are parsing a hexadecimal number
  186.                 if ((i < 0) || i > UInt16.MaxValue) {
  187.                     return false;
  188.                 }
  189.                 result = (Int16)i;
  190.                 return true;
  191.             }
  192.            
  193.             if (i < MinValue || i > MaxValue) {
  194.                 return false;
  195.             }
  196.             result = (Int16)i;
  197.             return true;
  198.         }
  199.        
  200.         //
  201.         // IValue implementation
  202.         //
  203.        
  204.         public TypeCode GetTypeCode()
  205.         {
  206.             return TypeCode.Int16;
  207.         }
  208.        
  209.        
  210.         /// <internalonly/>
  211.         bool IConvertible.ToBoolean(IFormatProvider provider)
  212.         {
  213.             return Convert.ToBoolean(m_value);
  214.         }
  215.        
  216.         /// <internalonly/>
  217.         char IConvertible.ToChar(IFormatProvider provider)
  218.         {
  219.             return Convert.ToChar(m_value);
  220.         }
  221.        
  222.         /// <internalonly/>
  223.         sbyte IConvertible.ToSByte(IFormatProvider provider)
  224.         {
  225.             return Convert.ToSByte(m_value);
  226.         }
  227.        
  228.         /// <internalonly/>
  229.         byte IConvertible.ToByte(IFormatProvider provider)
  230.         {
  231.             return Convert.ToByte(m_value);
  232.         }
  233.        
  234.         /// <internalonly/>
  235.         short IConvertible.ToInt16(IFormatProvider provider)
  236.         {
  237.             return m_value;
  238.         }
  239.        
  240.         /// <internalonly/>
  241.         ushort IConvertible.ToUInt16(IFormatProvider provider)
  242.         {
  243.             return Convert.ToUInt16(m_value);
  244.         }
  245.        
  246.         /// <internalonly/>
  247.         int IConvertible.ToInt32(IFormatProvider provider)
  248.         {
  249.             return Convert.ToInt32(m_value);
  250.         }
  251.        
  252.         /// <internalonly/>
  253.         uint IConvertible.ToUInt32(IFormatProvider provider)
  254.         {
  255.             return Convert.ToUInt32(m_value);
  256.         }
  257.        
  258.         /// <internalonly/>
  259.         long IConvertible.ToInt64(IFormatProvider provider)
  260.         {
  261.             return Convert.ToInt64(m_value);
  262.         }
  263.        
  264.         /// <internalonly/>
  265.         ulong IConvertible.ToUInt64(IFormatProvider provider)
  266.         {
  267.             return Convert.ToUInt64(m_value);
  268.         }
  269.        
  270.         /// <internalonly/>
  271.         float IConvertible.ToSingle(IFormatProvider provider)
  272.         {
  273.             return Convert.ToSingle(m_value);
  274.         }
  275.        
  276.         /// <internalonly/>
  277.         double IConvertible.ToDouble(IFormatProvider provider)
  278.         {
  279.             return Convert.ToDouble(m_value);
  280.         }
  281.        
  282.         /// <internalonly/>
  283.         decimal IConvertible.ToDecimal(IFormatProvider provider)
  284.         {
  285.             return Convert.ToDecimal(m_value);
  286.         }
  287.        
  288.         /// <internalonly/>
  289.         DateTime IConvertible.ToDateTime(IFormatProvider provider)
  290.         {
  291.             throw new InvalidCastException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("InvalidCast_FromTo"), "Int16", "DateTime"));
  292.         }
  293.        
  294.         /// <internalonly/>
  295.         object IConvertible.ToType(Type type, IFormatProvider provider)
  296.         {
  297.             return Convert.DefaultToType((IConvertible)this, type, provider);
  298.         }
  299.     }
  300. }

Developer Fusion