mcs/class/corlib/System/BitConverter.cs

   1 //
   2 // System.BitConverter.cs
   3 //
   4 // Author:
   5 //   Matt Kimball (matt@kimball.net)
   6 //
   7
   8 //
   9 // Copyright (C) 2004 Novell, Inc (http://www.novell.com)
  10 //
  11 // Permission is hereby granted, free of charge, to any person obtaining
  12 // a copy of this software and associated documentation files (the
  13 // "Software"), to deal in the Software without restriction, including
  14 // without limitation the rights to use, copy, modify, merge, publish,
  15 // distribute, sublicense, and/or sell copies of the Software, and to
  16 // permit persons to whom the Software is furnished to do so, subject to
  17 // the following conditions:
  18 //
  19 // The above copyright notice and this permission notice shall be
  20 // included in all copies or substantial portions of the Software.
  21 //
  22 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  23 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  24 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  25 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  26 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  27 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  28 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  29 //
  30
  31 namespace System
  32 {
  33         public sealed class BitConverter
  34         {
  35                 public static readonly bool IsLittleEndian = AmILittleEndian ();
  36
  37                 private BitConverter ()
  38                 {
  39                 }
  40
  41                 static bool AmILittleEndian ()
  42                 {
  43                         byte[] one = GetBytes ((int) 1);
  44                         return (one [0] == 1);
  45                 }
  46
  47                 public static long DoubleToInt64Bits (double value)
  48                 {
  49                         return ToInt64 (GetBytes (value), 0);
  50                 }
  51
  52                 public static double Int64BitsToDouble (long value)
  53                 {
  54                         return ToDouble (GetBytes (value), 0);
  55                 }
  56
  57                 unsafe static byte[] GetBytes (byte *ptr, int count)
  58                 {
  59                         byte [] ret = new byte [count];
  60
  61                         for (int i = 0; i < count; i++) {
  62                                 ret [i] = ptr [i];
  63                         }
  64
  65                         return ret;
  66                 }
  67
  68                 unsafe public static byte[] GetBytes (bool value)
  69                 {
  70                         return GetBytes ((byte *) &value, 1);
  71                 }
  72
  73                 unsafe public static byte[] GetBytes (char value)
  74                 {
  75                         return GetBytes ((byte *) &value, 2);
  76                 }
  77
  78                 unsafe public static byte[] GetBytes (short value)
  79                 {
  80                         return GetBytes ((byte *) &value, 2);
  81                 }
  82
  83                 unsafe public static byte[] GetBytes (int value)
  84                 {
  85                         return GetBytes ((byte *) &value, 4);
  86                 }
  87
  88                 unsafe public static byte[] GetBytes (long value)
  89                 {
  90                         return GetBytes ((byte *) &value, 8);
  91                 }
  92
  93                 [CLSCompliant (false)]
  94                 unsafe public static byte[] GetBytes (ushort value)
  95                 {
  96                         return GetBytes ((byte *) &value, 2);
  97                 }
  98
  99                 [CLSCompliant (false)]
 100                 unsafe public static byte[] GetBytes (uint value)
 101                 {
 102                         return GetBytes ((byte *) &value, 4);
 103                 }
 104
 105                 [CLSCompliant (false)]
 106                 unsafe public static byte[] GetBytes (ulong value)
 107                 {
 108                         return GetBytes ((byte *) &value, 8);
 109                 }
 110
 111                 unsafe public static byte[] GetBytes (float value)
 112                 {
 113                         return GetBytes ((byte *) &value, 4);
 114                 }
 115
 116                 unsafe public static byte[] GetBytes (double value)
 117                 {
 118                         return GetBytes ((byte *) &value, 8);
 119                 }
 120
 121                 unsafe static void PutBytes (byte *dst, byte[] src, int start_index, int count)
 122                 {
 123                         if (src == null) {
 124                                 throw new ArgumentNullException ("value"); // gets called from methods with value params
 125                         }
 126
 127                         if (start_index < 0)
 128                                 throw new ArgumentOutOfRangeException ("startIndex < 0");
 129
 130                         // avoid integer overflow (with large pos/neg start_index values)
 131                         if (src.Length - count < start_index) {
 132                                 throw new ArgumentOutOfRangeException (Locale.GetText (
 133                                         "Value is too big to return the requested type."), "startIndex");
 134                         }
 135
 136                         for (int i = 0; i < count; i++) {
 137                                 dst[i] = src[i + start_index];
 138                         }
 139                 }
 140
 141                 unsafe public static bool ToBoolean (byte[] value, int startIndex)
 142                 {
 143                         if (value == null)
 144                                 throw new ArgumentNullException ("value");
 145
 146                         if (startIndex < 0)
 147                                 throw new ArgumentOutOfRangeException ("startIndex < 0");
 148
 149                         // avoid integer overflow (with large pos/neg start_index values)
 150                         if (value.Length - 1 < startIndex)
 151                                 throw new ArgumentOutOfRangeException (Locale.GetText (
 152                                         "Value is too big to return the requested type."), "startIndex");
 153
 154                         if (value [startIndex] != 0)
 155                                 return true;
 156
 157                         return false;
 158                 }
 159
 160                 unsafe public static char ToChar (byte[] value, int startIndex)
 161                 {
 162                         char ret;
 163
 164                         PutBytes ((byte *) &ret, value, startIndex, 2);
 165
 166                         return ret;
 167                 }
 168
 169                 unsafe public static short ToInt16 (byte[] value, int startIndex)
 170                 {
 171                         short ret;
 172
 173                         PutBytes ((byte *) &ret, value, startIndex, 2);
 174
 175                         return ret;
 176                 }
 177
 178                 unsafe public static int ToInt32 (byte[] value, int startIndex)
 179                 {
 180                         int ret;
 181
 182                         PutBytes ((byte *) &ret, value, startIndex, 4);
 183
 184                         return ret;
 185                 }
 186
 187                 unsafe public static long ToInt64 (byte[] value, int startIndex)
 188                 {
 189                         long ret;
 190
 191                         PutBytes ((byte *) &ret, value, startIndex, 8);
 192
 193                         return ret;
 194                 }
 195
 196                 [CLSCompliant (false)]
 197                 unsafe public static ushort ToUInt16 (byte[] value, int startIndex)
 198                 {
 199                         ushort ret;
 200
 201                         PutBytes ((byte *) &ret, value, startIndex, 2);
 202
 203                         return ret;
 204                 }
 205
 206                 [CLSCompliant (false)]
 207                 unsafe public static uint ToUInt32 (byte[] value, int startIndex)
 208                 {
 209                         uint ret;
 210
 211                         PutBytes ((byte *) &ret, value, startIndex, 4);
 212
 213                         return ret;
 214                 }
 215
 216                 [CLSCompliant (false)]
 217                 unsafe public static ulong ToUInt64 (byte[] value, int startIndex)
 218                 {
 219                         ulong ret;
 220
 221                         PutBytes ((byte *) &ret, value, startIndex, 8);
 222
 223                         return ret;
 224                 }
 225
 226                 unsafe public static float ToSingle (byte[] value, int startIndex)
 227                 {
 228                         float ret;
 229
 230                         PutBytes ((byte *) &ret, value, startIndex, 4);
 231
 232                         return ret;
 233                 }
 234
 235                 unsafe public static double ToDouble (byte[] value, int startIndex)
 236                 {
 237                         double ret;
 238
 239                         PutBytes ((byte *) &ret, value, startIndex, 8);
 240
 241                         return ret;
 242                 }
 243
 244                 public static string ToString (byte[] value)
 245                 {
 246                         if (value == null) {
 247                                 throw new ArgumentNullException ("value");
 248                         }
 249
 250                         return ToString (value, 0, value.Length);
 251                 }
 252
 253                 public static string ToString (byte[] value, int startIndex)
 254                 {
 255                         if (value == null)
 256                                 throw new ArgumentNullException ("value");
 257                         if (startIndex < 0 || startIndex > value.Length - 1)
 258                                 throw new ArgumentOutOfRangeException ("startIndex");
 259
 260                         return ToString (value, startIndex, value.Length - startIndex);
 261                 }
 262
 263                 public static string ToString (byte[] value, int startIndex, int length)
 264                 {
 265                         if (value == null) {
 266                                 throw new ArgumentNullException ("value");
 267                         }
 268
 269                         // The 4th and last clause (start_index >= value.Length)
 270                         // was added as a small fix to a very obscure bug.
 271                         // It makes a small difference when start_index is
 272                         // outside the range and length==0.
 273                         if (startIndex < 0 || length < 0 || startIndex >= value.Length)
 274                                 throw new ArgumentOutOfRangeException ("startIndex");
 275                         // note: re-ordered to avoid possible integer overflow
 276                         if (startIndex > value.Length - length)
 277                                 throw new ArgumentException ("startIndex + length > value.Length");
 278
 279                         string ret = "";
 280                         int end = startIndex + length;
 281
 282                         for (int i = startIndex; i < end; i++) {
 283                                 if (i > startIndex)
 284                                         ret = ret + '-';
 285
 286                                 char high = (char)((value[i] >> 4) & 0x0f);
 287                                 char low = (char)(value[i] & 0x0f);
 288
 289                                 if (high < 10)
 290                                         high += '0';
 291                                 else {
 292                                         high -= (char) 10;
 293                                         high += 'A';
 294                                 }
 295
 296                                 if (low < 10)
 297                                         low += '0';
 298                                 else {
 299                                         low -= (char) 10;
 300                                         low += 'A';
 301                                 }
 302                                 ret = ret + high + low;
 303                         }
 304
 305                         return ret;
 306                 }
 307         }
 308 }