mcs/class/System.Runtime.Serialization/System.Xml/XmlBinaryDictionaryWriterAutoGen.cs

   1
   2 using System;
   3 using BF = System.Xml.XmlBinaryFormat;
   4
   5 namespace System.Xml
   6 {
   7         internal partial class XmlBinaryDictionaryWriter : XmlDictionaryWriter
   8         {
   9                 void CheckWriteArrayArguments (Array array, int offset, int length)
  10                 {
  11                         if (array == null)
  12                                 throw new ArgumentNullException ("array");
  13                         if (offset < 0)
  14                                 throw new ArgumentOutOfRangeException ("offset is negative");
  15                         if (offset > array.Length)
  16                                 throw new ArgumentOutOfRangeException ("offset exceeds the length of the destination array");
  17                         if (length < 0)
  18                                 throw new ArgumentOutOfRangeException ("length is negative");
  19                         if (length > array.Length - offset)
  20                                 throw new ArgumentOutOfRangeException ("length + offset exceeds the length of the destination array");
  21                 }
  22
  23                 void CheckDictionaryStringArgs (XmlDictionaryString localName, XmlDictionaryString namespaceUri)
  24                 {
  25                         if (localName == null)
  26                                 throw new ArgumentNullException ("localName");
  27                         if (namespaceUri == null)
  28                                 throw new ArgumentNullException ("namespaceUri");
  29                 }
  30
  31
  32
  33                 public override void WriteArray (string prefix, XmlDictionaryString localName, XmlDictionaryString namespaceUri, bool [] array, int offset, int length)
  34                 {
  35                         CheckDictionaryStringArgs (localName, namespaceUri);
  36                         writer.Write (BF.Array);
  37                         WriteStartElement (prefix, localName, namespaceUri);
  38                         WriteEndElement ();
  39                         WriteArrayRemaining (array, offset, length);
  40                 }
  41
  42                 public override void WriteArray (string prefix, string localName, string namespaceUri, bool [] array, int offset, int length)
  43                 {
  44                         CheckWriteArrayArguments (array, offset, length);
  45                         writer.Write (BF.Array);
  46                         WriteStartElement (prefix, localName, namespaceUri);
  47                         WriteEndElement ();
  48                         WriteArrayRemaining (array, offset, length);
  49                 }
  50
  51                 void WriteArrayRemaining (bool [] array, int offset, int length)
  52                 {
  53                         writer.Write ((byte) 0xB5); // ident
  54                         writer.WriteFlexibleInt (length);
  55                         for (int i = offset; i < offset + length; i++)
  56                                 WriteValueContent (array [i]);
  57                 }
  58
  59
  60                 public override void WriteArray (string prefix, XmlDictionaryString localName, XmlDictionaryString namespaceUri, DateTime [] array, int offset, int length)
  61                 {
  62                         CheckDictionaryStringArgs (localName, namespaceUri);
  63                         writer.Write (BF.Array);
  64                         WriteStartElement (prefix, localName, namespaceUri);
  65                         WriteEndElement ();
  66                         WriteArrayRemaining (array, offset, length);
  67                 }
  68
  69                 public override void WriteArray (string prefix, string localName, string namespaceUri, DateTime [] array, int offset, int length)
  70                 {
  71                         CheckWriteArrayArguments (array, offset, length);
  72                         writer.Write (BF.Array);
  73                         WriteStartElement (prefix, localName, namespaceUri);
  74                         WriteEndElement ();
  75                         WriteArrayRemaining (array, offset, length);
  76                 }
  77
  78                 void WriteArrayRemaining (DateTime [] array, int offset, int length)
  79                 {
  80                         writer.Write ((byte) 0x97); // ident
  81                         writer.WriteFlexibleInt (length);
  82                         for (int i = offset; i < offset + length; i++)
  83                                 WriteValueContent (array [i]);
  84                 }
  85
  86
  87                 public override void WriteArray (string prefix, XmlDictionaryString localName, XmlDictionaryString namespaceUri, decimal [] array, int offset, int length)
  88                 {
  89                         CheckDictionaryStringArgs (localName, namespaceUri);
  90                         writer.Write (BF.Array);
  91                         WriteStartElement (prefix, localName, namespaceUri);
  92                         WriteEndElement ();
  93                         WriteArrayRemaining (array, offset, length);
  94                 }
  95
  96                 public override void WriteArray (string prefix, string localName, string namespaceUri, decimal [] array, int offset, int length)
  97                 {
  98                         CheckWriteArrayArguments (array, offset, length);
  99                         writer.Write (BF.Array);
 100                         WriteStartElement (prefix, localName, namespaceUri);
 101                         WriteEndElement ();
 102                         WriteArrayRemaining (array, offset, length);
 103                 }
 104
 105                 void WriteArrayRemaining (decimal [] array, int offset, int length)
 106                 {
 107                         writer.Write ((byte) 0x95); // ident
 108                         writer.WriteFlexibleInt (length);
 109                         for (int i = offset; i < offset + length; i++)
 110                                 WriteValueContent (array [i]);
 111                 }
 112
 113
 114                 public override void WriteArray (string prefix, XmlDictionaryString localName, XmlDictionaryString namespaceUri, double [] array, int offset, int length)
 115                 {
 116                         CheckDictionaryStringArgs (localName, namespaceUri);
 117                         writer.Write (BF.Array);
 118                         WriteStartElement (prefix, localName, namespaceUri);
 119                         WriteEndElement ();
 120                         WriteArrayRemaining (array, offset, length);
 121                 }
 122
 123                 public override void WriteArray (string prefix, string localName, string namespaceUri, double [] array, int offset, int length)
 124                 {
 125                         CheckWriteArrayArguments (array, offset, length);
 126                         writer.Write (BF.Array);
 127                         WriteStartElement (prefix, localName, namespaceUri);
 128                         WriteEndElement ();
 129                         WriteArrayRemaining (array, offset, length);
 130                 }
 131
 132                 void WriteArrayRemaining (double [] array, int offset, int length)
 133                 {
 134                         writer.Write ((byte) 0x93); // ident
 135                         writer.WriteFlexibleInt (length);
 136                         for (int i = offset; i < offset + length; i++)
 137                                 WriteValueContent (array [i]);
 138                 }
 139
 140
 141                 public override void WriteArray (string prefix, XmlDictionaryString localName, XmlDictionaryString namespaceUri, Guid [] array, int offset, int length)
 142                 {
 143                         CheckDictionaryStringArgs (localName, namespaceUri);
 144                         writer.Write (BF.Array);
 145                         WriteStartElement (prefix, localName, namespaceUri);
 146                         WriteEndElement ();
 147                         WriteArrayRemaining (array, offset, length);
 148                 }
 149
 150                 public override void WriteArray (string prefix, string localName, string namespaceUri, Guid [] array, int offset, int length)
 151                 {
 152                         CheckWriteArrayArguments (array, offset, length);
 153                         writer.Write (BF.Array);
 154                         WriteStartElement (prefix, localName, namespaceUri);
 155                         WriteEndElement ();
 156                         WriteArrayRemaining (array, offset, length);
 157                 }
 158
 159                 void WriteArrayRemaining (Guid [] array, int offset, int length)
 160                 {
 161                         writer.Write ((byte) 0xB1); // ident
 162                         writer.WriteFlexibleInt (length);
 163                         for (int i = offset; i < offset + length; i++)
 164                                 WriteValueContent (array [i]);
 165                 }
 166
 167
 168                 public override void WriteArray (string prefix, XmlDictionaryString localName, XmlDictionaryString namespaceUri, short [] array, int offset, int length)
 169                 {
 170                         CheckDictionaryStringArgs (localName, namespaceUri);
 171                         writer.Write (BF.Array);
 172                         WriteStartElement (prefix, localName, namespaceUri);
 173                         WriteEndElement ();
 174                         WriteArrayRemaining (array, offset, length);
 175                 }
 176
 177                 public override void WriteArray (string prefix, string localName, string namespaceUri, short [] array, int offset, int length)
 178                 {
 179                         CheckWriteArrayArguments (array, offset, length);
 180                         writer.Write (BF.Array);
 181                         WriteStartElement (prefix, localName, namespaceUri);
 182                         WriteEndElement ();
 183                         WriteArrayRemaining (array, offset, length);
 184                 }
 185
 186                 void WriteArrayRemaining (short [] array, int offset, int length)
 187                 {
 188                         writer.Write ((byte) 0x8B); // ident
 189                         writer.WriteFlexibleInt (length);
 190                         for (int i = offset; i < offset + length; i++)
 191                                 WriteValueContent (array [i]);
 192                 }
 193
 194
 195                 public override void WriteArray (string prefix, XmlDictionaryString localName, XmlDictionaryString namespaceUri, int [] array, int offset, int length)
 196                 {
 197                         CheckDictionaryStringArgs (localName, namespaceUri);
 198                         writer.Write (BF.Array);
 199                         WriteStartElement (prefix, localName, namespaceUri);
 200                         WriteEndElement ();
 201                         WriteArrayRemaining (array, offset, length);
 202                 }
 203
 204                 public override void WriteArray (string prefix, string localName, string namespaceUri, int [] array, int offset, int length)
 205                 {
 206                         CheckWriteArrayArguments (array, offset, length);
 207                         writer.Write (BF.Array);
 208                         WriteStartElement (prefix, localName, namespaceUri);
 209                         WriteEndElement ();
 210                         WriteArrayRemaining (array, offset, length);
 211                 }
 212
 213                 void WriteArrayRemaining (int [] array, int offset, int length)
 214                 {
 215                         writer.Write ((byte) 0x8D); // ident
 216                         writer.WriteFlexibleInt (length);
 217                         for (int i = offset; i < offset + length; i++)
 218                                 WriteValueContent (array [i]);
 219                 }
 220
 221
 222                 public override void WriteArray (string prefix, XmlDictionaryString localName, XmlDictionaryString namespaceUri, long [] array, int offset, int length)
 223                 {
 224                         CheckDictionaryStringArgs (localName, namespaceUri);
 225                         writer.Write (BF.Array);
 226                         WriteStartElement (prefix, localName, namespaceUri);
 227                         WriteEndElement ();
 228                         WriteArrayRemaining (array, offset, length);
 229                 }
 230
 231                 public override void WriteArray (string prefix, string localName, string namespaceUri, long [] array, int offset, int length)
 232                 {
 233                         CheckWriteArrayArguments (array, offset, length);
 234                         writer.Write (BF.Array);
 235                         WriteStartElement (prefix, localName, namespaceUri);
 236                         WriteEndElement ();
 237                         WriteArrayRemaining (array, offset, length);
 238                 }
 239
 240                 void WriteArrayRemaining (long [] array, int offset, int length)
 241                 {
 242                         writer.Write ((byte) 0x8F); // ident
 243                         writer.WriteFlexibleInt (length);
 244                         for (int i = offset; i < offset + length; i++)
 245                                 WriteValueContent (array [i]);
 246                 }
 247
 248
 249                 public override void WriteArray (string prefix, XmlDictionaryString localName, XmlDictionaryString namespaceUri, float [] array, int offset, int length)
 250                 {
 251                         CheckDictionaryStringArgs (localName, namespaceUri);
 252                         writer.Write (BF.Array);
 253                         WriteStartElement (prefix, localName, namespaceUri);
 254                         WriteEndElement ();
 255                         WriteArrayRemaining (array, offset, length);
 256                 }
 257
 258                 public override void WriteArray (string prefix, string localName, string namespaceUri, float [] array, int offset, int length)
 259                 {
 260                         CheckWriteArrayArguments (array, offset, length);
 261                         writer.Write (BF.Array);
 262                         WriteStartElement (prefix, localName, namespaceUri);
 263                         WriteEndElement ();
 264                         WriteArrayRemaining (array, offset, length);
 265                 }
 266
 267                 void WriteArrayRemaining (float [] array, int offset, int length)
 268                 {
 269                         writer.Write ((byte) 0x91); // ident
 270                         writer.WriteFlexibleInt (length);
 271                         for (int i = offset; i < offset + length; i++)
 272                                 WriteValueContent (array [i]);
 273                 }
 274
 275
 276                 public override void WriteArray (string prefix, XmlDictionaryString localName, XmlDictionaryString namespaceUri, TimeSpan [] array, int offset, int length)
 277                 {
 278                         CheckDictionaryStringArgs (localName, namespaceUri);
 279                         writer.Write (BF.Array);
 280                         WriteStartElement (prefix, localName, namespaceUri);
 281                         WriteEndElement ();
 282                         WriteArrayRemaining (array, offset, length);
 283                 }
 284
 285                 public override void WriteArray (string prefix, string localName, string namespaceUri, TimeSpan [] array, int offset, int length)
 286                 {
 287                         CheckWriteArrayArguments (array, offset, length);
 288                         writer.Write (BF.Array);
 289                         WriteStartElement (prefix, localName, namespaceUri);
 290                         WriteEndElement ();
 291                         WriteArrayRemaining (array, offset, length);
 292                 }
 293
 294                 void WriteArrayRemaining (TimeSpan [] array, int offset, int length)
 295                 {
 296                         writer.Write ((byte) 0xAF); // ident
 297                         writer.WriteFlexibleInt (length);
 298                         for (int i = offset; i < offset + length; i++)
 299                                 WriteValueContent (array [i]);
 300                 }
 301
 302         }
 303 }