2004-07-17 Martin Baulig <martin@ximian.com>
[mono.git] / mcs / class / corlib / System / Byte.cs
1 //
2 // System.Byte.cs
3 //
4 // Author:
5 //   Miguel de Icaza (miguel@ximian.com)
6 //
7 // (C) Ximian, Inc.  http://www.ximian.com
8 //
9
10 //
11 // Copyright (C) 2004 Novell, Inc (http://www.novell.com)
12 //
13 // Permission is hereby granted, free of charge, to any person obtaining
14 // a copy of this software and associated documentation files (the
15 // "Software"), to deal in the Software without restriction, including
16 // without limitation the rights to use, copy, modify, merge, publish,
17 // distribute, sublicense, and/or sell copies of the Software, and to
18 // permit persons to whom the Software is furnished to do so, subject to
19 // the following conditions:
20 // 
21 // The above copyright notice and this permission notice shall be
22 // included in all copies or substantial portions of the Software.
23 // 
24 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
25 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
26 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
27 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
28 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
29 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
30 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
31 //
32
33 using System.Globalization;
34
35 namespace System
36 {
37         [Serializable]
38         public struct Byte : IFormattable, IConvertible,
39 #if NET_2_0
40                 IComparable, IComparable<Byte>
41 #else
42                 IComparable
43 #endif
44         {
45                 public const byte MinValue = 0;
46                 public const byte MaxValue = 255;
47
48                 internal byte m_value;
49
50                 public int CompareTo (object value)
51                 {
52                         if (value == null)
53                                 return 1;
54
55                         if (!(value is System.Byte))
56                                 throw new ArgumentException (Locale.GetText ("Value is not a System.Byte."));
57
58                         byte xv = (byte) value;
59
60                         if (m_value == xv)
61                                 return 0;
62                         if (m_value > xv)
63                                 return 1;
64                         else
65                                 return -1;
66                 }
67
68                 public override bool Equals (object obj)
69                 {
70                         if (!(obj is System.Byte))
71                                 return false;
72
73                         return ((byte) obj) == m_value;
74                 }
75
76                 public override int GetHashCode ()
77                 {
78                         return m_value;
79                 }
80
81 #if NET_2_0
82                 public int CompareTo (byte value)
83                 {
84                         if (m_value == value)
85                                 return 0;
86                         if (m_value > value)
87                                 return 1;
88                         else
89                                 return -1;
90                 }
91
92                 public bool Equals (byte value)
93                 {
94                         return value == m_value;
95                 }
96 #endif
97
98                 public static byte Parse (string s)
99                 {
100                         byte val = 0;
101                         int len;
102                         int i;
103                         bool digits_seen = false;
104                         bool negative = false;
105
106                         if (s == null)
107                                 throw new ArgumentNullException ("s");
108
109                         len = s.Length;
110
111                         // look for the first non-whitespace character
112                         char c;
113                         for (i = 0; i < len; i++){
114                                 c = s [i];
115                                 if (!Char.IsWhiteSpace (c))
116                                         break;
117                         }
118
119                         // if it's all whitespace, then throw exception
120                         if (i == len)
121                                 throw new FormatException ();
122
123                         // look for the optional '+' sign
124                         if (s [i] == '+')
125                                 i++;
126                         else if (s [i] == '-') {
127                                 negative = true;
128                                 i++;
129                         }
130
131                         // we should just have numerals followed by whitespace now
132                         for (; i < len; i++){
133                                 c = s [i];
134
135                                 if (c >= '0' && c <= '9'){
136                                         // shift left and accumulate every time we find a numeral
137                                         byte d = (byte) (c - '0');
138
139                                         val = checked ((byte) (val * 10 + d));
140                                         digits_seen = true;
141                                 } else {
142                                         // after the last numeral, only whitespace is allowed
143                                         if (Char.IsWhiteSpace (c)){
144                                                 for (i++; i < len; i++){
145                                                         if (!Char.IsWhiteSpace (s [i]))
146                                                                 throw new FormatException ();
147                                                 }
148                                                 break;
149                                         } else
150                                                 throw new FormatException ();
151                                 }
152                         }
153
154                         // -0 is legal but other negative values are not
155                         if (negative && (val > 0)) {
156                                 throw new OverflowException (
157                                         Locale.GetText ("Negative number"));
158                         }
159
160                         // if all we had was a '+' sign, then throw exception
161                         if (!digits_seen)
162                                 throw new FormatException ();
163
164                         return val;
165                 }
166
167                 public static byte Parse (string s, IFormatProvider provider)
168                 {
169                         return Parse (s, NumberStyles.Integer, provider);
170                 }
171
172                 public static byte Parse (string s, NumberStyles style)
173                 {
174                         return Parse (s, style, null);
175                 }
176
177                 public static byte Parse (string s, NumberStyles style, IFormatProvider provider)
178                 {
179                         uint tmpResult = UInt32.Parse (s, style, provider);
180                         if (tmpResult > Byte.MaxValue || tmpResult < Byte.MinValue)
181                                 throw new OverflowException (Locale.GetText ("Value too large or too small."));
182
183                         return (byte) tmpResult;
184                 }
185
186                 public override string ToString ()
187                 {
188                         return ToString (null, null);
189                 }
190
191                 public string ToString (string format)
192                 {
193                         return ToString (format, null);
194                 }
195
196                 public string ToString (IFormatProvider provider)
197                 {
198                         return ToString (null, provider);
199                 }
200
201                 public string ToString (string format, IFormatProvider provider)
202                 {
203                         NumberFormatInfo nfi = NumberFormatInfo.GetInstance (provider);
204
205                         // null or empty ("")
206                         if ((format == null) || (format.Length == 0))
207                                 format = "G";
208
209                         return IntegerFormatter.NumberToString (format, nfi, m_value);
210                 }
211
212                 // =========== IConvertible Methods =========== //
213                 public TypeCode GetTypeCode ()
214                 {
215                         return TypeCode.Byte;
216                 }
217
218                 object IConvertible.ToType (Type conversionType, IFormatProvider provider)
219                 {
220                         return System.Convert.ToType (m_value, conversionType, provider);
221                 }
222
223                 bool IConvertible.ToBoolean (IFormatProvider provider)
224                 {
225                         return System.Convert.ToBoolean (m_value);
226                 }
227
228                 byte IConvertible.ToByte (IFormatProvider provider)
229                 {
230                         return m_value;
231                 }
232
233                 char IConvertible.ToChar (IFormatProvider provider)
234                 {
235                         return System.Convert.ToChar (m_value);
236                 }
237
238                 DateTime IConvertible.ToDateTime (IFormatProvider provider)
239                 {
240                         throw new InvalidCastException ();
241                 }
242
243                 decimal IConvertible.ToDecimal (IFormatProvider provider)
244                 {
245                         return System.Convert.ToDecimal (m_value);
246                 }
247
248                 double IConvertible.ToDouble (IFormatProvider provider)
249                 {
250                         return System.Convert.ToDouble (m_value);
251                 }
252
253                 short IConvertible.ToInt16 (IFormatProvider provider)
254                 {
255                         return System.Convert.ToInt16 (m_value);
256                 }
257
258                 int IConvertible.ToInt32 (IFormatProvider provider)
259                 {
260                         return System.Convert.ToInt32 (m_value);
261                 }
262
263                 long IConvertible.ToInt64 (IFormatProvider provider)
264                 {
265                         return System.Convert.ToInt64 (m_value);
266                 }
267
268                 sbyte IConvertible.ToSByte (IFormatProvider provider)
269                 {
270                         return System.Convert.ToSByte (m_value);
271                 }
272
273                 float IConvertible.ToSingle (IFormatProvider provider)
274                 {
275                         return System.Convert.ToSingle (m_value);
276                 }
277
278 /*
279                 string IConvertible.ToString (IFormatProvider provider)
280                 {
281                         return ToString("G", provider);
282                 }
283 */
284
285                 ushort IConvertible.ToUInt16 (IFormatProvider provider)
286                 {
287                         return System.Convert.ToUInt16 (m_value);
288                 }
289
290                 uint IConvertible.ToUInt32 (IFormatProvider provider)
291                 {
292                         return System.Convert.ToUInt32 (m_value);
293                 }
294
295                 ulong IConvertible.ToUInt64 (IFormatProvider provider)
296                 {
297                         return System.Convert.ToUInt64 (m_value);
298                 }
299         }
300 }