← Back to branch summary

~ubuntu-branches/ubuntu/trusty/monodevelop/trusty-proposed

« back to all changes in this revision

Viewing changes to external/mono-addins/Mono.Addins.Setup/Mono.Addins.Setup/RepositoryReaderWriter.cs

  • Committer: Package Import Robot
  • Author(s): Jo Shields
  • Date: 2013-05-12 09:46:03 UTC
  • mto: This revision was merged to the branch mainline in revision 29.
  • Revision ID: package-import@ubuntu.com-20130512094603-mad323bzcxvmcam0
Tags: upstream-4.0.5+dfsg
Import upstream version 4.0.5+dfsg

Show diffs side-by-side

added added

removed removed

Lines of Context:
external/mono-addins/Mono.Addins.Setup/Mono.Addins.Setup/RepositoryReaderWriter.cs
 
1
// It is automatically generated
 
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 Mono.Addins.Setup
 
11
{
 
12
        internal class RepositoryReader : XmlSerializationReader
 
13
        {
 
14
                static readonly System.Reflection.MethodInfo fromBinHexStringMethod = typeof (XmlConvert).GetMethod ("FromBinHexString", System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.NonPublic, null, new Type [] {typeof (string)}, null);
 
15
                static byte [] FromBinHexString (string input)
 
16
                {
 
17
                        return input == null ? null : (byte []) fromBinHexStringMethod.Invoke (null, new object [] {input});
 
18
                }
 
19
                public object ReadRoot_Repository ()
 
20
                {
 
21
                        Reader.MoveToContent();
 
22
                        if (Reader.LocalName != "Repository" || Reader.NamespaceURI != "")
 
23
                                throw CreateUnknownNodeException();
 
24
                        return ReadObject_Repository (true, true);
 
25
                }
 
26
 
 
27
                public Mono.Addins.Setup.Repository ReadObject_Repository (bool isNullable, bool checkType)
 
28
                {
 
29
                        Mono.Addins.Setup.Repository ob = null;
 
30
                        if (isNullable && ReadNull()) return null;
 
31
 
 
32
                        if (checkType) 
 
33
                        {
 
34
                                System.Xml.XmlQualifiedName t = GetXsiType();
 
35
                                if (t == null)
 
36
                                { }
 
37
                                else if (t.Name != "Repository" || t.Namespace != "")
 
38
                                        throw CreateUnknownTypeException(t);
 
39
                        }
 
40
 
 
41
                        ob = (Mono.Addins.Setup.Repository) Activator.CreateInstance(typeof(Mono.Addins.Setup.Repository), true);
 
42
 
 
43
                        Reader.MoveToElement();
 
44
 
 
45
                        while (Reader.MoveToNextAttribute())
 
46
                        {
 
47
                                if (IsXmlnsAttribute (Reader.Name)) {
 
48
                                }
 
49
                                else {
 
50
                                        UnknownNode (ob);
 
51
                                }
 
52
                        }
 
53
 
 
54
                        Reader.MoveToElement ();
 
55
                        Reader.MoveToElement();
 
56
                        if (Reader.IsEmptyElement) {
 
57
                                Reader.Skip ();
 
58
                                return ob;
 
59
                        }
 
60
 
 
61
                        Reader.ReadStartElement();
 
62
                        Reader.MoveToContent();
 
63
 
 
64
                        bool b0=false, b1=false, b2=false, b3=false;
 
65
 
 
66
                        Mono.Addins.Setup.RepositoryEntryCollection o5;
 
67
                        o5 = ob.@Repositories;
 
68
                        Mono.Addins.Setup.RepositoryEntryCollection o7;
 
69
                        o7 = ob.@Addins;
 
70
                        int n4=0, n6=0;
 
71
 
 
72
                        while (Reader.NodeType != System.Xml.XmlNodeType.EndElement) 
 
73
                        {
 
74
                                if (Reader.NodeType == System.Xml.XmlNodeType.Element) 
 
75
                                {
 
76
                                        if (Reader.LocalName == "Addin" && Reader.NamespaceURI == "" && !b3) {
 
77
                                                if (((object)o7) == null)
 
78
                                                        throw CreateReadOnlyCollectionException ("Mono.Addins.Setup.RepositoryEntryCollection");
 
79
                                                o7.Add (ReadObject_PackageRepositoryEntry (false, true));
 
80
                                                n6++;
 
81
                                        }
 
82
                                        else if (Reader.LocalName == "Repository" && Reader.NamespaceURI == "" && !b2) {
 
83
                                                if (((object)o5) == null)
 
84
                                                        throw CreateReadOnlyCollectionException ("Mono.Addins.Setup.RepositoryEntryCollection");
 
85
                                                o5.Add (ReadObject_ReferenceRepositoryEntry (false, true));
 
86
                                                n4++;
 
87
                                        }
 
88
                                        else if (Reader.LocalName == "Name" && Reader.NamespaceURI == "" && !b0) {
 
89
                                                b0 = true;
 
90
                                                string s8 = Reader.ReadElementString ();
 
91
                                                ob.@Name = s8;
 
92
                                        }
 
93
                                        else if (Reader.LocalName == "Url" && Reader.NamespaceURI == "" && !b1) {
 
94
                                                b1 = true;
 
95
                                                string s9 = Reader.ReadElementString ();
 
96
                                                ob.@Url = s9;
 
97
                                        }
 
98
                                        else {
 
99
                                                UnknownNode (ob);
 
100
                                        }
 
101
                                }
 
102
                                else
 
103
                                        UnknownNode(ob);
 
104
 
 
105
                                Reader.MoveToContent();
 
106
                        }
 
107
 
 
108
 
 
109
                        ReadEndElement();
 
110
 
 
111
                        return ob;
 
112
                }
 
113
 
 
114
                public Mono.Addins.Setup.PackageRepositoryEntry ReadObject_PackageRepositoryEntry (bool isNullable, bool checkType)
 
115
                {
 
116
                        Mono.Addins.Setup.PackageRepositoryEntry ob = null;
 
117
                        if (isNullable && ReadNull()) return null;
 
118
 
 
119
                        if (checkType) 
 
120
                        {
 
121
                                System.Xml.XmlQualifiedName t = GetXsiType();
 
122
                                if (t == null)
 
123
                                { }
 
124
                                else if (t.Name != "PackageRepositoryEntry" || t.Namespace != "")
 
125
                                        throw CreateUnknownTypeException(t);
 
126
                        }
 
127
 
 
128
                        ob = (Mono.Addins.Setup.PackageRepositoryEntry) Activator.CreateInstance(typeof(Mono.Addins.Setup.PackageRepositoryEntry), true);
 
129
 
 
130
                        Reader.MoveToElement();
 
131
 
 
132
                        while (Reader.MoveToNextAttribute())
 
133
                        {
 
134
                                if (IsXmlnsAttribute (Reader.Name)) {
 
135
                                }
 
136
                                else {
 
137
                                        UnknownNode (ob);
 
138
                                }
 
139
                        }
 
140
 
 
141
                        Reader.MoveToElement ();
 
142
                        Reader.MoveToElement();
 
143
                        if (Reader.IsEmptyElement) {
 
144
                                Reader.Skip ();
 
145
                                return ob;
 
146
                        }
 
147
 
 
148
                        Reader.ReadStartElement();
 
149
                        Reader.MoveToContent();
 
150
 
 
151
                        bool b10=false, b11=false;
 
152
 
 
153
                        while (Reader.NodeType != System.Xml.XmlNodeType.EndElement) 
 
154
                        {
 
155
                                if (Reader.NodeType == System.Xml.XmlNodeType.Element) 
 
156
                                {
 
157
                                        if (Reader.LocalName == "Addin" && Reader.NamespaceURI == "" && !b11) {
 
158
                                                b11 = true;
 
159
                                                ob.@Addin = ReadObject_AddinInfo (false, true);
 
160
                                        }
 
161
                                        else if (Reader.LocalName == "Url" && Reader.NamespaceURI == "" && !b10) {
 
162
                                                b10 = true;
 
163
                                                string s12 = Reader.ReadElementString ();
 
164
                                                ob.@Url = s12;
 
165
                                        }
 
166
                                        else {
 
167
                                                UnknownNode (ob);
 
168
                                        }
 
169
                                }
 
170
                                else
 
171
                                        UnknownNode(ob);
 
172
 
 
173
                                Reader.MoveToContent();
 
174
                        }
 
175
 
 
176
                        ReadEndElement();
 
177
 
 
178
                        return ob;
 
179
                }
 
180
 
 
181
                public Mono.Addins.Setup.ReferenceRepositoryEntry ReadObject_ReferenceRepositoryEntry (bool isNullable, bool checkType)
 
182
                {
 
183
                        Mono.Addins.Setup.ReferenceRepositoryEntry ob = null;
 
184
                        if (isNullable && ReadNull()) return null;
 
185
 
 
186
                        if (checkType) 
 
187
                        {
 
188
                                System.Xml.XmlQualifiedName t = GetXsiType();
 
189
                                if (t == null)
 
190
                                { }
 
191
                                else if (t.Name != "ReferenceRepositoryEntry" || t.Namespace != "")
 
192
                                        throw CreateUnknownTypeException(t);
 
193
                        }
 
194
 
 
195
                        ob = (Mono.Addins.Setup.ReferenceRepositoryEntry) Activator.CreateInstance(typeof(Mono.Addins.Setup.ReferenceRepositoryEntry), true);
 
196
 
 
197
                        Reader.MoveToElement();
 
198
 
 
199
                        while (Reader.MoveToNextAttribute())
 
200
                        {
 
201
                                if (IsXmlnsAttribute (Reader.Name)) {
 
202
                                }
 
203
                                else {
 
204
                                        UnknownNode (ob);
 
205
                                }
 
206
                        }
 
207
 
 
208
                        Reader.MoveToElement ();
 
209
                        Reader.MoveToElement();
 
210
                        if (Reader.IsEmptyElement) {
 
211
                                Reader.Skip ();
 
212
                                return ob;
 
213
                        }
 
214
 
 
215
                        Reader.ReadStartElement();
 
216
                        Reader.MoveToContent();
 
217
 
 
218
                        bool b13=false, b14=false;
 
219
 
 
220
                        while (Reader.NodeType != System.Xml.XmlNodeType.EndElement) 
 
221
                        {
 
222
                                if (Reader.NodeType == System.Xml.XmlNodeType.Element) 
 
223
                                {
 
224
                                        if (Reader.LocalName == "Url" && Reader.NamespaceURI == "" && !b13) {
 
225
                                                b13 = true;
 
226
                                                string s15 = Reader.ReadElementString ();
 
227
                                                ob.@Url = s15;
 
228
                                        }
 
229
                                        else if (Reader.LocalName == "LastModified" && Reader.NamespaceURI == "" && !b14) {
 
230
                                                b14 = true;
 
231
                                                string s16 = Reader.ReadElementString ();
 
232
                                                ob.@LastModified = XmlConvert.ToDateTime (s16, XmlDateTimeSerializationMode.RoundtripKind);
 
233
                                        }
 
234
                                        else {
 
235
                                                UnknownNode (ob);
 
236
                                        }
 
237
                                }
 
238
                                else
 
239
                                        UnknownNode(ob);
 
240
 
 
241
                                Reader.MoveToContent();
 
242
                        }
 
243
 
 
244
                        ReadEndElement();
 
245
 
 
246
                        return ob;
 
247
                }
 
248
 
 
249
                public Mono.Addins.Setup.AddinInfo ReadObject_AddinInfo (bool isNullable, bool checkType)
 
250
                {
 
251
                        Mono.Addins.Setup.AddinInfo ob = null;
 
252
                        if (isNullable && ReadNull()) return null;
 
253
 
 
254
                        if (checkType) 
 
255
                        {
 
256
                                System.Xml.XmlQualifiedName t = GetXsiType();
 
257
                                if (t == null)
 
258
                                { }
 
259
                                else if (t.Name != "AddinInfo" || t.Namespace != "")
 
260
                                        throw CreateUnknownTypeException(t);
 
261
                        }
 
262
 
 
263
                        ob = (Mono.Addins.Setup.AddinInfo) Activator.CreateInstance(typeof(Mono.Addins.Setup.AddinInfo), true);
 
264
 
 
265
                        Reader.MoveToElement();
 
266
 
 
267
                        while (Reader.MoveToNextAttribute())
 
268
                        {
 
269
                                if (IsXmlnsAttribute (Reader.Name)) {
 
270
                                }
 
271
                                else {
 
272
                                        UnknownNode (ob);
 
273
                                }
 
274
                        }
 
275
 
 
276
                        Reader.MoveToElement ();
 
277
                        Reader.MoveToElement();
 
278
                        if (Reader.IsEmptyElement) {
 
279
                                Reader.Skip ();
 
280
                                return ob;
 
281
                        }
 
282
 
 
283
                        Reader.ReadStartElement();
 
284
                        Reader.MoveToContent();
 
285
 
 
286
                        bool b17=false, b18=false, b19=false, b20=false, b21=false, b22=false, b23=false, b24=false, b25=false, b26=false, b27=false, b28=false, b29=false;
 
287
 
 
288
                        while (Reader.NodeType != System.Xml.XmlNodeType.EndElement) 
 
289
                        {
 
290
                                if (Reader.NodeType == System.Xml.XmlNodeType.Element) 
 
291
                                {
 
292
                                        if (Reader.LocalName == "Version" && Reader.NamespaceURI == "" && !b20) {
 
293
                                                b20 = true;
 
294
                                                string s30 = Reader.ReadElementString ();
 
295
                                                ob.@Version = s30;
 
296
                                        }
 
297
                                        else if (Reader.LocalName == "Dependencies" && Reader.NamespaceURI == "" && !b27) {
 
298
                                                if (((object)ob.@Dependencies) == null)
 
299
                                                        throw CreateReadOnlyCollectionException ("Mono.Addins.Description.DependencyCollection");
 
300
                                                if (Reader.IsEmptyElement) {
 
301
                                                        Reader.Skip();
 
302
                                                } else {
 
303
                                                        int n31 = 0;
 
304
                                                        Reader.ReadStartElement();
 
305
                                                        Reader.MoveToContent();
 
306
 
 
307
                                                        while (Reader.NodeType != System.Xml.XmlNodeType.EndElement) 
 
308
                                                        {
 
309
                                                                if (Reader.NodeType == System.Xml.XmlNodeType.Element) 
 
310
                                                                {
 
311
                                                                        if (Reader.LocalName == "AssemblyDependency" && Reader.NamespaceURI == "") {
 
312
                                                                                if (((object)ob.@Dependencies) == null)
 
313
                                                                                        throw CreateReadOnlyCollectionException ("Mono.Addins.Description.DependencyCollection");
 
314
                                                                                ob.@Dependencies.Add (ReadObject_AssemblyDependency (false, true));
 
315
                                                                                n31++;
 
316
                                                                        }
 
317
                                                                        else if (Reader.LocalName == "NativeDependency" && Reader.NamespaceURI == "") {
 
318
                                                                                if (((object)ob.@Dependencies) == null)
 
319
                                                                                        throw CreateReadOnlyCollectionException ("Mono.Addins.Description.DependencyCollection");
 
320
                                                                                ob.@Dependencies.Add (ReadObject_NativeReference (false, true));
 
321
                                                                                n31++;
 
322
                                                                        }
 
323
                                                                        else if (Reader.LocalName == "AddinDependency" && Reader.NamespaceURI == "") {
 
324
                                                                                if (((object)ob.@Dependencies) == null)
 
325
                                                                                        throw CreateReadOnlyCollectionException ("Mono.Addins.Description.DependencyCollection");
 
326
                                                                                ob.@Dependencies.Add (ReadObject_AddinReference (false, true));
 
327
                                                                                n31++;
 
328
                                                                        }
 
329
                                                                        else UnknownNode (null);
 
330
                                                                }
 
331
                                                                else UnknownNode (null);
 
332
 
 
333
                                                                Reader.MoveToContent();
 
334
                                                        }
 
335
                                                        ReadEndElement();
 
336
                                                }
 
337
                                                b27 = true;
 
338
                                        }
 
339
                                        else if (Reader.LocalName == "Name" && Reader.NamespaceURI == "" && !b19) {
 
340
                                                b19 = true;
 
341
                                                string s32 = Reader.ReadElementString ();
 
342
                                                ob.@Name = s32;
 
343
                                        }
 
344
                                        else if (Reader.LocalName == "BaseVersion" && Reader.NamespaceURI == "" && !b21) {
 
345
                                                b21 = true;
 
346
                                                string s33 = Reader.ReadElementString ();
 
347
                                                ob.@BaseVersion = s33;
 
348
                                        }
 
349
                                        else if (Reader.LocalName == "Id" && Reader.NamespaceURI == "" && !b17) {
 
350
                                                b17 = true;
 
351
                                                string s34 = Reader.ReadElementString ();
 
352
                                                ob.@LocalId = s34;
 
353
                                        }
 
354
                                        else if (Reader.LocalName == "Url" && Reader.NamespaceURI == "" && !b24) {
 
355
                                                b24 = true;
 
356
                                                string s35 = Reader.ReadElementString ();
 
357
                                                ob.@Url = s35;
 
358
                                        }
 
359
                                        else if (Reader.LocalName == "Copyright" && Reader.NamespaceURI == "" && !b23) {
 
360
                                                b23 = true;
 
361
                                                string s36 = Reader.ReadElementString ();
 
362
                                                ob.@Copyright = s36;
 
363
                                        }
 
364
                                        else if (Reader.LocalName == "Description" && Reader.NamespaceURI == "" && !b25) {
 
365
                                                b25 = true;
 
366
                                                string s37 = Reader.ReadElementString ();
 
367
                                                ob.@Description = s37;
 
368
                                        }
 
369
                                        else if (Reader.LocalName == "Author" && Reader.NamespaceURI == "" && !b22) {
 
370
                                                b22 = true;
 
371
                                                string s38 = Reader.ReadElementString ();
 
372
                                                ob.@Author = s38;
 
373
                                        }
 
374
                                        else if (Reader.LocalName == "OptionalDependencies" && Reader.NamespaceURI == "" && !b28) {
 
375
                                                if (((object)ob.@OptionalDependencies) == null)
 
376
                                                        throw CreateReadOnlyCollectionException ("Mono.Addins.Description.DependencyCollection");
 
377
                                                if (Reader.IsEmptyElement) {
 
378
                                                        Reader.Skip();
 
379
                                                } else {
 
380
                                                        int n39 = 0;
 
381
                                                        Reader.ReadStartElement();
 
382
                                                        Reader.MoveToContent();
 
383
 
 
384
                                                        while (Reader.NodeType != System.Xml.XmlNodeType.EndElement) 
 
385
                                                        {
 
386
                                                                if (Reader.NodeType == System.Xml.XmlNodeType.Element) 
 
387
                                                                {
 
388
                                                                        if (Reader.LocalName == "AssemblyDependency" && Reader.NamespaceURI == "") {
 
389
                                                                                if (((object)ob.@OptionalDependencies) == null)
 
390
                                                                                        throw CreateReadOnlyCollectionException ("Mono.Addins.Description.DependencyCollection");
 
391
                                                                                ob.@OptionalDependencies.Add (ReadObject_AssemblyDependency (false, true));
 
392
                                                                                n39++;
 
393
                                                                        }
 
394
                                                                        else if (Reader.LocalName == "NativeDependency" && Reader.NamespaceURI == "") {
 
395
                                                                                if (((object)ob.@OptionalDependencies) == null)
 
396
                                                                                        throw CreateReadOnlyCollectionException ("Mono.Addins.Description.DependencyCollection");
 
397
                                                                                ob.@OptionalDependencies.Add (ReadObject_NativeReference (false, true));
 
398
                                                                                n39++;
 
399
                                                                        }
 
400
                                                                        else if (Reader.LocalName == "AddinDependency" && Reader.NamespaceURI == "") {
 
401
                                                                                if (((object)ob.@OptionalDependencies) == null)
 
402
                                                                                        throw CreateReadOnlyCollectionException ("Mono.Addins.Description.DependencyCollection");
 
403
                                                                                ob.@OptionalDependencies.Add (ReadObject_AddinReference (false, true));
 
404
                                                                                n39++;
 
405
                                                                        }
 
406
                                                                        else UnknownNode (null);
 
407
                                                                }
 
408
                                                                else UnknownNode (null);
 
409
 
 
410
                                                                Reader.MoveToContent();
 
411
                                                        }
 
412
                                                        ReadEndElement();
 
413
                                                }
 
414
                                                b28 = true;
 
415
                                        }
 
416
                                        else if (Reader.LocalName == "Properties" && Reader.NamespaceURI == "" && !b29) {
 
417
                                                if (((object)ob.@Properties) == null)
 
418
                                                        throw CreateReadOnlyCollectionException ("Mono.Addins.Setup.AddinPropertyCollectionImpl");
 
419
                                                if (Reader.IsEmptyElement) {
 
420
                                                        Reader.Skip();
 
421
                                                } else {
 
422
                                                        int n40 = 0;
 
423
                                                        Reader.ReadStartElement();
 
424
                                                        Reader.MoveToContent();
 
425
 
 
426
                                                        while (Reader.NodeType != System.Xml.XmlNodeType.EndElement) 
 
427
                                                        {
 
428
                                                                if (Reader.NodeType == System.Xml.XmlNodeType.Element) 
 
429
                                                                {
 
430
                                                                        if (Reader.LocalName == "Property" && Reader.NamespaceURI == "") {
 
431
                                                                                if (((object)ob.@Properties) == null)
 
432
                                                                                        throw CreateReadOnlyCollectionException ("Mono.Addins.Setup.AddinPropertyCollectionImpl");
 
433
                                                                                ob.@Properties.Add (ReadObject_AddinProperty (false, true));
 
434
                                                                                n40++;
 
435
                                                                        }
 
436
                                                                        else UnknownNode (null);
 
437
                                                                }
 
438
                                                                else UnknownNode (null);
 
439
 
 
440
                                                                Reader.MoveToContent();
 
441
                                                        }
 
442
                                                        ReadEndElement();
 
443
                                                }
 
444
                                                b29 = true;
 
445
                                        }
 
446
                                        else if (Reader.LocalName == "Namespace" && Reader.NamespaceURI == "" && !b18) {
 
447
                                                b18 = true;
 
448
                                                string s41 = Reader.ReadElementString ();
 
449
                                                ob.@Namespace = s41;
 
450
                                        }
 
451
                                        else if (Reader.LocalName == "Category" && Reader.NamespaceURI == "" && !b26) {
 
452
                                                b26 = true;
 
453
                                                string s42 = Reader.ReadElementString ();
 
454
                                                ob.@Category = s42;
 
455
                                        }
 
456
                                        else {
 
457
                                                UnknownNode (ob);
 
458
                                        }
 
459
                                }
 
460
                                else
 
461
                                        UnknownNode(ob);
 
462
 
 
463
                                Reader.MoveToContent();
 
464
                        }
 
465
 
 
466
                        ReadEndElement();
 
467
 
 
468
                        return ob;
 
469
                }
 
470
 
 
471
                public Mono.Addins.Description.AssemblyDependency ReadObject_AssemblyDependency (bool isNullable, bool checkType)
 
472
                {
 
473
                        Mono.Addins.Description.AssemblyDependency ob = null;
 
474
                        if (isNullable && ReadNull()) return null;
 
475
 
 
476
                        if (checkType) 
 
477
                        {
 
478
                                System.Xml.XmlQualifiedName t = GetXsiType();
 
479
                                if (t == null)
 
480
                                { }
 
481
                                else if (t.Name != "AssemblyDependency" || t.Namespace != "")
 
482
                                        throw CreateUnknownTypeException(t);
 
483
                        }
 
484
 
 
485
                        ob = (Mono.Addins.Description.AssemblyDependency) Activator.CreateInstance(typeof(Mono.Addins.Description.AssemblyDependency), true);
 
486
 
 
487
                        Reader.MoveToElement();
 
488
 
 
489
                        while (Reader.MoveToNextAttribute())
 
490
                        {
 
491
                                if (IsXmlnsAttribute (Reader.Name)) {
 
492
                                }
 
493
                                else {
 
494
                                        UnknownNode (ob);
 
495
                                }
 
496
                        }
 
497
 
 
498
                        Reader.MoveToElement ();
 
499
                        Reader.MoveToElement();
 
500
                        if (Reader.IsEmptyElement) {
 
501
                                Reader.Skip ();
 
502
                                return ob;
 
503
                        }
 
504
 
 
505
                        Reader.ReadStartElement();
 
506
                        Reader.MoveToContent();
 
507
 
 
508
                        bool b43=false, b44=false;
 
509
 
 
510
                        while (Reader.NodeType != System.Xml.XmlNodeType.EndElement) 
 
511
                        {
 
512
                                if (Reader.NodeType == System.Xml.XmlNodeType.Element) 
 
513
                                {
 
514
                                        if (Reader.LocalName == "Package" && Reader.NamespaceURI == "" && !b44) {
 
515
                                                b44 = true;
 
516
                                                string s45 = Reader.ReadElementString ();
 
517
                                                ob.@Package = s45;
 
518
                                        }
 
519
                                        else if (Reader.LocalName == "FullName" && Reader.NamespaceURI == "" && !b43) {
 
520
                                                b43 = true;
 
521
                                                string s46 = Reader.ReadElementString ();
 
522
                                                ob.@FullName = s46;
 
523
                                        }
 
524
                                        else {
 
525
                                                UnknownNode (ob);
 
526
                                        }
 
527
                                }
 
528
                                else
 
529
                                        UnknownNode(ob);
 
530
 
 
531
                                Reader.MoveToContent();
 
532
                        }
 
533
 
 
534
                        ReadEndElement();
 
535
 
 
536
                        return ob;
 
537
                }
 
538
 
 
539
                public Mono.Addins.Description.NativeDependency ReadObject_NativeReference (bool isNullable, bool checkType)
 
540
                {
 
541
                        Mono.Addins.Description.NativeDependency ob = null;
 
542
                        if (isNullable && ReadNull()) return null;
 
543
 
 
544
                        if (checkType) 
 
545
                        {
 
546
                                System.Xml.XmlQualifiedName t = GetXsiType();
 
547
                                if (t == null)
 
548
                                { }
 
549
                                else if (t.Name != "NativeReference" || t.Namespace != "")
 
550
                                        throw CreateUnknownTypeException(t);
 
551
                        }
 
552
 
 
553
                        ob = (Mono.Addins.Description.NativeDependency) Activator.CreateInstance(typeof(Mono.Addins.Description.NativeDependency), true);
 
554
 
 
555
                        Reader.MoveToElement();
 
556
 
 
557
                        while (Reader.MoveToNextAttribute())
 
558
                        {
 
559
                                if (IsXmlnsAttribute (Reader.Name)) {
 
560
                                }
 
561
                                else {
 
562
                                        UnknownNode (ob);
 
563
                                }
 
564
                        }
 
565
 
 
566
                        Reader.MoveToElement ();
 
567
                        Reader.MoveToElement();
 
568
                        if (Reader.IsEmptyElement) {
 
569
                                Reader.Skip ();
 
570
                                return ob;
 
571
                        }
 
572
 
 
573
                        Reader.ReadStartElement();
 
574
                        Reader.MoveToContent();
 
575
 
 
576
                        while (Reader.NodeType != System.Xml.XmlNodeType.EndElement) 
 
577
                        {
 
578
                                if (Reader.NodeType == System.Xml.XmlNodeType.Element) 
 
579
                                {
 
580
                                        UnknownNode (ob);
 
581
                                }
 
582
                                else
 
583
                                        UnknownNode(ob);
 
584
 
 
585
                                Reader.MoveToContent();
 
586
                        }
 
587
 
 
588
                        ReadEndElement();
 
589
 
 
590
                        return ob;
 
591
                }
 
592
 
 
593
                public Mono.Addins.Description.AddinDependency ReadObject_AddinReference (bool isNullable, bool checkType)
 
594
                {
 
595
                        Mono.Addins.Description.AddinDependency ob = null;
 
596
                        if (isNullable && ReadNull()) return null;
 
597
 
 
598
                        if (checkType) 
 
599
                        {
 
600
                                System.Xml.XmlQualifiedName t = GetXsiType();
 
601
                                if (t == null)
 
602
                                { }
 
603
                                else if (t.Name != "AddinReference" || t.Namespace != "")
 
604
                                        throw CreateUnknownTypeException(t);
 
605
                        }
 
606
 
 
607
                        ob = (Mono.Addins.Description.AddinDependency) Activator.CreateInstance(typeof(Mono.Addins.Description.AddinDependency), true);
 
608
 
 
609
                        Reader.MoveToElement();
 
610
 
 
611
                        while (Reader.MoveToNextAttribute())
 
612
                        {
 
613
                                if (IsXmlnsAttribute (Reader.Name)) {
 
614
                                }
 
615
                                else {
 
616
                                        UnknownNode (ob);
 
617
                                }
 
618
                        }
 
619
 
 
620
                        Reader.MoveToElement ();
 
621
                        Reader.MoveToElement();
 
622
                        if (Reader.IsEmptyElement) {
 
623
                                Reader.Skip ();
 
624
                                return ob;
 
625
                        }
 
626
 
 
627
                        Reader.ReadStartElement();
 
628
                        Reader.MoveToContent();
 
629
 
 
630
                        bool b47=false, b48=false;
 
631
 
 
632
                        while (Reader.NodeType != System.Xml.XmlNodeType.EndElement) 
 
633
                        {
 
634
                                if (Reader.NodeType == System.Xml.XmlNodeType.Element) 
 
635
                                {
 
636
                                        if (Reader.LocalName == "Version" && Reader.NamespaceURI == "" && !b48) {
 
637
                                                b48 = true;
 
638
                                                string s49 = Reader.ReadElementString ();
 
639
                                                ob.@Version = s49;
 
640
                                        }
 
641
                                        else if (Reader.LocalName == "AddinId" && Reader.NamespaceURI == "" && !b47) {
 
642
                                                b47 = true;
 
643
                                                string s50 = Reader.ReadElementString ();
 
644
                                                ob.@AddinId = s50;
 
645
                                        }
 
646
                                        else {
 
647
                                                UnknownNode (ob);
 
648
                                        }
 
649
                                }
 
650
                                else
 
651
                                        UnknownNode(ob);
 
652
 
 
653
                                Reader.MoveToContent();
 
654
                        }
 
655
 
 
656
                        ReadEndElement();
 
657
 
 
658
                        return ob;
 
659
                }
 
660
 
 
661
                public Mono.Addins.Description.AddinProperty ReadObject_AddinProperty (bool isNullable, bool checkType)
 
662
                {
 
663
                        Mono.Addins.Description.AddinProperty ob = null;
 
664
                        if (isNullable && ReadNull()) return null;
 
665
 
 
666
                        if (checkType) 
 
667
                        {
 
668
                                System.Xml.XmlQualifiedName t = GetXsiType();
 
669
                                if (t == null)
 
670
                                { }
 
671
                                else if (t.Name != "AddinProperty" || t.Namespace != "")
 
672
                                        throw CreateUnknownTypeException(t);
 
673
                        }
 
674
 
 
675
                        ob = (Mono.Addins.Description.AddinProperty) Activator.CreateInstance(typeof(Mono.Addins.Description.AddinProperty), true);
 
676
 
 
677
                        Reader.MoveToElement();
 
678
 
 
679
                        while (Reader.MoveToNextAttribute())
 
680
                        {
 
681
                                if (Reader.LocalName == "name" && Reader.NamespaceURI == "") {
 
682
                                        ob.@Name = Reader.Value;
 
683
                                }
 
684
                                else if (Reader.LocalName == "locale" && Reader.NamespaceURI == "") {
 
685
                                        ob.@Locale = Reader.Value;
 
686
                                }
 
687
                                else if (IsXmlnsAttribute (Reader.Name)) {
 
688
                                }
 
689
                                else {
 
690
                                        UnknownNode (ob);
 
691
                                }
 
692
                        }
 
693
 
 
694
                        Reader.MoveToElement ();
 
695
                        Reader.MoveToElement();
 
696
                        if (Reader.IsEmptyElement) {
 
697
                                Reader.Skip ();
 
698
                                return ob;
 
699
                        }
 
700
 
 
701
                        Reader.ReadStartElement();
 
702
                        Reader.MoveToContent();
 
703
 
 
704
 
 
705
                        while (Reader.NodeType != System.Xml.XmlNodeType.EndElement) 
 
706
                        {
 
707
                                if (Reader.NodeType == System.Xml.XmlNodeType.Element) 
 
708
                                {
 
709
                                        UnknownNode (ob);
 
710
                                }
 
711
                                else if (Reader.NodeType == System.Xml.XmlNodeType.Text || Reader.NodeType == System.Xml.XmlNodeType.CDATA)
 
712
                                {
 
713
                                        ob.@Value = ReadString (ob.@Value);
 
714
                                }
 
715
                                else
 
716
                                        UnknownNode(ob);
 
717
 
 
718
                                Reader.MoveToContent();
 
719
                        }
 
720
 
 
721
                        ReadEndElement();
 
722
 
 
723
                        return ob;
 
724
                }
 
725
 
 
726
                protected override void InitCallbacks ()
 
727
                {
 
728
                }
 
729
 
 
730
                protected override void InitIDs ()
 
731
                {
 
732
                }
 
733
 
 
734
        }
 
735
 
 
736
        internal class RepositoryWriter : XmlSerializationWriter
 
737
        {
 
738
                const string xmlNamespace = "http://www.w3.org/2000/xmlns/";
 
739
                static readonly System.Reflection.MethodInfo toBinHexStringMethod = typeof (XmlConvert).GetMethod ("ToBinHexString", System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.NonPublic, null, new Type [] {typeof (byte [])}, null);
 
740
                static string ToBinHexString (byte [] input)
 
741
                {
 
742
                        return input == null ? null : (string) toBinHexStringMethod.Invoke (null, new object [] {input});
 
743
                }
 
744
                public void WriteRoot_Repository (object o)
 
745
                {
 
746
                        WriteStartDocument ();
 
747
                        Mono.Addins.Setup.Repository ob = (Mono.Addins.Setup.Repository) o;
 
748
                        TopLevelElement ();
 
749
                        WriteObject_Repository (ob, "Repository", "", true, false, true);
 
750
                }
 
751
 
 
752
                void WriteObject_Repository (Mono.Addins.Setup.Repository ob, string element, string namesp, bool isNullable, bool needType, bool writeWrappingElem)
 
753
                {
 
754
                        if (((object)ob) == null)
 
755
                        {
 
756
                                if (isNullable)
 
757
                                        WriteNullTagLiteral(element, namesp);
 
758
                                return;
 
759
                        }
 
760
 
 
761
                        System.Type type = ob.GetType ();
 
762
                        if (type == typeof(Mono.Addins.Setup.Repository))
 
763
                        { }
 
764
                        else {
 
765
                                throw CreateUnknownTypeException (ob);
 
766
                        }
 
767
 
 
768
                        if (writeWrappingElem) {
 
769
                                WriteStartElement (element, namesp, ob);
 
770
                        }
 
771
 
 
772
                        if (needType) WriteXsiType("Repository", "");
 
773
 
 
774
                        WriteElementString ("Name", "", ob.@Name);
 
775
                        WriteElementString ("Url", "", ob.@Url);
 
776
                        if (ob.@Repositories != null) {
 
777
                                for (int n51 = 0; n51 < ob.@Repositories.Count; n51++) {
 
778
                                        WriteObject_ReferenceRepositoryEntry (((Mono.Addins.Setup.ReferenceRepositoryEntry) ob.@Repositories[n51]), "Repository", "", false, false, true);
 
779
                                }
 
780
                        }
 
781
                        if (ob.@Addins != null) {
 
782
                                for (int n52 = 0; n52 < ob.@Addins.Count; n52++) {
 
783
                                        WriteObject_PackageRepositoryEntry (((Mono.Addins.Setup.PackageRepositoryEntry) ob.@Addins[n52]), "Addin", "", false, false, true);
 
784
                                }
 
785
                        }
 
786
                        if (writeWrappingElem) WriteEndElement (ob);
 
787
                }
 
788
 
 
789
                void WriteObject_ReferenceRepositoryEntry (Mono.Addins.Setup.ReferenceRepositoryEntry ob, string element, string namesp, bool isNullable, bool needType, bool writeWrappingElem)
 
790
                {
 
791
                        if (((object)ob) == null)
 
792
                        {
 
793
                                if (isNullable)
 
794
                                        WriteNullTagLiteral(element, namesp);
 
795
                                return;
 
796
                        }
 
797
 
 
798
                        System.Type type = ob.GetType ();
 
799
                        if (type == typeof(Mono.Addins.Setup.ReferenceRepositoryEntry))
 
800
                        { }
 
801
                        else {
 
802
                                throw CreateUnknownTypeException (ob);
 
803
                        }
 
804
 
 
805
                        if (writeWrappingElem) {
 
806
                                WriteStartElement (element, namesp, ob);
 
807
                        }
 
808
 
 
809
                        if (needType) WriteXsiType("ReferenceRepositoryEntry", "");
 
810
 
 
811
                        WriteElementString ("Url", "", ob.@Url);
 
812
                        WriteElementString ("LastModified", "", XmlConvert.ToString (ob.@LastModified, XmlDateTimeSerializationMode.RoundtripKind));
 
813
                        if (writeWrappingElem) WriteEndElement (ob);
 
814
                }
 
815
 
 
816
                void WriteObject_PackageRepositoryEntry (Mono.Addins.Setup.PackageRepositoryEntry ob, string element, string namesp, bool isNullable, bool needType, bool writeWrappingElem)
 
817
                {
 
818
                        if (((object)ob) == null)
 
819
                        {
 
820
                                if (isNullable)
 
821
                                        WriteNullTagLiteral(element, namesp);
 
822
                                return;
 
823
                        }
 
824
 
 
825
                        System.Type type = ob.GetType ();
 
826
                        if (type == typeof(Mono.Addins.Setup.PackageRepositoryEntry))
 
827
                        { }
 
828
                        else {
 
829
                                throw CreateUnknownTypeException (ob);
 
830
                        }
 
831
 
 
832
                        if (writeWrappingElem) {
 
833
                                WriteStartElement (element, namesp, ob);
 
834
                        }
 
835
 
 
836
                        if (needType) WriteXsiType("PackageRepositoryEntry", "");
 
837
 
 
838
                        WriteElementString ("Url", "", ob.@Url);
 
839
                        WriteObject_AddinInfo (ob.@Addin, "Addin", "", false, false, true);
 
840
                        if (writeWrappingElem) WriteEndElement (ob);
 
841
                }
 
842
 
 
843
                void WriteObject_AddinInfo (Mono.Addins.Setup.AddinInfo ob, string element, string namesp, bool isNullable, bool needType, bool writeWrappingElem)
 
844
                {
 
845
                        if (((object)ob) == null)
 
846
                        {
 
847
                                if (isNullable)
 
848
                                        WriteNullTagLiteral(element, namesp);
 
849
                                return;
 
850
                        }
 
851
 
 
852
                        System.Type type = ob.GetType ();
 
853
                        if (type == typeof(Mono.Addins.Setup.AddinInfo))
 
854
                        { }
 
855
                        else {
 
856
                                throw CreateUnknownTypeException (ob);
 
857
                        }
 
858
 
 
859
                        if (writeWrappingElem) {
 
860
                                WriteStartElement (element, namesp, ob);
 
861
                        }
 
862
 
 
863
                        if (needType) WriteXsiType("AddinInfo", "");
 
864
 
 
865
                        WriteElementString ("Id", "", ob.@LocalId);
 
866
                        WriteElementString ("Namespace", "", ob.@Namespace);
 
867
                        WriteElementString ("Name", "", ob.@Name);
 
868
                        WriteElementString ("Version", "", ob.@Version);
 
869
                        WriteElementString ("BaseVersion", "", ob.@BaseVersion);
 
870
                        WriteElementString ("Author", "", ob.@Author);
 
871
                        WriteElementString ("Copyright", "", ob.@Copyright);
 
872
                        WriteElementString ("Url", "", ob.@Url);
 
873
                        WriteElementString ("Description", "", ob.@Description);
 
874
                        WriteElementString ("Category", "", ob.@Category);
 
875
                        if (ob.@Dependencies != null) {
 
876
                                WriteStartElement ("Dependencies", "", ob.@Dependencies);
 
877
                                for (int n53 = 0; n53 < ob.@Dependencies.Count; n53++) {
 
878
                                        if (((object)ob.@Dependencies[n53]) == null) { }
 
879
                                        else if (ob.@Dependencies[n53].GetType() == typeof(Mono.Addins.Description.AssemblyDependency)) {
 
880
                                                WriteObject_AssemblyDependency (((Mono.Addins.Description.AssemblyDependency) ob.@Dependencies[n53]), "AssemblyDependency", "", false, false, true);
 
881
                                        }
 
882
                                        else if (ob.@Dependencies[n53].GetType() == typeof(Mono.Addins.Description.NativeDependency)) {
 
883
                                                WriteObject_NativeReference (((Mono.Addins.Description.NativeDependency) ob.@Dependencies[n53]), "NativeDependency", "", false, false, true);
 
884
                                        }
 
885
                                        else if (ob.@Dependencies[n53].GetType() == typeof(Mono.Addins.Description.AddinDependency)) {
 
886
                                                WriteObject_AddinReference (((Mono.Addins.Description.AddinDependency) ob.@Dependencies[n53]), "AddinDependency", "", false, false, true);
 
887
                                        }
 
888
                                        else throw CreateUnknownTypeException (ob.@Dependencies[n53]);
 
889
                                }
 
890
                                WriteEndElement (ob.@Dependencies);
 
891
                        }
 
892
                        if (ob.@OptionalDependencies != null) {
 
893
                                WriteStartElement ("OptionalDependencies", "", ob.@OptionalDependencies);
 
894
                                for (int n54 = 0; n54 < ob.@OptionalDependencies.Count; n54++) {
 
895
                                        if (((object)ob.@OptionalDependencies[n54]) == null) { }
 
896
                                        else if (ob.@OptionalDependencies[n54].GetType() == typeof(Mono.Addins.Description.AssemblyDependency)) {
 
897
                                                WriteObject_AssemblyDependency (((Mono.Addins.Description.AssemblyDependency) ob.@OptionalDependencies[n54]), "AssemblyDependency", "", false, false, true);
 
898
                                        }
 
899
                                        else if (ob.@OptionalDependencies[n54].GetType() == typeof(Mono.Addins.Description.NativeDependency)) {
 
900
                                                WriteObject_NativeReference (((Mono.Addins.Description.NativeDependency) ob.@OptionalDependencies[n54]), "NativeDependency", "", false, false, true);
 
901
                                        }
 
902
                                        else if (ob.@OptionalDependencies[n54].GetType() == typeof(Mono.Addins.Description.AddinDependency)) {
 
903
                                                WriteObject_AddinReference (((Mono.Addins.Description.AddinDependency) ob.@OptionalDependencies[n54]), "AddinDependency", "", false, false, true);
 
904
                                        }
 
905
                                        else throw CreateUnknownTypeException (ob.@OptionalDependencies[n54]);
 
906
                                }
 
907
                                WriteEndElement (ob.@OptionalDependencies);
 
908
                        }
 
909
                        if (ob.@Properties != null) {
 
910
                                WriteStartElement ("Properties", "", ob.@Properties);
 
911
                                for (int n55 = 0; n55 < ob.@Properties.Count; n55++) {
 
912
                                        WriteObject_AddinProperty (ob.@Properties[n55], "Property", "", false, false, true);
 
913
                                }
 
914
                                WriteEndElement (ob.@Properties);
 
915
                        }
 
916
                        if (writeWrappingElem) WriteEndElement (ob);
 
917
                }
 
918
 
 
919
                void WriteObject_AssemblyDependency (Mono.Addins.Description.AssemblyDependency ob, string element, string namesp, bool isNullable, bool needType, bool writeWrappingElem)
 
920
                {
 
921
                        if (((object)ob) == null)
 
922
                        {
 
923
                                if (isNullable)
 
924
                                        WriteNullTagLiteral(element, namesp);
 
925
                                return;
 
926
                        }
 
927
 
 
928
                        System.Type type = ob.GetType ();
 
929
                        if (type == typeof(Mono.Addins.Description.AssemblyDependency))
 
930
                        { }
 
931
                        else {
 
932
                                throw CreateUnknownTypeException (ob);
 
933
                        }
 
934
 
 
935
                        if (writeWrappingElem) {
 
936
                                WriteStartElement (element, namesp, ob);
 
937
                        }
 
938
 
 
939
                        if (needType) WriteXsiType("AssemblyDependency", "");
 
940
 
 
941
                        WriteElementString ("FullName", "", ob.@FullName);
 
942
                        WriteElementString ("Package", "", ob.@Package);
 
943
                        if (writeWrappingElem) WriteEndElement (ob);
 
944
                }
 
945
 
 
946
                void WriteObject_NativeReference (Mono.Addins.Description.NativeDependency ob, string element, string namesp, bool isNullable, bool needType, bool writeWrappingElem)
 
947
                {
 
948
                        if (((object)ob) == null)
 
949
                        {
 
950
                                if (isNullable)
 
951
                                        WriteNullTagLiteral(element, namesp);
 
952
                                return;
 
953
                        }
 
954
 
 
955
                        System.Type type = ob.GetType ();
 
956
                        if (type == typeof(Mono.Addins.Description.NativeDependency))
 
957
                        { }
 
958
                        else {
 
959
                                throw CreateUnknownTypeException (ob);
 
960
                        }
 
961
 
 
962
                        if (writeWrappingElem) {
 
963
                                WriteStartElement (element, namesp, ob);
 
964
                        }
 
965
 
 
966
                        if (needType) WriteXsiType("NativeReference", "");
 
967
 
 
968
                        if (writeWrappingElem) WriteEndElement (ob);
 
969
                }
 
970
 
 
971
                void WriteObject_AddinReference (Mono.Addins.Description.AddinDependency ob, string element, string namesp, bool isNullable, bool needType, bool writeWrappingElem)
 
972
                {
 
973
                        if (((object)ob) == null)
 
974
                        {
 
975
                                if (isNullable)
 
976
                                        WriteNullTagLiteral(element, namesp);
 
977
                                return;
 
978
                        }
 
979
 
 
980
                        System.Type type = ob.GetType ();
 
981
                        if (type == typeof(Mono.Addins.Description.AddinDependency))
 
982
                        { }
 
983
                        else {
 
984
                                throw CreateUnknownTypeException (ob);
 
985
                        }
 
986
 
 
987
                        if (writeWrappingElem) {
 
988
                                WriteStartElement (element, namesp, ob);
 
989
                        }
 
990
 
 
991
                        if (needType) WriteXsiType("AddinReference", "");
 
992
 
 
993
                        WriteElementString ("AddinId", "", ob.@AddinId);
 
994
                        WriteElementString ("Version", "", ob.@Version);
 
995
                        if (writeWrappingElem) WriteEndElement (ob);
 
996
                }
 
997
 
 
998
                void WriteObject_AddinProperty (Mono.Addins.Description.AddinProperty ob, string element, string namesp, bool isNullable, bool needType, bool writeWrappingElem)
 
999
                {
 
1000
                        if (((object)ob) == null)
 
1001
                        {
 
1002
                                if (isNullable)
 
1003
                                        WriteNullTagLiteral(element, namesp);
 
1004
                                return;
 
1005
                        }
 
1006
 
 
1007
                        System.Type type = ob.GetType ();
 
1008
                        if (type == typeof(Mono.Addins.Description.AddinProperty))
 
1009
                        { }
 
1010
                        else {
 
1011
                                throw CreateUnknownTypeException (ob);
 
1012
                        }
 
1013
 
 
1014
                        if (writeWrappingElem) {
 
1015
                                WriteStartElement (element, namesp, ob);
 
1016
                        }
 
1017
 
 
1018
                        if (needType) WriteXsiType("AddinProperty", "");
 
1019
 
 
1020
                        WriteAttribute ("name", "", ob.@Name);
 
1021
                        WriteAttribute ("locale", "", ob.@Locale);
 
1022
 
 
1023
                        WriteValue (ob.@Value);
 
1024
                        if (writeWrappingElem) WriteEndElement (ob);
 
1025
                }
 
1026
 
 
1027
                protected override void InitCallbacks ()
 
1028
                {
 
1029
                }
 
1030
 
 
1031
        }
 
1032
}
 
1033