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

   1
   2 #pragma warning disable 612
   3 using System;
   4 using System.Collections.Generic;
   5
   6 namespace System.Xml
   7 {
   8         public abstract partial class XmlDictionaryReader : XmlReader
   9         {
  10                 static readonly char [] wsChars = new char [] {' ', '\t', '\n', '\r'};
  11
  12                 void CheckReadArrayArguments (Array array, int offset, int length)
  13                 {
  14                         if (array == null)
  15                                 throw new ArgumentNullException ("array");
  16                         if (offset < 0)
  17                                 throw new ArgumentOutOfRangeException ("offset is negative");
  18                         if (offset > array.Length)
  19                                 throw new ArgumentOutOfRangeException ("offset exceeds the length of the destination array");
  20                         if (length < 0)
  21                                 throw new ArgumentOutOfRangeException ("length is negative");
  22                         if (length > array.Length - offset)
  23                                 throw new ArgumentOutOfRangeException ("length + offset exceeds the length of the destination array");
  24                 }
  25
  26                 void CheckDictionaryStringArgs (XmlDictionaryString localName, XmlDictionaryString namespaceUri)
  27                 {
  28                         if (localName == null)
  29                                 throw new ArgumentNullException ("localName");
  30                         if (namespaceUri == null)
  31                                 throw new ArgumentNullException ("namespaceUri");
  32                 }
  33
  34
  35                 public virtual int ReadArray (XmlDictionaryString localName, XmlDictionaryString namespaceUri, bool [] array, int offset, int length)
  36                 {
  37                         CheckDictionaryStringArgs (localName, namespaceUri);
  38                         return ReadArray (localName.Value, namespaceUri.Value, array, offset, length);
  39                 }
  40
  41                 public virtual int ReadArray (string localName, string namespaceUri, bool [] array, int offset, int length)
  42                 {
  43                         CheckReadArrayArguments (array, offset, length);
  44                         for (int i = 0; i < length; i++) {
  45                                 MoveToContent ();
  46                                 if (NodeType != XmlNodeType.Element)
  47                                         return i;
  48                                 ReadStartElement (localName, namespaceUri);
  49                                 array [offset + i] = XmlConvert.ToBoolean (ReadContentAsString ());
  50                                 ReadEndElement ();
  51                         }
  52                         return length;
  53                 }
  54
  55                 public virtual bool [] ReadBooleanArray (string localName, string namespaceUri)
  56                 {
  57                         List<bool> list = new List<bool> ();
  58                         while (true) {
  59                                 MoveToContent ();
  60                                 if (NodeType != XmlNodeType.Element)
  61                                         break;
  62                                 ReadStartElement (localName, namespaceUri);
  63                                 list.Add (XmlConvert.ToBoolean (ReadContentAsString ()));
  64                                 ReadEndElement ();
  65                                 if (list.Count == Quotas.MaxArrayLength)
  66                                         // FIXME: check if raises an error or not
  67                                         break;
  68                         }
  69                         return list.ToArray ();
  70                 }
  71
  72                 public virtual bool [] ReadBooleanArray (XmlDictionaryString localName, XmlDictionaryString namespaceUri)
  73                 {
  74                         CheckDictionaryStringArgs (localName, namespaceUri);
  75                         return ReadBooleanArray (localName.Value, namespaceUri.Value);
  76                 }
  77
  78                 public virtual int ReadArray (XmlDictionaryString localName, XmlDictionaryString namespaceUri, DateTime [] array, int offset, int length)
  79                 {
  80                         CheckDictionaryStringArgs (localName, namespaceUri);
  81                         return ReadArray (localName.Value, namespaceUri.Value, array, offset, length);
  82                 }
  83
  84                 public virtual int ReadArray (string localName, string namespaceUri, DateTime [] array, int offset, int length)
  85                 {
  86                         CheckReadArrayArguments (array, offset, length);
  87                         for (int i = 0; i < length; i++) {
  88                                 MoveToContent ();
  89                                 if (NodeType != XmlNodeType.Element)
  90                                         return i;
  91                                 ReadStartElement (localName, namespaceUri);
  92                                 array [offset + i] = XmlConvert.ToDateTime (ReadContentAsString ());
  93                                 ReadEndElement ();
  94                         }
  95                         return length;
  96                 }
  97
  98                 public virtual DateTime [] ReadDateTimeArray (string localName, string namespaceUri)
  99                 {
 100                         List<DateTime> list = new List<DateTime> ();
 101                         while (true) {
 102                                 MoveToContent ();
 103                                 if (NodeType != XmlNodeType.Element)
 104                                         break;
 105                                 ReadStartElement (localName, namespaceUri);
 106                                 list.Add (XmlConvert.ToDateTime (ReadContentAsString ()));
 107                                 ReadEndElement ();
 108                                 if (list.Count == Quotas.MaxArrayLength)
 109                                         // FIXME: check if raises an error or not
 110                                         break;
 111                         }
 112                         return list.ToArray ();
 113                 }
 114
 115                 public virtual DateTime [] ReadDateTimeArray (XmlDictionaryString localName, XmlDictionaryString namespaceUri)
 116                 {
 117                         CheckDictionaryStringArgs (localName, namespaceUri);
 118                         return ReadDateTimeArray (localName.Value, namespaceUri.Value);
 119                 }
 120
 121                 public virtual int ReadArray (XmlDictionaryString localName, XmlDictionaryString namespaceUri, decimal [] array, int offset, int length)
 122                 {
 123                         CheckDictionaryStringArgs (localName, namespaceUri);
 124                         return ReadArray (localName.Value, namespaceUri.Value, array, offset, length);
 125                 }
 126
 127                 public virtual int ReadArray (string localName, string namespaceUri, decimal [] array, int offset, int length)
 128                 {
 129                         CheckReadArrayArguments (array, offset, length);
 130                         for (int i = 0; i < length; i++) {
 131                                 MoveToContent ();
 132                                 if (NodeType != XmlNodeType.Element)
 133                                         return i;
 134                                 ReadStartElement (localName, namespaceUri);
 135                                 array [offset + i] = XmlConvert.ToDecimal (ReadContentAsString ());
 136                                 ReadEndElement ();
 137                         }
 138                         return length;
 139                 }
 140
 141                 public virtual decimal [] ReadDecimalArray (string localName, string namespaceUri)
 142                 {
 143                         List<decimal> list = new List<decimal> ();
 144                         while (true) {
 145                                 MoveToContent ();
 146                                 if (NodeType != XmlNodeType.Element)
 147                                         break;
 148                                 ReadStartElement (localName, namespaceUri);
 149                                 list.Add (XmlConvert.ToDecimal (ReadContentAsString ()));
 150                                 ReadEndElement ();
 151                                 if (list.Count == Quotas.MaxArrayLength)
 152                                         // FIXME: check if raises an error or not
 153                                         break;
 154                         }
 155                         return list.ToArray ();
 156                 }
 157
 158                 public virtual decimal [] ReadDecimalArray (XmlDictionaryString localName, XmlDictionaryString namespaceUri)
 159                 {
 160                         CheckDictionaryStringArgs (localName, namespaceUri);
 161                         return ReadDecimalArray (localName.Value, namespaceUri.Value);
 162                 }
 163
 164                 public virtual int ReadArray (XmlDictionaryString localName, XmlDictionaryString namespaceUri, double [] array, int offset, int length)
 165                 {
 166                         CheckDictionaryStringArgs (localName, namespaceUri);
 167                         return ReadArray (localName.Value, namespaceUri.Value, array, offset, length);
 168                 }
 169
 170                 public virtual int ReadArray (string localName, string namespaceUri, double [] array, int offset, int length)
 171                 {
 172                         CheckReadArrayArguments (array, offset, length);
 173                         for (int i = 0; i < length; i++) {
 174                                 MoveToContent ();
 175                                 if (NodeType != XmlNodeType.Element)
 176                                         return i;
 177                                 ReadStartElement (localName, namespaceUri);
 178                                 array [offset + i] = XmlConvert.ToDouble (ReadContentAsString ());
 179                                 ReadEndElement ();
 180                         }
 181                         return length;
 182                 }
 183
 184                 public virtual double [] ReadDoubleArray (string localName, string namespaceUri)
 185                 {
 186                         List<double> list = new List<double> ();
 187                         while (true) {
 188                                 MoveToContent ();
 189                                 if (NodeType != XmlNodeType.Element)
 190                                         break;
 191                                 ReadStartElement (localName, namespaceUri);
 192                                 list.Add (XmlConvert.ToDouble (ReadContentAsString ()));
 193                                 ReadEndElement ();
 194                                 if (list.Count == Quotas.MaxArrayLength)
 195                                         // FIXME: check if raises an error or not
 196                                         break;
 197                         }
 198                         return list.ToArray ();
 199                 }
 200
 201                 public virtual double [] ReadDoubleArray (XmlDictionaryString localName, XmlDictionaryString namespaceUri)
 202                 {
 203                         CheckDictionaryStringArgs (localName, namespaceUri);
 204                         return ReadDoubleArray (localName.Value, namespaceUri.Value);
 205                 }
 206
 207                 public virtual int ReadArray (XmlDictionaryString localName, XmlDictionaryString namespaceUri, Guid [] array, int offset, int length)
 208                 {
 209                         CheckDictionaryStringArgs (localName, namespaceUri);
 210                         return ReadArray (localName.Value, namespaceUri.Value, array, offset, length);
 211                 }
 212
 213                 public virtual int ReadArray (string localName, string namespaceUri, Guid [] array, int offset, int length)
 214                 {
 215                         CheckReadArrayArguments (array, offset, length);
 216                         for (int i = 0; i < length; i++) {
 217                                 MoveToContent ();
 218                                 if (NodeType != XmlNodeType.Element)
 219                                         return i;
 220                                 ReadStartElement (localName, namespaceUri);
 221                                 array [offset + i] = XmlConvert.ToGuid (ReadContentAsString ());
 222                                 ReadEndElement ();
 223                         }
 224                         return length;
 225                 }
 226
 227                 public virtual Guid [] ReadGuidArray (string localName, string namespaceUri)
 228                 {
 229                         List<Guid> list = new List<Guid> ();
 230                         while (true) {
 231                                 MoveToContent ();
 232                                 if (NodeType != XmlNodeType.Element)
 233                                         break;
 234                                 ReadStartElement (localName, namespaceUri);
 235                                 list.Add (XmlConvert.ToGuid (ReadContentAsString ()));
 236                                 ReadEndElement ();
 237                                 if (list.Count == Quotas.MaxArrayLength)
 238                                         // FIXME: check if raises an error or not
 239                                         break;
 240                         }
 241                         return list.ToArray ();
 242                 }
 243
 244                 public virtual Guid [] ReadGuidArray (XmlDictionaryString localName, XmlDictionaryString namespaceUri)
 245                 {
 246                         CheckDictionaryStringArgs (localName, namespaceUri);
 247                         return ReadGuidArray (localName.Value, namespaceUri.Value);
 248                 }
 249
 250                 public virtual int ReadArray (XmlDictionaryString localName, XmlDictionaryString namespaceUri, short [] array, int offset, int length)
 251                 {
 252                         CheckDictionaryStringArgs (localName, namespaceUri);
 253                         return ReadArray (localName.Value, namespaceUri.Value, array, offset, length);
 254                 }
 255
 256                 public virtual int ReadArray (string localName, string namespaceUri, short [] array, int offset, int length)
 257                 {
 258                         CheckReadArrayArguments (array, offset, length);
 259                         for (int i = 0; i < length; i++) {
 260                                 MoveToContent ();
 261                                 if (NodeType != XmlNodeType.Element)
 262                                         return i;
 263                                 ReadStartElement (localName, namespaceUri);
 264                                 array [offset + i] = XmlConvert.ToInt16 (ReadContentAsString ());
 265                                 ReadEndElement ();
 266                         }
 267                         return length;
 268                 }
 269
 270                 public virtual short [] ReadInt16Array (string localName, string namespaceUri)
 271                 {
 272                         List<short> list = new List<short> ();
 273                         while (true) {
 274                                 MoveToContent ();
 275                                 if (NodeType != XmlNodeType.Element)
 276                                         break;
 277                                 ReadStartElement (localName, namespaceUri);
 278                                 list.Add (XmlConvert.ToInt16 (ReadContentAsString ()));
 279                                 ReadEndElement ();
 280                                 if (list.Count == Quotas.MaxArrayLength)
 281                                         // FIXME: check if raises an error or not
 282                                         break;
 283                         }
 284                         return list.ToArray ();
 285                 }
 286
 287                 public virtual short [] ReadInt16Array (XmlDictionaryString localName, XmlDictionaryString namespaceUri)
 288                 {
 289                         CheckDictionaryStringArgs (localName, namespaceUri);
 290                         return ReadInt16Array (localName.Value, namespaceUri.Value);
 291                 }
 292
 293                 public virtual int ReadArray (XmlDictionaryString localName, XmlDictionaryString namespaceUri, int [] array, int offset, int length)
 294                 {
 295                         CheckDictionaryStringArgs (localName, namespaceUri);
 296                         return ReadArray (localName.Value, namespaceUri.Value, array, offset, length);
 297                 }
 298
 299                 public virtual int ReadArray (string localName, string namespaceUri, int [] array, int offset, int length)
 300                 {
 301                         CheckReadArrayArguments (array, offset, length);
 302                         for (int i = 0; i < length; i++) {
 303                                 MoveToContent ();
 304                                 if (NodeType != XmlNodeType.Element)
 305                                         return i;
 306                                 ReadStartElement (localName, namespaceUri);
 307                                 array [offset + i] = XmlConvert.ToInt32 (ReadContentAsString ());
 308                                 ReadEndElement ();
 309                         }
 310                         return length;
 311                 }
 312
 313                 public virtual int [] ReadInt32Array (string localName, string namespaceUri)
 314                 {
 315                         List<int> list = new List<int> ();
 316                         while (true) {
 317                                 MoveToContent ();
 318                                 if (NodeType != XmlNodeType.Element)
 319                                         break;
 320                                 ReadStartElement (localName, namespaceUri);
 321                                 list.Add (XmlConvert.ToInt32 (ReadContentAsString ()));
 322                                 ReadEndElement ();
 323                                 if (list.Count == Quotas.MaxArrayLength)
 324                                         // FIXME: check if raises an error or not
 325                                         break;
 326                         }
 327                         return list.ToArray ();
 328                 }
 329
 330                 public virtual int [] ReadInt32Array (XmlDictionaryString localName, XmlDictionaryString namespaceUri)
 331                 {
 332                         CheckDictionaryStringArgs (localName, namespaceUri);
 333                         return ReadInt32Array (localName.Value, namespaceUri.Value);
 334                 }
 335
 336                 public virtual int ReadArray (XmlDictionaryString localName, XmlDictionaryString namespaceUri, long [] array, int offset, int length)
 337                 {
 338                         CheckDictionaryStringArgs (localName, namespaceUri);
 339                         return ReadArray (localName.Value, namespaceUri.Value, array, offset, length);
 340                 }
 341
 342                 public virtual int ReadArray (string localName, string namespaceUri, long [] array, int offset, int length)
 343                 {
 344                         CheckReadArrayArguments (array, offset, length);
 345                         for (int i = 0; i < length; i++) {
 346                                 MoveToContent ();
 347                                 if (NodeType != XmlNodeType.Element)
 348                                         return i;
 349                                 ReadStartElement (localName, namespaceUri);
 350                                 array [offset + i] = XmlConvert.ToInt64 (ReadContentAsString ());
 351                                 ReadEndElement ();
 352                         }
 353                         return length;
 354                 }
 355
 356                 public virtual long [] ReadInt64Array (string localName, string namespaceUri)
 357                 {
 358                         List<long> list = new List<long> ();
 359                         while (true) {
 360                                 MoveToContent ();
 361                                 if (NodeType != XmlNodeType.Element)
 362                                         break;
 363                                 ReadStartElement (localName, namespaceUri);
 364                                 list.Add (XmlConvert.ToInt64 (ReadContentAsString ()));
 365                                 ReadEndElement ();
 366                                 if (list.Count == Quotas.MaxArrayLength)
 367                                         // FIXME: check if raises an error or not
 368                                         break;
 369                         }
 370                         return list.ToArray ();
 371                 }
 372
 373                 public virtual long [] ReadInt64Array (XmlDictionaryString localName, XmlDictionaryString namespaceUri)
 374                 {
 375                         CheckDictionaryStringArgs (localName, namespaceUri);
 376                         return ReadInt64Array (localName.Value, namespaceUri.Value);
 377                 }
 378
 379                 public virtual int ReadArray (XmlDictionaryString localName, XmlDictionaryString namespaceUri, float [] array, int offset, int length)
 380                 {
 381                         CheckDictionaryStringArgs (localName, namespaceUri);
 382                         return ReadArray (localName.Value, namespaceUri.Value, array, offset, length);
 383                 }
 384
 385                 public virtual int ReadArray (string localName, string namespaceUri, float [] array, int offset, int length)
 386                 {
 387                         CheckReadArrayArguments (array, offset, length);
 388                         for (int i = 0; i < length; i++) {
 389                                 MoveToContent ();
 390                                 if (NodeType != XmlNodeType.Element)
 391                                         return i;
 392                                 ReadStartElement (localName, namespaceUri);
 393                                 array [offset + i] = XmlConvert.ToSingle (ReadContentAsString ());
 394                                 ReadEndElement ();
 395                         }
 396                         return length;
 397                 }
 398
 399                 public virtual float [] ReadSingleArray (string localName, string namespaceUri)
 400                 {
 401                         List<float> list = new List<float> ();
 402                         while (true) {
 403                                 MoveToContent ();
 404                                 if (NodeType != XmlNodeType.Element)
 405                                         break;
 406                                 ReadStartElement (localName, namespaceUri);
 407                                 list.Add (XmlConvert.ToSingle (ReadContentAsString ()));
 408                                 ReadEndElement ();
 409                                 if (list.Count == Quotas.MaxArrayLength)
 410                                         // FIXME: check if raises an error or not
 411                                         break;
 412                         }
 413                         return list.ToArray ();
 414                 }
 415
 416                 public virtual float [] ReadSingleArray (XmlDictionaryString localName, XmlDictionaryString namespaceUri)
 417                 {
 418                         CheckDictionaryStringArgs (localName, namespaceUri);
 419                         return ReadSingleArray (localName.Value, namespaceUri.Value);
 420                 }
 421
 422                 public virtual int ReadArray (XmlDictionaryString localName, XmlDictionaryString namespaceUri, TimeSpan [] array, int offset, int length)
 423                 {
 424                         CheckDictionaryStringArgs (localName, namespaceUri);
 425                         return ReadArray (localName.Value, namespaceUri.Value, array, offset, length);
 426                 }
 427
 428                 public virtual int ReadArray (string localName, string namespaceUri, TimeSpan [] array, int offset, int length)
 429                 {
 430                         CheckReadArrayArguments (array, offset, length);
 431                         for (int i = 0; i < length; i++) {
 432                                 MoveToContent ();
 433                                 if (NodeType != XmlNodeType.Element)
 434                                         return i;
 435                                 ReadStartElement (localName, namespaceUri);
 436                                 array [offset + i] = XmlConvert.ToTimeSpan (ReadContentAsString ());
 437                                 ReadEndElement ();
 438                         }
 439                         return length;
 440                 }
 441
 442                 public virtual TimeSpan [] ReadTimeSpanArray (string localName, string namespaceUri)
 443                 {
 444                         List<TimeSpan> list = new List<TimeSpan> ();
 445                         while (true) {
 446                                 MoveToContent ();
 447                                 if (NodeType != XmlNodeType.Element)
 448                                         break;
 449                                 ReadStartElement (localName, namespaceUri);
 450                                 list.Add (XmlConvert.ToTimeSpan (ReadContentAsString ()));
 451                                 ReadEndElement ();
 452                                 if (list.Count == Quotas.MaxArrayLength)
 453                                         // FIXME: check if raises an error or not
 454                                         break;
 455                         }
 456                         return list.ToArray ();
 457                 }
 458
 459                 public virtual TimeSpan [] ReadTimeSpanArray (XmlDictionaryString localName, XmlDictionaryString namespaceUri)
 460                 {
 461                         CheckDictionaryStringArgs (localName, namespaceUri);
 462                         return ReadTimeSpanArray (localName.Value, namespaceUri.Value);
 463                 }
 464
 465                 public override bool ReadElementContentAsBoolean ()
 466                 {
 467                         ReadStartElement (LocalName, NamespaceURI);
 468                         bool ret = ReadContentAsBoolean ();
 469                         ReadEndElement ();
 470                         return ret;
 471                 }
 472
 473                 public override DateTime ReadElementContentAsDateTime ()
 474                 {
 475                         ReadStartElement (LocalName, NamespaceURI);
 476                         DateTime ret = ReadContentAsDateTime ();
 477                         ReadEndElement ();
 478                         return ret;
 479                 }
 480
 481                 public override decimal ReadElementContentAsDecimal ()
 482                 {
 483                         ReadStartElement (LocalName, NamespaceURI);
 484                         decimal ret = ReadContentAsDecimal ();
 485                         ReadEndElement ();
 486                         return ret;
 487                 }
 488
 489                 public override double ReadElementContentAsDouble ()
 490                 {
 491                         ReadStartElement (LocalName, NamespaceURI);
 492                         double ret = ReadContentAsDouble ();
 493                         ReadEndElement ();
 494                         return ret;
 495                 }
 496
 497                 public override float ReadElementContentAsFloat ()
 498                 {
 499                         ReadStartElement (LocalName, NamespaceURI);
 500                         float ret = ReadContentAsFloat ();
 501                         ReadEndElement ();
 502                         return ret;
 503                 }
 504
 505                 public override int ReadElementContentAsInt ()
 506                 {
 507                         ReadStartElement (LocalName, NamespaceURI);
 508                         int ret = ReadContentAsInt ();
 509                         ReadEndElement ();
 510                         return ret;
 511                 }
 512
 513                 public override long ReadElementContentAsLong ()
 514                 {
 515                         ReadStartElement (LocalName, NamespaceURI);
 516                         long ret = ReadContentAsLong ();
 517                         ReadEndElement ();
 518                         return ret;
 519                 }
 520
 521         }
 522 }