The Labs \ Source Viewer \ SSCLI \ System \ SByte

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

Developer Fusion