The Labs \ Source Viewer \ SSCLI \ System \ Int32

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

Developer Fusion