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

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