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);
FromBinHexString(string input)15 		static byte [] FromBinHexString (string input)
16 		{
17 			return input == null ? null : (byte []) fromBinHexStringMethod.Invoke (null, new object [] {input});
18 		}
ReadRoot_Repository()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 
ReadObject_Repository(bool isNullable, bool checkType)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 
ReadObject_PackageRepositoryEntry(bool isNullable, bool checkType)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 
ReadObject_ReferenceRepositoryEntry(bool isNullable, bool checkType)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 
ReadObject_AddinInfo(bool isNullable, bool checkType)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 
ReadObject_AssemblyDependency(bool isNullable, bool checkType)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 
ReadObject_NativeReference(bool isNullable, bool checkType)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 
ReadObject_AddinReference(bool isNullable, bool checkType)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 
ReadObject_AddinProperty(bool isNullable, bool checkType)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 
InitCallbacks()726 		protected override void InitCallbacks ()
727 		{
728 		}
729 
InitIDs()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);
ToBinHexString(byte [] input)740 		static string ToBinHexString (byte [] input)
741 		{
742 			return input == null ? null : (string) toBinHexStringMethod.Invoke (null, new object [] {input});
743 		}
WriteRoot_Repository(object o)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 
WriteObject_Repository(Mono.Addins.Setup.Repository ob, string element, string namesp, bool isNullable, bool needType, bool writeWrappingElem)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 
WriteObject_ReferenceRepositoryEntry(Mono.Addins.Setup.ReferenceRepositoryEntry ob, string element, string namesp, bool isNullable, bool needType, bool writeWrappingElem)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 
WriteObject_PackageRepositoryEntry(Mono.Addins.Setup.PackageRepositoryEntry ob, string element, string namesp, bool isNullable, bool needType, bool writeWrappingElem)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 
WriteObject_AddinInfo(Mono.Addins.Setup.AddinInfo ob, string element, string namesp, bool isNullable, bool needType, bool writeWrappingElem)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 
WriteObject_AssemblyDependency(Mono.Addins.Description.AssemblyDependency ob, string element, string namesp, bool isNullable, bool needType, bool writeWrappingElem)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 
WriteObject_NativeReference(Mono.Addins.Description.NativeDependency ob, string element, string namesp, bool isNullable, bool needType, bool writeWrappingElem)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 
WriteObject_AddinReference(Mono.Addins.Description.AddinDependency ob, string element, string namesp, bool isNullable, bool needType, bool writeWrappingElem)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 
WriteObject_AddinProperty(Mono.Addins.Description.AddinProperty ob, string element, string namesp, bool isNullable, bool needType, bool writeWrappingElem)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 
InitCallbacks()1027 		protected override void InitCallbacks ()
1028 		{
1029 		}
1030 
1031 	}
1032 }
1033 
1034