netcore/System.Private.CoreLib/shared/System/Int32.cs

   1 // Licensed to the .NET Foundation under one or more agreements.
   2 // The .NET Foundation licenses this file to you under the MIT license.
   3 // See the LICENSE file in the project root for more information.
   4
   5 using System.Globalization;
   6 using System.Runtime.CompilerServices;
   7 using System.Runtime.InteropServices;
   8 using System.Runtime.Versioning;
   9
  10 namespace System
  11 {
  12     [Serializable]
  13     [StructLayout(LayoutKind.Sequential)]
  14     [TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
  15     public readonly struct Int32 : IComparable, IConvertible, IFormattable, IComparable<int>, IEquatable<int>, ISpanFormattable
  16     {
  17         private readonly int m_value; // Do not rename (binary serialization)
  18
  19         public const int MaxValue = 0x7fffffff;
  20         public const int MinValue = unchecked((int)0x80000000);
  21
  22         // Compares this object to another object, returning an integer that
  23         // indicates the relationship.
  24         // Returns :
  25         // 0 if the values are equal
  26         // Negative number if _value is less than value
  27         // Positive number if _value is more than value
  28         // null is considered to be less than any instance, hence returns positive number
  29         // If object is not of type Int32, this method throws an ArgumentException.
  30         //
  31         public int CompareTo(object? value)
  32         {
  33             if (value == null)
  34             {
  35                 return 1;
  36             }
  37             if (value is int)
  38             {
  39                 // NOTE: Cannot use return (_value - value) as this causes a wrap
  40                 // around in cases where _value - value > MaxValue.
  41                 int i = (int)value;
  42                 if (m_value < i) return -1;
  43                 if (m_value > i) return 1;
  44                 return 0;
  45             }
  46             throw new ArgumentException(SR.Arg_MustBeInt32);
  47         }
  48
  49         public int CompareTo(int value)
  50         {
  51             // NOTE: Cannot use return (_value - value) as this causes a wrap
  52             // around in cases where _value - value > MaxValue.
  53             if (m_value < value) return -1;
  54             if (m_value > value) return 1;
  55             return 0;
  56         }
  57
  58         public override bool Equals(object? obj)
  59         {
  60             if (!(obj is int))
  61             {
  62                 return false;
  63             }
  64             return m_value == ((int)obj).m_value;
  65         }
  66
  67         [NonVersionable]
  68         public bool Equals(int obj)
  69         {
  70             return m_value == obj;
  71         }
  72
  73         // The absolute value of the int contained.
  74         public override int GetHashCode()
  75         {
  76             return m_value;
  77         }
  78
  79         public override string ToString()
  80         {
  81             return Number.FormatInt32(m_value, null, null);
  82         }
  83
  84         public string ToString(string? format)
  85         {
  86             return Number.FormatInt32(m_value, format, null);
  87         }
  88
  89         public string ToString(IFormatProvider? provider)
  90         {
  91             return Number.FormatInt32(m_value, null, provider);
  92         }
  93
  94         public string ToString(string? format, IFormatProvider? provider)
  95         {
  96             return Number.FormatInt32(m_value, format, provider);
  97         }
  98
  99         public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format = default, IFormatProvider? provider = null)
 100         {
 101             return Number.TryFormatInt32(m_value, format, provider, destination, out charsWritten);
 102         }
 103
 104         public static int Parse(string s)
 105         {
 106             if (s == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
 107             return Number.ParseInt32(s, NumberStyles.Integer, NumberFormatInfo.CurrentInfo);
 108         }
 109
 110         public static int Parse(string s, NumberStyles style)
 111         {
 112             NumberFormatInfo.ValidateParseStyleInteger(style);
 113             if (s == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
 114             return Number.ParseInt32(s, style, NumberFormatInfo.CurrentInfo);
 115         }
 116
 117         // Parses an integer from a String in the given style.  If
 118         // a NumberFormatInfo isn't specified, the current culture's
 119         // NumberFormatInfo is assumed.
 120         //
 121         public static int Parse(string s, IFormatProvider? provider)
 122         {
 123             if (s == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
 124             return Number.ParseInt32(s, NumberStyles.Integer, NumberFormatInfo.GetInstance(provider));
 125         }
 126
 127         // Parses an integer from a String in the given style.  If
 128         // a NumberFormatInfo isn't specified, the current culture's
 129         // NumberFormatInfo is assumed.
 130         //
 131         public static int Parse(string s, NumberStyles style, IFormatProvider? provider)
 132         {
 133             NumberFormatInfo.ValidateParseStyleInteger(style);
 134             if (s == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
 135             return Number.ParseInt32(s, style, NumberFormatInfo.GetInstance(provider));
 136         }
 137
 138         public static int Parse(ReadOnlySpan<char> s, NumberStyles style = NumberStyles.Integer, IFormatProvider? provider = null)
 139         {
 140             NumberFormatInfo.ValidateParseStyleInteger(style);
 141             return Number.ParseInt32(s, style, NumberFormatInfo.GetInstance(provider));
 142         }
 143
 144         // Parses an integer from a String. Returns false rather
 145         // than throwing exceptin if input is invalid
 146         //
 147         public static bool TryParse(string? s, out int result)
 148         {
 149             if (s == null)
 150             {
 151                 result = 0;
 152                 return false;
 153             }
 154
 155             return Number.TryParseInt32IntegerStyle(s, NumberStyles.Integer, NumberFormatInfo.CurrentInfo, out result) == Number.ParsingStatus.OK;
 156         }
 157
 158         public static bool TryParse(ReadOnlySpan<char> s, out int result)
 159         {
 160             return Number.TryParseInt32IntegerStyle(s, NumberStyles.Integer, NumberFormatInfo.CurrentInfo, out result) == Number.ParsingStatus.OK;
 161         }
 162
 163         // Parses an integer from a String in the given style. Returns false rather
 164         // than throwing exceptin if input is invalid
 165         //
 166         public static bool TryParse(string? s, NumberStyles style, IFormatProvider? provider, out int result)
 167         {
 168             NumberFormatInfo.ValidateParseStyleInteger(style);
 169
 170             if (s == null)
 171             {
 172                 result = 0;
 173                 return false;
 174             }
 175
 176             return Number.TryParseInt32(s, style, NumberFormatInfo.GetInstance(provider), out result) == Number.ParsingStatus.OK;
 177         }
 178
 179         public static bool TryParse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider? provider, out int result)
 180         {
 181             NumberFormatInfo.ValidateParseStyleInteger(style);
 182             return Number.TryParseInt32(s, style, NumberFormatInfo.GetInstance(provider), out result) == Number.ParsingStatus.OK;
 183         }
 184
 185         //
 186         // IConvertible implementation
 187         //
 188
 189         public TypeCode GetTypeCode()
 190         {
 191             return TypeCode.Int32;
 192         }
 193
 194         bool IConvertible.ToBoolean(IFormatProvider? provider)
 195         {
 196             return Convert.ToBoolean(m_value);
 197         }
 198
 199         char IConvertible.ToChar(IFormatProvider? provider)
 200         {
 201             return Convert.ToChar(m_value);
 202         }
 203
 204         sbyte IConvertible.ToSByte(IFormatProvider? provider)
 205         {
 206             return Convert.ToSByte(m_value);
 207         }
 208
 209         byte IConvertible.ToByte(IFormatProvider? provider)
 210         {
 211             return Convert.ToByte(m_value);
 212         }
 213
 214         short IConvertible.ToInt16(IFormatProvider? provider)
 215         {
 216             return Convert.ToInt16(m_value);
 217         }
 218
 219         ushort IConvertible.ToUInt16(IFormatProvider? provider)
 220         {
 221             return Convert.ToUInt16(m_value);
 222         }
 223
 224         int IConvertible.ToInt32(IFormatProvider? provider)
 225         {
 226             return m_value;
 227         }
 228
 229         uint IConvertible.ToUInt32(IFormatProvider? provider)
 230         {
 231             return Convert.ToUInt32(m_value);
 232         }
 233
 234         long IConvertible.ToInt64(IFormatProvider? provider)
 235         {
 236             return Convert.ToInt64(m_value);
 237         }
 238
 239         ulong IConvertible.ToUInt64(IFormatProvider? provider)
 240         {
 241             return Convert.ToUInt64(m_value);
 242         }
 243
 244         float IConvertible.ToSingle(IFormatProvider? provider)
 245         {
 246             return Convert.ToSingle(m_value);
 247         }
 248
 249         double IConvertible.ToDouble(IFormatProvider? provider)
 250         {
 251             return Convert.ToDouble(m_value);
 252         }
 253
 254         decimal IConvertible.ToDecimal(IFormatProvider? provider)
 255         {
 256             return Convert.ToDecimal(m_value);
 257         }
 258
 259         DateTime IConvertible.ToDateTime(IFormatProvider? provider)
 260         {
 261             throw new InvalidCastException(SR.Format(SR.InvalidCast_FromTo, "Int32", "DateTime"));
 262         }
 263
 264         object IConvertible.ToType(Type type, IFormatProvider? provider)
 265         {
 266             return Convert.DefaultToType((IConvertible)this, type, provider);
 267         }
 268     }
 269 }