The Labs \ Source Viewer \ SSCLI \ System \ Int64

  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:  Int64.cs
  18. **
  19. **
  20. ** Purpose: This class will encapsulate a long 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.     [Serializable(), System.Runtime.InteropServices.StructLayout(LayoutKind.Sequential)]
  33.     [System.Runtime.InteropServices.ComVisible(true)]
  34.     public struct Int64 : IComparable, IFormattable, IConvertible, IComparable<Int64>, IEquatable<Int64>
  35.     {
  36.         internal long m_value;
  37.        
  38.         public const long MaxValue = 9223372036854775807l;
  39.         public const long MinValue = unchecked((long)9223372036854775808ul);
  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 Int64, 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 Int64) {
  53.                 // Need to use compare because subtraction will wrap
  54.                 // to positive for very large neg numbers, etc.
  55.                 long i = (long)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_MustBeInt64"));
  63.         }
  64.        
  65.         public int CompareTo(Int64 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 Int64)) {
  79.                 return false;
  80.             }
  81.             return m_value == ((Int64)obj).m_value;
  82.         }
  83.        
  84.         public bool Equals(Int64 obj)
  85.         {
  86.             return m_value == obj;
  87.         }
  88.        
  89.         // The value of the lower 32 bits XORed with the uppper 32 bits.
  90.         public override int GetHashCode()
  91.         {
  92.             return (unchecked((int)((long)m_value)) ^ (int)(m_value >> 32));
  93.         }
  94.        
  95.         public override string ToString()
  96.         {
  97.             return Number.FormatInt64(m_value, null, NumberFormatInfo.CurrentInfo);
  98.         }
  99.        
  100.         public string ToString(IFormatProvider provider)
  101.         {
  102.             return Number.FormatInt64(m_value, null, NumberFormatInfo.GetInstance(provider));
  103.         }
  104.        
  105.         public string ToString(string format)
  106.         {
  107.             return Number.FormatInt64(m_value, format, NumberFormatInfo.CurrentInfo);
  108.         }
  109.        
  110.         public string ToString(string format, IFormatProvider provider)
  111.         {
  112.             return Number.FormatInt64(m_value, format, NumberFormatInfo.GetInstance(provider));
  113.         }
  114.        
  115.         public static long Parse(string s)
  116.         {
  117.             return Number.ParseInt64(s, NumberStyles.Integer, NumberFormatInfo.CurrentInfo);
  118.         }
  119.        
  120.         public static long Parse(string s, NumberStyles style)
  121.         {
  122.             NumberFormatInfo.ValidateParseStyleInteger(style);
  123.             return Number.ParseInt64(s, style, NumberFormatInfo.CurrentInfo);
  124.         }
  125.        
  126.         public static long Parse(string s, IFormatProvider provider)
  127.         {
  128.             return Number.ParseInt64(s, NumberStyles.Integer, NumberFormatInfo.GetInstance(provider));
  129.         }
  130.        
  131.        
  132.         // Parses a long from a String in the given style. If
  133.         // a NumberFormatInfo isn't specified, the current culture's
  134.         // NumberFormatInfo is assumed.
  135.         //
  136.         public static long Parse(string s, NumberStyles style, IFormatProvider provider)
  137.         {
  138.             NumberFormatInfo.ValidateParseStyleInteger(style);
  139.             return Number.ParseInt64(s, style, NumberFormatInfo.GetInstance(provider));
  140.         }
  141.        
  142.         public static bool TryParse(string s, out Int64 result)
  143.         {
  144.             return Number.TryParseInt64(s, NumberStyles.Integer, NumberFormatInfo.CurrentInfo, out result);
  145.         }
  146.        
  147.         public static bool TryParse(string s, NumberStyles style, IFormatProvider provider, out Int64 result)
  148.         {
  149.             NumberFormatInfo.ValidateParseStyleInteger(style);
  150.             return Number.TryParseInt64(s, style, NumberFormatInfo.GetInstance(provider), out result);
  151.         }
  152.        
  153.         //
  154.         // IValue implementation
  155.         //
  156.        
  157.         public TypeCode GetTypeCode()
  158.         {
  159.             return TypeCode.Int64;
  160.         }
  161.        
  162.         /// <internalonly/>
  163.         bool IConvertible.ToBoolean(IFormatProvider provider)
  164.         {
  165.             return Convert.ToBoolean(m_value);
  166.         }
  167.        
  168.         /// <internalonly/>
  169.         char IConvertible.ToChar(IFormatProvider provider)
  170.         {
  171.             return Convert.ToChar(m_value);
  172.         }
  173.        
  174.         /// <internalonly/>
  175.         sbyte IConvertible.ToSByte(IFormatProvider provider)
  176.         {
  177.             return Convert.ToSByte(m_value);
  178.         }
  179.        
  180.         /// <internalonly/>
  181.         byte IConvertible.ToByte(IFormatProvider provider)
  182.         {
  183.             return Convert.ToByte(m_value);
  184.         }
  185.        
  186.         /// <internalonly/>
  187.         short IConvertible.ToInt16(IFormatProvider provider)
  188.         {
  189.             return Convert.ToInt16(m_value);
  190.         }
  191.        
  192.         /// <internalonly/>
  193.         ushort IConvertible.ToUInt16(IFormatProvider provider)
  194.         {
  195.             return Convert.ToUInt16(m_value);
  196.         }
  197.        
  198.         /// <internalonly/>
  199.         int IConvertible.ToInt32(IFormatProvider provider)
  200.         {
  201.             return Convert.ToInt32(m_value);
  202.         }
  203.        
  204.         /// <internalonly/>
  205.         uint IConvertible.ToUInt32(IFormatProvider provider)
  206.         {
  207.             return Convert.ToUInt32(m_value);
  208.         }
  209.        
  210.         /// <internalonly/>
  211.         long IConvertible.ToInt64(IFormatProvider provider)
  212.         {
  213.             return m_value;
  214.         }
  215.        
  216.         /// <internalonly/>
  217.         ulong IConvertible.ToUInt64(IFormatProvider provider)
  218.         {
  219.             return Convert.ToUInt64(m_value);
  220.         }
  221.        
  222.         /// <internalonly/>
  223.         float IConvertible.ToSingle(IFormatProvider provider)
  224.         {
  225.             return Convert.ToSingle(m_value);
  226.         }
  227.        
  228.         /// <internalonly/>
  229.         double IConvertible.ToDouble(IFormatProvider provider)
  230.         {
  231.             return Convert.ToDouble(m_value);
  232.         }
  233.        
  234.         /// <internalonly/>
  235.         decimal IConvertible.ToDecimal(IFormatProvider provider)
  236.         {
  237.             return Convert.ToDecimal(m_value);
  238.         }
  239.        
  240.         /// <internalonly/>
  241.         DateTime IConvertible.ToDateTime(IFormatProvider provider)
  242.         {
  243.             throw new InvalidCastException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("InvalidCast_FromTo"), "Int64", "DateTime"));
  244.         }
  245.        
  246.         /// <internalonly/>
  247.         object IConvertible.ToType(Type type, IFormatProvider provider)
  248.         {
  249.             return Convert.DefaultToType((IConvertible)this, type, provider);
  250.         }
  251.     }
  252. }

Developer Fusion