mcs/class/System.Web.Services/System.Web.Services.Description/WebReferenceOptionsSerializer.cs

   1 using System;
   2 using System.Xml;
   3 using System.Xml.Schema;
   4 using System.Xml.Serialization;
   5 using System.Text;
   6 using System.Collections;
   7 using System.Globalization;
   8
   9 namespace System.Web.Services.Description
  10 {
  11         internal class WebReferenceOptionsReader : XmlSerializationReader
  12         {
  13                 public object ReadRoot_WebReferenceOptions ()
  14                 {
  15                         Reader.MoveToContent();
  16                         if (Reader.LocalName != "webReferenceOptions" || Reader.NamespaceURI != "http://microsoft.com/webReference/")
  17                                 throw CreateUnknownNodeException();
  18                         return ReadObject_webReferenceOptions (true, true);
  19                 }
  20
  21                 public System.Web.Services.Description.WebReferenceOptions ReadObject_webReferenceOptions (bool isNullable, bool checkType)
  22                 {
  23                         System.Web.Services.Description.WebReferenceOptions ob = null;
  24                         if (isNullable && ReadNull()) return null;
  25
  26                         if (checkType)
  27                         {
  28                                 System.Xml.XmlQualifiedName t = GetXsiType();
  29                                 if (t == null)
  30                                 { }
  31                                 else if (t.Name != "webReferenceOptions" || t.Namespace != "http://microsoft.com/webReference/")
  32                                         throw CreateUnknownTypeException(t);
  33                         }
  34
  35                         ob = new System.Web.Services.Description.WebReferenceOptions ();
  36
  37                         Reader.MoveToElement();
  38
  39                         ob.@CodeGenerationOptions = ((System.Xml.Serialization.CodeGenerationOptions) System.Xml.Serialization.CodeGenerationOptions.GenerateOldAsync);
  40                         ob.@Style = ((System.Web.Services.Description.ServiceDescriptionImportStyle) System.Web.Services.Description.ServiceDescriptionImportStyle.Client);
  41                         while (Reader.MoveToNextAttribute())
  42                         {
  43                                 if (IsXmlnsAttribute (Reader.Name)) {
  44                                 }
  45                                 else {
  46                                         UnknownNode (ob);
  47                                 }
  48                         }
  49
  50                         Reader.MoveToElement();
  51                         if (Reader.IsEmptyElement) {
  52                                 Reader.Skip ();
  53                                 return ob;
  54                         }
  55
  56                         Reader.ReadStartElement();
  57                         Reader.MoveToContent();
  58
  59                         bool b0=false, b1=false, b2=false, b3=false;
  60
  61                         while (Reader.NodeType != System.Xml.XmlNodeType.EndElement)
  62                         {
  63                                 if (Reader.NodeType == System.Xml.XmlNodeType.Element)
  64                                 {
  65                                         if (Reader.LocalName == "style" && Reader.NamespaceURI == "http://microsoft.com/webReference/" && !b2) {
  66                                                 b2 = true;
  67                                                 ob.@Style = GetEnumValue_ServiceDescriptionImportStyle (Reader.ReadElementString ());
  68                                         }
  69                                         else if (Reader.LocalName == "verbose" && Reader.NamespaceURI == "http://microsoft.com/webReference/" && !b3) {
  70                                                 b3 = true;
  71                                                 ob.@Verbose = XmlConvert.ToBoolean (Reader.ReadElementString ());
  72                                         }
  73                                         else if (Reader.LocalName == "codeGenerationOptions" && Reader.NamespaceURI == "http://microsoft.com/webReference/" && !b0) {
  74                                                 b0 = true;
  75                                                 ob.@CodeGenerationOptions = GetEnumValue_CodeGenerationOptions (Reader.ReadElementString ());
  76                                         }
  77                                         else if (Reader.LocalName == "schemaImporterExtensions" && Reader.NamespaceURI == "http://microsoft.com/webReference/" && !b1) {
  78                                                 if (((object)ob.@SchemaImporterExtensions) == null)
  79                                                         throw CreateReadOnlyCollectionException ("System.Collections.Specialized.StringCollection");
  80                                                 if (Reader.IsEmptyElement) {
  81                                                         Reader.Skip();
  82                                                 } else {
  83                                                         int n4 = 0;
  84                                                         Reader.ReadStartElement();
  85                                                         Reader.MoveToContent();
  86
  87                                                         while (Reader.NodeType != System.Xml.XmlNodeType.EndElement)
  88                                                         {
  89                                                                 if (Reader.NodeType == System.Xml.XmlNodeType.Element)
  90                                                                 {
  91                                                                         if (Reader.LocalName == "type" && Reader.NamespaceURI == "http://microsoft.com/webReference/") {
  92                                                                                 if (((object)ob.@SchemaImporterExtensions) == null)
  93                                                                                         throw CreateReadOnlyCollectionException ("System.Collections.Specialized.StringCollection");
  94                                                                                 ob.@SchemaImporterExtensions.Add (Reader.ReadElementString ());
  95                                                                                 n4++;
  96                                                                         }
  97                                                                         else UnknownNode (null);
  98                                                                 }
  99                                                                 else UnknownNode (null);
 100
 101                                                                 Reader.MoveToContent();
 102                                                         }
 103                                                         ReadEndElement();
 104                                                 }
 105                                                 b1 = true;
 106                                         }
 107                                         else {
 108                                                 UnknownNode (ob);
 109                                         }
 110                                 }
 111                                 else
 112                                         UnknownNode(ob);
 113
 114                                 Reader.MoveToContent();
 115                         }
 116
 117                         ReadEndElement();
 118
 119                         return ob;
 120                 }
 121
 122                 public System.Web.Services.Description.ServiceDescriptionImportStyle ReadObject_ServiceDescriptionImportStyle (bool isNullable, bool checkType)
 123                 {
 124                         Reader.ReadStartElement ();
 125                         System.Web.Services.Description.ServiceDescriptionImportStyle res = GetEnumValue_ServiceDescriptionImportStyle (Reader.ReadString());
 126                         if (Reader.NodeType != XmlNodeType.None)
 127                         Reader.ReadEndElement ();
 128                         return res;
 129                 }
 130
 131                 System.Web.Services.Description.ServiceDescriptionImportStyle GetEnumValue_ServiceDescriptionImportStyle (string xmlName)
 132                 {
 133                         switch (xmlName)
 134                         {
 135                                 case "client": return System.Web.Services.Description.ServiceDescriptionImportStyle.Client;
 136                                 case "server": return System.Web.Services.Description.ServiceDescriptionImportStyle.Server;
 137                                 case "serverInterface": return System.Web.Services.Description.ServiceDescriptionImportStyle.ServerInterface;
 138                                 default:
 139                                         throw CreateUnknownConstantException (xmlName, typeof(System.Web.Services.Description.ServiceDescriptionImportStyle));
 140                         }
 141                 }
 142
 143                 public System.Xml.Serialization.CodeGenerationOptions ReadObject_CodeGenerationOptions (bool isNullable, bool checkType)
 144                 {
 145                         Reader.ReadStartElement ();
 146                         System.Xml.Serialization.CodeGenerationOptions res = GetEnumValue_CodeGenerationOptions (Reader.ReadString());
 147                         if (Reader.NodeType != XmlNodeType.None)
 148                         Reader.ReadEndElement ();
 149                         return res;
 150                 }
 151
 152                 System.Xml.Serialization.CodeGenerationOptions GetEnumValue_CodeGenerationOptions (string xmlName)
 153                 {
 154                         xmlName = xmlName.Trim();
 155                         if (xmlName.Length == 0) return (System.Xml.Serialization.CodeGenerationOptions)0;
 156                         System.Xml.Serialization.CodeGenerationOptions sb = (System.Xml.Serialization.CodeGenerationOptions)0;
 157                         string[] enumNames = xmlName.Split (null);
 158                         foreach (string name in enumNames)
 159                         {
 160                                 if (name == string.Empty) continue;
 161                                 sb |= GetEnumValue_CodeGenerationOptions_Switch (name);
 162                         }
 163                         return sb;
 164                 }
 165
 166                 System.Xml.Serialization.CodeGenerationOptions GetEnumValue_CodeGenerationOptions_Switch (string xmlName)
 167                 {
 168                         switch (xmlName)
 169                         {
 170                                 case "properties": return System.Xml.Serialization.CodeGenerationOptions.GenerateProperties;
 171                                 case "newAsync": return System.Xml.Serialization.CodeGenerationOptions.GenerateNewAsync;
 172                                 case "oldAsync": return System.Xml.Serialization.CodeGenerationOptions.GenerateOldAsync;
 173                                 case "order": return System.Xml.Serialization.CodeGenerationOptions.GenerateOrder;
 174                                 case "enableDataBinding": return System.Xml.Serialization.CodeGenerationOptions.EnableDataBinding;
 175                                 default:
 176                                         throw CreateUnknownConstantException (xmlName, typeof(System.Xml.Serialization.CodeGenerationOptions));
 177                         }
 178                 }
 179
 180                 protected override void InitCallbacks ()
 181                 {
 182                 }
 183
 184                 protected override void InitIDs ()
 185                 {
 186                 }
 187
 188         }
 189
 190         internal class WebReferenceOptionsWriter : XmlSerializationWriter
 191         {
 192                 const string xmlNamespace = "http://www.w3.org/2000/xmlns/";
 193                 public void WriteRoot_WebReferenceOptions (object o)
 194                 {
 195                         WriteStartDocument ();
 196                         System.Web.Services.Description.WebReferenceOptions ob = (System.Web.Services.Description.WebReferenceOptions) o;
 197                         TopLevelElement ();
 198                         WriteObject_webReferenceOptions (ob, "webReferenceOptions", "http://microsoft.com/webReference/", true, false, true);
 199                 }
 200
 201                 void WriteObject_webReferenceOptions (System.Web.Services.Description.WebReferenceOptions ob, string element, string namesp, bool isNullable, bool needType, bool writeWrappingElem)
 202                 {
 203                         if (((object)ob) == null)
 204                         {
 205                                 if (isNullable)
 206                                         WriteNullTagLiteral(element, namesp);
 207                                 return;
 208                         }
 209
 210                         System.Type type = ob.GetType ();
 211                         if (type == typeof(System.Web.Services.Description.WebReferenceOptions))
 212                         { }
 213                         else {
 214                                 throw CreateUnknownTypeException (ob);
 215                         }
 216
 217                         if (writeWrappingElem) {
 218                                 WriteStartElement (element, namesp, ob);
 219                         }
 220
 221                         if (needType) WriteXsiType("webReferenceOptions", "http://microsoft.com/webReference/");
 222
 223                         if (ob.@CodeGenerationOptions != ((System.Xml.Serialization.CodeGenerationOptions) System.Xml.Serialization.CodeGenerationOptions.GenerateOldAsync)) {
 224                                 WriteElementString ("codeGenerationOptions", "http://microsoft.com/webReference/", GetEnumValue_CodeGenerationOptions (ob.@CodeGenerationOptions));
 225                         }
 226                         if (ob.@SchemaImporterExtensions != null) {
 227                                 WriteStartElement ("schemaImporterExtensions", "http://microsoft.com/webReference/", ob.@SchemaImporterExtensions);
 228                                 for (int n5 = 0; n5 < ob.@SchemaImporterExtensions.Count; n5++) {
 229                                         WriteElementString ("type", "http://microsoft.com/webReference/", ob.@SchemaImporterExtensions[n5]);
 230                                 }
 231                                 WriteEndElement (ob.@SchemaImporterExtensions);
 232                         }
 233                         if (ob.@Style != ((System.Web.Services.Description.ServiceDescriptionImportStyle) System.Web.Services.Description.ServiceDescriptionImportStyle.Client)) {
 234                                 WriteElementString ("style", "http://microsoft.com/webReference/", GetEnumValue_ServiceDescriptionImportStyle (ob.@Style));
 235                         }
 236                         WriteElementString ("verbose", "http://microsoft.com/webReference/", (ob.@Verbose?"true":"false"));
 237                         if (writeWrappingElem) WriteEndElement (ob);
 238                 }
 239
 240                 void WriteObject_CodeGenerationOptions (System.Xml.Serialization.CodeGenerationOptions ob, string element, string namesp, bool isNullable, bool needType, bool writeWrappingElem)
 241                 {
 242                         System.Type type = ob.GetType ();
 243                         if (type == typeof(System.Xml.Serialization.CodeGenerationOptions))
 244                         { }
 245                         else {
 246                                 throw CreateUnknownTypeException (ob);
 247                         }
 248
 249                         if (writeWrappingElem) {
 250                                 WriteStartElement (element, namesp, ob);
 251                         }
 252
 253                         if (needType) WriteXsiType("CodeGenerationOptions", "http://microsoft.com/webReference/");
 254
 255                         Writer.WriteString (GetEnumValue_CodeGenerationOptions (ob));
 256                         if (writeWrappingElem) WriteEndElement (ob);
 257                 }
 258
 259                 static readonly string[] _xmlNamesCodeGenerationOptions = { "properties","newAsync","oldAsync","order","enableDataBinding" };
 260                 static readonly long[] _valuesCodeGenerationOptions = { 1L,2L,4L,8L,16L };
 261
 262                 string GetEnumValue_CodeGenerationOptions (System.Xml.Serialization.CodeGenerationOptions val)
 263                 {
 264                         switch (val) {
 265                                 case System.Xml.Serialization.CodeGenerationOptions.GenerateProperties: return "properties";
 266                                 case System.Xml.Serialization.CodeGenerationOptions.GenerateNewAsync: return "newAsync";
 267                                 case System.Xml.Serialization.CodeGenerationOptions.GenerateOldAsync: return "oldAsync";
 268                                 case System.Xml.Serialization.CodeGenerationOptions.GenerateOrder: return "order";
 269                                 case System.Xml.Serialization.CodeGenerationOptions.EnableDataBinding: return "enableDataBinding";
 270                                 default:
 271                                         if (val.ToString () == "0") return string.Empty;
 272                                         return FromEnum ((long) val, _xmlNamesCodeGenerationOptions, _valuesCodeGenerationOptions, typeof (System.Xml.Serialization.CodeGenerationOptions).FullName);
 273                         }
 274                 }
 275
 276                 void WriteObject_ServiceDescriptionImportStyle (System.Web.Services.Description.ServiceDescriptionImportStyle ob, string element, string namesp, bool isNullable, bool needType, bool writeWrappingElem)
 277                 {
 278                         System.Type type = ob.GetType ();
 279                         if (type == typeof(System.Web.Services.Description.ServiceDescriptionImportStyle))
 280                         { }
 281                         else {
 282                                 throw CreateUnknownTypeException (ob);
 283                         }
 284
 285                         if (writeWrappingElem) {
 286                                 WriteStartElement (element, namesp, ob);
 287                         }
 288
 289                         if (needType) WriteXsiType("ServiceDescriptionImportStyle", "http://microsoft.com/webReference/");
 290
 291                         Writer.WriteString (GetEnumValue_ServiceDescriptionImportStyle (ob));
 292                         if (writeWrappingElem) WriteEndElement (ob);
 293                 }
 294
 295                 string GetEnumValue_ServiceDescriptionImportStyle (System.Web.Services.Description.ServiceDescriptionImportStyle val)
 296                 {
 297                         switch (val) {
 298                                 case System.Web.Services.Description.ServiceDescriptionImportStyle.Client: return "client";
 299                                 case System.Web.Services.Description.ServiceDescriptionImportStyle.Server: return "server";
 300                                 case System.Web.Services.Description.ServiceDescriptionImportStyle.ServerInterface: return "serverInterface";
 301                                 default: throw CreateInvalidEnumValueException ((long) val, typeof (System.Web.Services.Description.ServiceDescriptionImportStyle).FullName);
 302                         }
 303                 }
 304
 305                 protected override void InitCallbacks ()
 306                 {
 307                 }
 308
 309         }
 310
 311
 312         internal class WebReferenceOptionsBaseSerializer : System.Xml.Serialization.XmlSerializer
 313         {
 314                 protected override System.Xml.Serialization.XmlSerializationReader CreateReader () {
 315                         return new WebReferenceOptionsReader ();
 316                 }
 317
 318                 protected override System.Xml.Serialization.XmlSerializationWriter CreateWriter () {
 319                         return new WebReferenceOptionsWriter ();
 320                 }
 321
 322                 public override bool CanDeserialize (System.Xml.XmlReader xmlReader) {
 323                         return true;
 324                 }
 325         }
 326
 327         internal sealed class webReferenceOptionsSerializer : WebReferenceOptionsBaseSerializer
 328         {
 329                 protected override void Serialize (object obj, System.Xml.Serialization.XmlSerializationWriter writer) {
 330                         ((WebReferenceOptionsWriter)writer).WriteRoot_WebReferenceOptions(obj);
 331                 }
 332
 333                 protected override object Deserialize (System.Xml.Serialization.XmlSerializationReader reader) {
 334                         return ((WebReferenceOptionsReader)reader).ReadRoot_WebReferenceOptions();
 335                 }
 336         }
 337
 338         internal class WebReferenceOptionsSerializerImplementation : System.Xml.Serialization.XmlSerializerImplementation
 339         {
 340                 System.Collections.Hashtable readMethods = null;
 341                 System.Collections.Hashtable writeMethods = null;
 342                 System.Collections.Hashtable typedSerializers = null;
 343
 344                 public override System.Xml.Serialization.XmlSerializationReader Reader {
 345                         get {
 346                                 return new WebReferenceOptionsReader();
 347                         }
 348                 }
 349
 350                 public override System.Xml.Serialization.XmlSerializationWriter Writer {
 351                         get {
 352                                 return new WebReferenceOptionsWriter();
 353                         }
 354                 }
 355
 356                 public override System.Collections.Hashtable ReadMethods {
 357                         get {
 358                                 lock (this) {
 359                                         if (readMethods == null) {
 360                                                 readMethods = new System.Collections.Hashtable ();
 361                                                 readMethods.Add (@"", @"ReadRoot_WebReferenceOptions");
 362                                         }
 363                                         return readMethods;
 364                                 }
 365                         }
 366                 }
 367
 368                 public override System.Collections.Hashtable WriteMethods {
 369                         get {
 370                                 lock (this) {
 371                                         if (writeMethods == null) {
 372                                                 writeMethods = new System.Collections.Hashtable ();
 373                                                 writeMethods.Add (@"", @"WriteRoot_WebReferenceOptions");
 374                                         }
 375                                         return writeMethods;
 376                                 }
 377                         }
 378                 }
 379
 380                 public override System.Collections.Hashtable TypedSerializers {
 381                         get {
 382                                 lock (this) {
 383                                         if (typedSerializers == null) {
 384                                                 typedSerializers = new System.Collections.Hashtable ();
 385                                                 typedSerializers.Add (@"", new webReferenceOptionsSerializer());
 386                                         }
 387                                         return typedSerializers;
 388                                 }
 389                         }
 390                 }
 391
 392                 public override XmlSerializer GetSerializer (Type type)
 393                 {
 394                         switch (type.FullName) {
 395                         case "System.Web.Services.Description.WebReferenceOptions":
 396                                 return (XmlSerializer) TypedSerializers [""];
 397
 398                         }
 399                         return base.GetSerializer (type);
 400                 }
 401
 402                 public override bool CanSerialize (System.Type type) {
 403                         if (type == typeof(System.Web.Services.Description.WebReferenceOptions)) return true;
 404                         return false;
 405                 }
 406         }
 407
 408 }