mcs/class/corlib/System.Runtime.Serialization.Formatters.Binary/BinaryCommon.cs

   1 // BinaryCommon.cs
   2 //
   3 // Author:
   4 //   Lluis Sanchez Gual (lluis@ideary.com)
   5 //
   6 // (C) 2003 Lluis Sanchez Gual
   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 using System;
  32
  33 namespace System.Runtime.Serialization.Formatters.Binary
  34 {
  35         internal class BinaryCommon
  36         {
  37                 // Header present in all binary serializations
  38                 public static byte[] BinaryHeader = new Byte[] {0,1,0,0,0,255,255,255,255,1,0,0,0,0,0,0,0};
  39
  40                 static Type[] _typeCodesToType;
  41                 static byte[] _typeCodeMap;
  42                 public static bool UseReflectionSerialization = false;
  43
  44                 static BinaryCommon()
  45                 {
  46                         _typeCodesToType = new Type [19];
  47                         _typeCodesToType[(int)BinaryTypeCode.Boolean] = typeof (Boolean);
  48                         _typeCodesToType[(int)BinaryTypeCode.Byte] = typeof (Byte);
  49                         _typeCodesToType[(int)BinaryTypeCode.Char] = typeof (Char);
  50                         _typeCodesToType[(int)BinaryTypeCode.TimeSpan] = typeof (TimeSpan);
  51                         _typeCodesToType[(int)BinaryTypeCode.DateTime] = typeof (DateTime);
  52                         _typeCodesToType[(int)BinaryTypeCode.Decimal] = typeof (Decimal);
  53                         _typeCodesToType[(int)BinaryTypeCode.Double] = typeof (Double);
  54                         _typeCodesToType[(int)BinaryTypeCode.Int16] = typeof (Int16);
  55                         _typeCodesToType[(int)BinaryTypeCode.Int32] = typeof (Int32);
  56                         _typeCodesToType[(int)BinaryTypeCode.Int64] = typeof (Int64);
  57                         _typeCodesToType[(int)BinaryTypeCode.SByte] = typeof (SByte);
  58                         _typeCodesToType[(int)BinaryTypeCode.Single] = typeof (Single);
  59                         _typeCodesToType[(int)BinaryTypeCode.UInt16] = typeof (UInt16);
  60                         _typeCodesToType[(int)BinaryTypeCode.UInt32] = typeof (UInt32);
  61                         _typeCodesToType[(int)BinaryTypeCode.UInt64] = typeof (UInt64);
  62                         _typeCodesToType[(int)BinaryTypeCode.Null] = null;
  63                         _typeCodesToType[(int)BinaryTypeCode.String] = typeof (string);
  64
  65                         _typeCodeMap = new byte[30];
  66                         _typeCodeMap[(int)TypeCode.Boolean] = (byte) BinaryTypeCode.Boolean;
  67                         _typeCodeMap[(int)TypeCode.Byte] = (byte) BinaryTypeCode.Byte;
  68                         _typeCodeMap[(int)TypeCode.Char] = (byte) BinaryTypeCode.Char;
  69                         _typeCodeMap[(int)TypeCode.DateTime] = (byte) BinaryTypeCode.DateTime;
  70                         _typeCodeMap[(int)TypeCode.Decimal] = (byte) BinaryTypeCode.Decimal;
  71                         _typeCodeMap[(int)TypeCode.Double] = (byte) BinaryTypeCode.Double;
  72                         _typeCodeMap[(int)TypeCode.Int16] = (byte) BinaryTypeCode.Int16;
  73                         _typeCodeMap[(int)TypeCode.Int32] = (byte) BinaryTypeCode.Int32;
  74                         _typeCodeMap[(int)TypeCode.Int64] = (byte) BinaryTypeCode.Int64;
  75                         _typeCodeMap[(int)TypeCode.SByte] = (byte) BinaryTypeCode.SByte;
  76                         _typeCodeMap[(int)TypeCode.Single] = (byte) BinaryTypeCode.Single;
  77                         _typeCodeMap[(int)TypeCode.UInt16] = (byte) BinaryTypeCode.UInt16;
  78                         _typeCodeMap[(int)TypeCode.UInt32] = (byte) BinaryTypeCode.UInt32;
  79                         _typeCodeMap[(int)TypeCode.UInt64] = (byte) BinaryTypeCode.UInt64;
  80                         _typeCodeMap[(int)TypeCode.String] = (byte) BinaryTypeCode.String;
  81
  82                         // TimeStamp does not have a TypeCode, so it is managed as a special
  83                         // case in GetTypeCode()
  84
  85                         // This environment variable is only for test and benchmarking pourposes.
  86                         // By default, mono will always use IL generated class serializers.
  87                         string s = Environment.GetEnvironmentVariable("MONO_REFLECTION_SERIALIZER");
  88                         if (s == null) s = "no";
  89                         UseReflectionSerialization = (s != "no");
  90                 }
  91
  92                 public static bool IsPrimitive (Type type)
  93                 {
  94                         return (type.IsPrimitive && type != typeof (IntPtr)) ||
  95                                 type == typeof (DateTime) ||
  96                                 type == typeof (TimeSpan) ||
  97                                 type == typeof (Decimal);
  98                 }
  99
 100                 public static byte GetTypeCode (Type type)
 101                 {
 102                         if (type == typeof(TimeSpan)) return (byte) BinaryTypeCode.TimeSpan;
 103                         else return _typeCodeMap [(int)Type.GetTypeCode(type)];
 104                 }
 105
 106                 public static Type GetTypeFromCode (int code)
 107                 {
 108                         return _typeCodesToType [code];
 109                 }
 110
 111                 public static void CheckSerializable (Type type, ISurrogateSelector selector, StreamingContext context)
 112                 {
 113                         if (!type.IsSerializable && !type.IsInterface)
 114                         {
 115                                 if (selector != null && selector.GetSurrogate (type, context, out selector) != null)
 116                                         return;
 117
 118                                 throw new SerializationException ("Type " + type + " is not marked as Serializable.");
 119                         }
 120                 }
 121
 122                 public static void SwapBytes (byte[] byteArray, int size, int dataSize)
 123                 {
 124                         byte b;
 125                         if (dataSize == 8) {
 126                                 for (int n=0; n<size; n+=8) {
 127                                         b = byteArray [n]; byteArray [n] = byteArray [n + 7]; byteArray [n + 7] = b;
 128                                         b = byteArray [n+1]; byteArray [n+1] = byteArray [n + 6]; byteArray [n + 6] = b;
 129                                         b = byteArray [n+2]; byteArray [n+2] = byteArray [n + 5]; byteArray [n + 5] = b;
 130                                         b = byteArray [n+3]; byteArray [n+3] = byteArray [n + 4]; byteArray [n + 4] = b;
 131                                 }
 132                         } else if (dataSize == 4) {
 133                                 for (int n=0; n<size; n+=4) {
 134                                         b = byteArray [n]; byteArray [n] = byteArray [n + 3]; byteArray [n + 3] = b;
 135                                         b = byteArray [n+1]; byteArray [n+1] = byteArray [n + 2]; byteArray [n + 2] = b;
 136                                 }
 137                         } else if (dataSize == 2) {
 138                                 for (int n=0; n<size; n+=2) {
 139                                         b = byteArray [n]; byteArray [n] = byteArray [n + 1]; byteArray [n + 1] = b;
 140                                 }
 141                         }
 142                 }
 143         }
 144
 145         internal enum BinaryElement : byte
 146         {
 147                 Header = 0,
 148                 RefTypeObject = 1,
 149                 UntypedRuntimeObject = 2,
 150                 UntypedExternalObject = 3,
 151                 RuntimeObject = 4,
 152                 ExternalObject = 5,
 153                 String = 6,
 154                 GenericArray = 7,
 155                 BoxedPrimitiveTypeValue = 8,
 156                 ObjectReference = 9,
 157                 NullValue = 10,
 158                 End = 11,
 159                 Assembly = 12,
 160                 ArrayFiller8b = 13,
 161                 ArrayFiller32b = 14,
 162                 ArrayOfPrimitiveType = 15,
 163                 ArrayOfObject = 16,
 164                 ArrayOfString = 17,
 165                 Method = 18,
 166                 _Unknown4 = 19,
 167                 _Unknown5 = 20,
 168                 MethodCall = 21,
 169                 MethodResponse = 22
 170         }
 171
 172         internal enum TypeTag : byte
 173         {
 174                 PrimitiveType = 0,
 175                 String = 1,
 176                 ObjectType = 2,
 177                 RuntimeType = 3,
 178                 GenericType = 4,
 179                 ArrayOfObject = 5,
 180                 ArrayOfString = 6,
 181                 ArrayOfPrimitiveType = 7
 182         }
 183
 184         internal enum ArrayStructure : byte
 185         {
 186                 SingleDimensional = 0,
 187                 Jagged = 1,
 188                 MultiDimensional = 2
 189         }
 190
 191         internal enum MethodFlags
 192         {
 193                 NoArguments = 1,
 194                 PrimitiveArguments = 2,
 195                 ArgumentsInSimpleArray = 4,
 196                 ArgumentsInMultiArray = 8,
 197                 ExcludeLogicalCallContext = 16,
 198                 IncludesLogicalCallContext = 64,
 199                 IncludesSignature = 128,
 200
 201                 FormatMask = 15,
 202
 203 #if NET_2_0
 204                 GenericArguments = 0x8000,
 205                 NeedsInfoArrayMask = 4 + 8 + 64 + 128 + 0x8000,
 206 #else
 207                 NeedsInfoArrayMask = 4 + 8 + 64 + 128,
 208 #endif
 209         }
 210
 211         internal enum ReturnTypeTag : byte
 212         {
 213                 Null = 2,
 214                 PrimitiveType = 8,
 215                 ObjectType = 16,
 216                 Exception = 32
 217         }
 218
 219         enum BinaryTypeCode : byte
 220         {
 221                 Boolean = 1,
 222                 Byte = 2,
 223                 Char = 3,
 224                 Decimal = 5,
 225                 Double = 6,
 226                 Int16 = 7,
 227                 Int32 = 8,
 228                 Int64 = 9,
 229                 SByte = 10,
 230                 Single = 11,
 231                 TimeSpan = 12,
 232                 DateTime = 13,
 233                 UInt16 = 14,
 234                 UInt32 = 15,
 235                 UInt64 = 16,
 236                 Null = 17,
 237                 String = 18
 238         }
 239
 240 }