2 // System.Xml.Schema.XmlSchema.cs
5 // Dwivedi, Ajay kumar Adwiv@Yahoo.com
6 // Atsushi Enomoto ginga@kit.hi-ho.ne.jp
10 // Permission is hereby granted, free of charge, to any person obtaining
11 // a copy of this software and associated documentation files (the
12 // "Software"), to deal in the Software without restriction, including
13 // without limitation the rights to use, copy, modify, merge, publish,
14 // distribute, sublicense, and/or sell copies of the Software, and to
15 // permit persons to whom the Software is furnished to do so, subject to
16 // the following conditions:
18 // The above copyright notice and this permission notice shall be
19 // included in all copies or substantial portions of the Software.
21 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
22 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
23 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
24 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
25 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
26 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
27 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
30 using System.Collections;
33 using System.Xml.Serialization;
34 using System.ComponentModel;
36 namespace System.Xml.Schema
39 /// Summary description for XmlSchema.
41 [XmlRoot ("schema",Namespace=XmlSchema.Namespace)]
42 public class XmlSchema : XmlSchemaObject
45 public const string Namespace = "http://www.w3.org/2001/XMLSchema";
46 public const string InstanceNamespace = "http://www.w3.org/2001/XMLSchema-instance";
47 internal const string XdtNamespace = "http://www.w3.org/2003/11/xpath-datatypes";
50 private XmlSchemaForm attributeFormDefault ;
51 private XmlSchemaObjectTable attributeGroups ;
52 private XmlSchemaObjectTable attributes ;
53 private XmlSchemaDerivationMethod blockDefault ;
54 private XmlSchemaForm elementFormDefault ;
55 private XmlSchemaObjectTable elements ;
56 private XmlSchemaDerivationMethod finalDefault ;
57 private XmlSchemaObjectTable groups ;
59 private XmlSchemaObjectCollection includes ;
60 private XmlSchemaObjectCollection items ;
61 private XmlSchemaObjectTable notations ;
62 private XmlSchemaObjectTable schemaTypes ;
63 private string targetNamespace ;
64 private XmlAttribute[] unhandledAttributes ;
65 private string version;
67 // other post schema compilation infoset
68 private Hashtable idCollection;
69 private XmlSchemaObjectTable namedIdentities;
70 private XmlSchemaSet schemas;
72 private XmlNameTable nameTable;
74 internal bool missedSubComponents;
76 // Only compilation-time use
77 private XmlSchemaObjectCollection compilationItems;
78 private Hashtable handledUris;
80 // Compiler specific things
81 const string xmlname = "schema";
85 attributeFormDefault= XmlSchemaForm.None;
86 blockDefault = XmlSchemaDerivationMethod.None;
87 elementFormDefault = XmlSchemaForm.None;
88 finalDefault = XmlSchemaDerivationMethod.None;
89 includes = new XmlSchemaObjectCollection();
91 items = new XmlSchemaObjectCollection();
92 attributeGroups = new XmlSchemaObjectTable();
93 attributes = new XmlSchemaObjectTable();
94 elements = new XmlSchemaObjectTable();
95 groups = new XmlSchemaObjectTable();
96 notations = new XmlSchemaObjectTable();
97 schemaTypes = new XmlSchemaObjectTable();
98 idCollection = new Hashtable ();
99 namedIdentities = new XmlSchemaObjectTable();
104 [DefaultValue (XmlSchemaForm.None)]
105 [System.Xml.Serialization.XmlAttribute ("attributeFormDefault")]
106 public XmlSchemaForm AttributeFormDefault
108 get{ return attributeFormDefault; }
109 set{ this.attributeFormDefault = value;}
112 [DefaultValue (XmlSchemaDerivationMethod.None)]
113 [System.Xml.Serialization.XmlAttribute ("blockDefault")]
114 public XmlSchemaDerivationMethod BlockDefault
116 get{ return blockDefault;}
117 set{ blockDefault = value;}
120 [DefaultValue (XmlSchemaDerivationMethod.None)]
121 [System.Xml.Serialization.XmlAttribute ("finalDefault")]
122 public XmlSchemaDerivationMethod FinalDefault
124 get{ return finalDefault; }
125 set{ finalDefault = value; }
128 [DefaultValue (XmlSchemaForm.None)]
129 [System.Xml.Serialization.XmlAttribute ("elementFormDefault")]
130 public XmlSchemaForm ElementFormDefault
132 get{ return elementFormDefault; }
133 set{ elementFormDefault = value; }
136 [System.Xml.Serialization.XmlAttribute ("targetNamespace")]
137 public string TargetNamespace
139 get{ return targetNamespace; }
140 set{ targetNamespace = value; }
143 [System.Xml.Serialization.XmlAttribute ("version")]
144 public string Version
146 get{ return version; }
147 set{ version = value; }
150 [XmlElement ("include",typeof(XmlSchemaInclude), Namespace="http://www.w3.org/2001/XMLSchema")]
151 [XmlElement ("import",typeof(XmlSchemaImport), Namespace="http://www.w3.org/2001/XMLSchema")]
152 [XmlElement ("redefine",typeof(XmlSchemaRedefine), Namespace="http://www.w3.org/2001/XMLSchema")]
153 public XmlSchemaObjectCollection Includes
155 get{ return includes;}
158 [XmlElement ("simpleType", typeof (XmlSchemaSimpleType), Namespace="http://www.w3.org/2001/XMLSchema")]
159 [XmlElement ("complexType", typeof (XmlSchemaComplexType), Namespace="http://www.w3.org/2001/XMLSchema")]
160 [XmlElement ("group", typeof (XmlSchemaGroup),Namespace="http://www.w3.org/2001/XMLSchema")]
161 //Only Schema's attributeGroup has type XmlSchemaAttributeGroup.
162 //Others (complextype, restrictions etc) must have XmlSchemaAttributeGroupRef
163 [XmlElement ("attributeGroup", typeof (XmlSchemaAttributeGroup), Namespace="http://www.w3.org/2001/XMLSchema")]
164 [XmlElement ("element", typeof (XmlSchemaElement), Namespace="http://www.w3.org/2001/XMLSchema")]
165 [XmlElement ("attribute", typeof (XmlSchemaAttribute), Namespace="http://www.w3.org/2001/XMLSchema")]
166 [XmlElement ("notation", typeof (XmlSchemaNotation), Namespace="http://www.w3.org/2001/XMLSchema")]
167 [XmlElement ("annotation", typeof (XmlSchemaAnnotation), Namespace="http://www.w3.org/2001/XMLSchema")]
168 public XmlSchemaObjectCollection Items
174 public bool IsCompiled
176 get{ return this.CompilationId != Guid.Empty; }
180 public XmlSchemaObjectTable Attributes
182 get{ return attributes; }
186 public XmlSchemaObjectTable AttributeGroups
188 get{ return attributeGroups; }
192 public XmlSchemaObjectTable SchemaTypes
194 get{ return schemaTypes; }
198 public XmlSchemaObjectTable Elements
200 get{ return elements; }
203 [System.Xml.Serialization.XmlAttribute ("id")]
211 public XmlAttribute [] UnhandledAttributes
214 if (unhandledAttributeList != null) {
215 unhandledAttributes = (XmlAttribute []) unhandledAttributeList.ToArray (typeof (XmlAttribute));
216 unhandledAttributeList = null;
218 return unhandledAttributes;
221 unhandledAttributes = value;
222 unhandledAttributeList = null;
227 public XmlSchemaObjectTable Groups
229 get{ return groups; }
233 public XmlSchemaObjectTable Notations
235 get{ return notations; }
238 internal Hashtable IDCollection
240 get { return idCollection; }
243 internal XmlSchemaObjectTable NamedIdentities
245 get { return namedIdentities; }
248 internal XmlSchemaSet Schemas
250 get { return schemas; }
258 /// This compile method does two things:
259 /// 1. It compiles and fills the PSVI dataset
260 /// 2. Validates the schema by calling Validate method.
261 /// Every XmlSchemaObject has a Compile Method which gets called.
264 /// 1. blockDefault must be one of #all | List of (extension | restriction | substitution)
265 /// 2. finalDefault must be one of (#all | List of (extension | restriction| union| list))
266 /// 3. id must be of type ID
267 /// 4. targetNamespace should be any uri
268 /// 5. version should be a normalizedString
270 public void Compile (ValidationEventHandler handler)
272 Compile (handler, new XmlUrlResolver ());
276 public void Compile (ValidationEventHandler handler, XmlResolver resolver)
278 internal void Compile (ValidationEventHandler handler, XmlResolver resolver)
281 Compile (handler, new Stack (), this, null, resolver);
284 internal void Compile (ValidationEventHandler handler, XmlSchemaSet col, XmlResolver resolver)
286 Compile (handler, new Stack (), this, col, resolver);
289 private void Compile (ValidationEventHandler handler, Stack schemaLocationStack, XmlSchema rootSchema, XmlSchemaSet col, XmlResolver resolver)
291 if (rootSchema != this) {
292 CompilationId = rootSchema.CompilationId;
293 schemas = rootSchema.schemas;
297 if (schemas == null) {
298 schemas = new XmlSchemaSet ();
299 schemas.CompilationId = Guid.NewGuid ();
301 CompilationId = schemas.CompilationId;
302 this.idCollection.Clear ();
304 if (!schemas.Contains (this)) // e.g. xs:import
307 attributeGroups.Clear ();
312 schemaTypes.Clear ();
313 namedIdentities.Clear ();
315 //1. Union and List are not allowed in block default
316 if (BlockDefault != XmlSchemaDerivationMethod.All) {
317 if((BlockDefault & XmlSchemaDerivationMethod.List)!=0 )
318 error(handler, "list is not allowed in blockDefault attribute");
319 if((BlockDefault & XmlSchemaDerivationMethod.Union)!=0 )
320 error(handler, "union is not allowed in blockDefault attribute");
323 //2. Substitution is not allowed in finaldefault.
324 if (FinalDefault != XmlSchemaDerivationMethod.All) {
325 if((FinalDefault & XmlSchemaDerivationMethod.Substitution)!=0 )
326 error(handler, "substitution is not allowed in finalDefault attribute");
329 //3. id must be of type ID
330 XmlSchemaUtil.CompileID(Id, this, this.IDCollection, handler);
332 //4. targetNamespace should be of type anyURI or absent
333 if (TargetNamespace != null) {
334 if(!XmlSchemaUtil.CheckAnyUri (TargetNamespace))
335 error(handler, TargetNamespace+" is not a valid value for targetNamespace attribute of schema");
338 //5. version should be of type normalizedString
339 if (!XmlSchemaUtil.CheckNormalizedString(Version))
340 error(handler, Version + "is not a valid value for version attribute of schema");
342 // Compile the content of this schema
344 compilationItems = new XmlSchemaObjectCollection ();
345 for (int i = 0; i < Items.Count; i++) {
347 Items [i].Parent = this;
349 compilationItems.Add (Items [i]);
351 if (this == rootSchema)
352 handledUris = new Hashtable ();
354 // First, we run into inclusion schemas to collect
355 // compilation target items into compiledItems.
356 for (int i = 0; i < Includes.Count; i++) {
358 Includes [i].Parent = this;
360 XmlSchemaExternal ext = Includes [i] as XmlSchemaExternal;
362 error (handler, String.Format ("Object of Type {0} is not valid in Includes Property of XmlSchema", Includes [i].GetType().Name));
366 if (ext.SchemaLocation == null)
369 Stream stream = null;
371 if (resolver != null) {
372 url = GetResolvedUri (resolver, ext.SchemaLocation);
373 if (schemaLocationStack.Contains (url)) {
374 // Just skip nested inclusion.
375 // The spec is "carefully written"
376 // not to handle it as an error.
377 // error (handler, "Nested inclusion was found: " + url);
378 // must skip this inclusion
381 if (rootSchema.handledUris.Contains (url))
382 // This schema is already handled, so simply skip (otherwise, duplicate definition errrors occur.
384 rootSchema.handledUris.Add (url, url);
386 stream = resolver.GetEntity (new Uri (url), null, typeof (Stream)) as Stream;
387 } catch (Exception) {
388 // LAMESPEC: This is not good way to handle errors, but since we cannot know what kind of XmlResolver will come, so there are no mean to avoid this ugly catch.
389 warn (handler, "Could not resolve schema location URI: " + url);
394 // Process redefinition children in advance.
395 XmlSchemaRedefine redefine = Includes [i] as XmlSchemaRedefine;
396 if (redefine != null) {
397 for (int j = 0; j < redefine.Items.Count; j++) {
398 XmlSchemaObject redefinedObj = redefine.Items [j];
399 redefinedObj.isRedefinedComponent = true;
400 redefinedObj.isRedefineChild = true;
401 if (redefinedObj is XmlSchemaType ||
402 redefinedObj is XmlSchemaGroup ||
403 redefinedObj is XmlSchemaAttributeGroup)
404 compilationItems.Add (redefinedObj);
406 error (handler, "Redefinition is only allowed to simpleType, complexType, group and attributeGroup.");
410 XmlSchema includedSchema = null;
411 if (stream == null) {
412 // It is missing schema components.
413 missedSubComponents = true;
416 schemaLocationStack.Push (url);
417 XmlTextReader xtr = null;
419 xtr = new XmlTextReader (url, stream, nameTable);
420 includedSchema = XmlSchema.Read (xtr, handler);
425 includedSchema.schemas = schemas;
428 // Set - actual - target namespace for the included schema * before compilation*.
429 XmlSchemaImport import = ext as XmlSchemaImport;
430 if (import != null) {
431 if (TargetNamespace == includedSchema.TargetNamespace) {
432 error (handler, "Target namespace must be different from that of included schema.");
434 } else if (includedSchema.TargetNamespace != import.Namespace) {
435 error (handler, "Attribute namespace and its importing schema's target namespace must be the same.");
439 if (TargetNamespace == null &&
440 includedSchema.TargetNamespace != null) {
441 error (handler, "Target namespace is required to include a schema which has its own target namespace");
444 else if (TargetNamespace != null &&
445 includedSchema.TargetNamespace == null)
446 includedSchema.TargetNamespace = TargetNamespace;
449 // Compile included schema.
450 includedSchema.idCollection = this.IDCollection;
451 includedSchema.Compile (handler, schemaLocationStack, rootSchema, col, resolver);
452 schemaLocationStack.Pop ();
455 rootSchema.schemas.Add (includedSchema);
457 // Note that we use compiled items. Items
458 // may not exist in Items, since included
459 // schema also includes another schemas.
460 foreach (DictionaryEntry entry in includedSchema.Attributes)
461 compilationItems.Add ((XmlSchemaObject) entry.Value);
462 foreach (DictionaryEntry entry in includedSchema.Elements)
463 compilationItems.Add ((XmlSchemaObject) entry.Value);
464 foreach (DictionaryEntry entry in includedSchema.SchemaTypes)
465 compilationItems.Add ((XmlSchemaObject) entry.Value);
466 foreach (DictionaryEntry entry in includedSchema.AttributeGroups)
467 compilationItems.Add ((XmlSchemaObject) entry.Value);
468 foreach (DictionaryEntry entry in includedSchema.Groups)
469 compilationItems.Add ((XmlSchemaObject) entry.Value);
470 foreach (DictionaryEntry entry in includedSchema.Notations)
471 compilationItems.Add ((XmlSchemaObject) entry.Value);
474 // Compilation phase.
475 // At least each Compile() must gives unique (qualified) name for each component.
476 // It also checks self-resolvable properties correct.
477 // Post compilation schema information contribution is not required here.
478 // It should be done by Validate().
479 for (int i = 0; i < compilationItems.Count; i++) {
480 XmlSchemaObject obj = compilationItems [i];
481 if(obj is XmlSchemaAnnotation) {
482 int numerr = ((XmlSchemaAnnotation)obj).Compile (handler, this);
483 errorCount += numerr;
484 } else if (obj is XmlSchemaAttribute) {
485 XmlSchemaAttribute attr = (XmlSchemaAttribute) obj;
486 attr.ParentIsSchema = true;
487 int numerr = attr.Compile (handler, this);
488 errorCount += numerr;
491 XmlSchemaUtil.AddToTable (Attributes, attr, attr.QualifiedName, handler);
493 } else if (obj is XmlSchemaAttributeGroup) {
494 XmlSchemaAttributeGroup attrgrp = (XmlSchemaAttributeGroup) obj;
495 int numerr = attrgrp.Compile(handler, this);
496 errorCount += numerr;
498 XmlSchemaUtil.AddToTable (
501 attrgrp.QualifiedName,
503 } else if (obj is XmlSchemaComplexType) {
504 XmlSchemaComplexType ctype = (XmlSchemaComplexType) obj;
505 ctype.ParentIsSchema = true;
506 int numerr = ctype.Compile (handler, this);
507 errorCount += numerr;
509 XmlSchemaUtil.AddToTable (
514 } else if (obj is XmlSchemaSimpleType) {
515 XmlSchemaSimpleType stype = (XmlSchemaSimpleType) obj;
516 stype.islocal = false; //This simple type is toplevel
517 int numerr = stype.Compile (handler, this);
518 errorCount += numerr;
520 XmlSchemaUtil.AddToTable (
525 } else if (obj is XmlSchemaElement) {
526 XmlSchemaElement elem = (XmlSchemaElement) obj;
527 elem.parentIsSchema = true;
528 int numerr = elem.Compile (handler, this);
529 errorCount += numerr;
531 XmlSchemaUtil.AddToTable (
536 } else if (obj is XmlSchemaGroup) {
537 XmlSchemaGroup grp = (XmlSchemaGroup) obj;
538 int numerr = grp.Compile (handler, this);
539 errorCount += numerr;
541 XmlSchemaUtil.AddToTable (
546 } else if (obj is XmlSchemaNotation) {
547 XmlSchemaNotation ntn = (XmlSchemaNotation) obj;
548 int numerr = ntn.Compile (handler, this);
549 errorCount += numerr;
551 XmlSchemaUtil.AddToTable (
557 ValidationHandler.RaiseValidationEvent (
560 String.Format ("Object of Type {0} is not valid in Item Property of Schema", obj.GetType ().Name),
564 XmlSeverityType.Error);
568 if (rootSchema == this)
576 private string GetResolvedUri (XmlResolver resolver, string relativeUri)
579 if (this.SourceUri != null && this.SourceUri != String.Empty)
580 baseUri = new Uri (this.SourceUri);
581 return resolver.ResolveUri (baseUri, relativeUri).ToString ();
584 internal bool IsNamespaceAbsent (string ns)
586 return !schemas.Contains (ns);
591 private void Validate (ValidationEventHandler handler)
593 ValidationId = CompilationId;
595 // Firstly Element needs to be filled their substitution group info
596 foreach (XmlSchemaElement elem in Elements.Values)
597 elem.FillSubstitutionElementInfo ();
600 foreach (XmlSchemaAttribute attr in Attributes.Values)
601 errorCount += attr.Validate (handler, this);
602 foreach (XmlSchemaAttributeGroup attrgrp in AttributeGroups.Values)
603 errorCount += attrgrp.Validate (handler, this);
604 foreach (XmlSchemaType type in SchemaTypes.Values)
605 errorCount += type.Validate (handler, this);
606 foreach (XmlSchemaElement elem in Elements.Values)
607 errorCount += elem.Validate (handler, this);
608 foreach (XmlSchemaGroup grp in Groups.Values)
609 errorCount += grp.Validate (handler, this);
610 foreach (XmlSchemaNotation ntn in Notations.Values)
611 errorCount += ntn.Validate (handler, this);
616 // We cannot use xml deserialization, since it does not provide line info, qname context, and so on.
617 public static XmlSchema Read (TextReader reader, ValidationEventHandler validationEventHandler)
619 return Read (new XmlTextReader (reader),validationEventHandler);
621 public static XmlSchema Read (Stream stream, ValidationEventHandler validationEventHandler)
623 return Read (new XmlTextReader (stream),validationEventHandler);
626 public static XmlSchema Read (XmlReader rdr, ValidationEventHandler validationEventHandler)
628 XmlSchemaReader reader = new XmlSchemaReader (rdr, validationEventHandler);
630 if (reader.ReadState == ReadState.Initial)
631 reader.ReadNextElement ();
633 int startDepth = reader.Depth;
637 switch(reader.NodeType)
639 case XmlNodeType.Element:
640 if(reader.LocalName == "schema")
642 XmlSchema schema = new XmlSchema ();
643 schema.nameTable = rdr.NameTable;
645 schema.LineNumber = reader.LineNumber;
646 schema.LinePosition = reader.LinePosition;
647 schema.SourceUri = reader.BaseURI;
649 ReadAttributes(schema, reader, validationEventHandler);
650 //IsEmptyElement does not behave properly if reader is
651 //positioned at an attribute.
652 reader.MoveToElement();
653 if(!reader.IsEmptyElement)
655 ReadContent(schema, reader, validationEventHandler);
660 if (rdr.NodeType == XmlNodeType.EndElement)
665 //Schema can't be generated. Throw an exception
666 error (validationEventHandler, "The root element must be schema", null);
669 error(validationEventHandler, "This should never happen. XmlSchema.Read 1 ",null);
672 } while(reader.Depth > startDepth && reader.ReadNextElement());
674 // This is thrown regardless of ValidationEventHandler existence.
675 throw new XmlSchemaException ("The top level schema must have namespace " + XmlSchema.Namespace, null);
678 private static void ReadAttributes(XmlSchema schema, XmlSchemaReader reader, ValidationEventHandler h)
682 reader.MoveToElement();
683 while(reader.MoveToNextAttribute())
687 case "attributeFormDefault" :
688 schema.attributeFormDefault = XmlSchemaUtil.ReadFormAttribute(reader,out ex);
690 error(h, reader.Value + " is not a valid value for attributeFormDefault.", ex);
692 case "blockDefault" :
693 schema.blockDefault = XmlSchemaUtil.ReadDerivationAttribute(reader,out ex, "blockDefault",
694 XmlSchemaUtil.ElementBlockAllowed);
696 error (h, ex.Message, ex);
698 case "elementFormDefault":
699 schema.elementFormDefault = XmlSchemaUtil.ReadFormAttribute(reader, out ex);
701 error(h, reader.Value + " is not a valid value for elementFormDefault.", ex);
704 schema.finalDefault = XmlSchemaUtil.ReadDerivationAttribute(reader, out ex, "finalDefault",
705 XmlSchemaUtil.FinalAllowed);
707 error (h, ex.Message , ex);
710 schema.id = reader.Value;
712 case "targetNamespace":
713 schema.targetNamespace = reader.Value;
716 schema.version = reader.Value;
719 if((reader.NamespaceURI == "" && reader.Name != "xmlns") || reader.NamespaceURI == XmlSchema.Namespace)
720 error(h, reader.Name + " attribute is not allowed in schema element",null);
723 XmlSchemaUtil.ReadUnhandledAttribute(reader,schema);
730 private static void ReadContent(XmlSchema schema, XmlSchemaReader reader, ValidationEventHandler h)
732 reader.MoveToElement();
733 if(reader.LocalName != "schema" && reader.NamespaceURI != XmlSchema.Namespace && reader.NodeType != XmlNodeType.Element)
734 error(h, "UNREACHABLE CODE REACHED: Method: Schema.ReadContent, " + reader.LocalName + ", " + reader.NamespaceURI,null);
736 //(include | import | redefine | annotation)*,
737 //((simpleType | complexType | group | attributeGroup | element | attribute | notation | annotation)*
739 while(reader.ReadNextElement())
741 if(reader.NodeType == XmlNodeType.EndElement)
743 if(reader.LocalName != xmlname)
744 error(h,"Should not happen :2: XmlSchema.Read, name="+reader.Name,null);
749 if(reader.LocalName == "include")
751 XmlSchemaInclude include = XmlSchemaInclude.Read(reader,h);
753 schema.includes.Add(include);
756 if(reader.LocalName == "import")
758 XmlSchemaImport import = XmlSchemaImport.Read(reader,h);
760 schema.includes.Add(import);
763 if(reader.LocalName == "redefine")
765 XmlSchemaRedefine redefine = XmlSchemaRedefine.Read(reader,h);
767 schema.includes.Add(redefine);
770 if(reader.LocalName == "annotation")
772 XmlSchemaAnnotation annotation = XmlSchemaAnnotation.Read(reader,h);
773 if(annotation != null)
774 schema.items.Add(annotation);
781 if(reader.LocalName == "simpleType")
783 XmlSchemaSimpleType stype = XmlSchemaSimpleType.Read(reader,h);
785 schema.items.Add(stype);
788 if(reader.LocalName == "complexType")
790 XmlSchemaComplexType ctype = XmlSchemaComplexType.Read(reader,h);
792 schema.items.Add(ctype);
795 if(reader.LocalName == "group")
797 XmlSchemaGroup group = XmlSchemaGroup.Read(reader,h);
799 schema.items.Add(group);
802 if(reader.LocalName == "attributeGroup")
804 XmlSchemaAttributeGroup attributeGroup = XmlSchemaAttributeGroup.Read(reader,h);
805 if(attributeGroup != null)
806 schema.items.Add(attributeGroup);
809 if(reader.LocalName == "element")
811 XmlSchemaElement element = XmlSchemaElement.Read(reader,h);
813 schema.items.Add(element);
816 if(reader.LocalName == "attribute")
818 XmlSchemaAttribute attr = XmlSchemaAttribute.Read(reader,h);
820 schema.items.Add(attr);
823 if(reader.LocalName == "notation")
825 XmlSchemaNotation notation = XmlSchemaNotation.Read(reader,h);
827 schema.items.Add(notation);
830 if(reader.LocalName == "annotation")
832 XmlSchemaAnnotation annotation = XmlSchemaAnnotation.Read(reader,h);
833 if(annotation != null)
834 schema.items.Add(annotation);
838 reader.RaiseInvalidElementError();
845 public void Write(System.IO.Stream stream)
849 public void Write(System.IO.TextWriter writer)
853 public void Write(System.Xml.XmlWriter writer)
857 public void Write(System.IO.Stream stream, System.Xml.XmlNamespaceManager namespaceManager)
859 Write(new XmlTextWriter(stream,null),namespaceManager);
861 public void Write(System.IO.TextWriter writer, System.Xml.XmlNamespaceManager namespaceManager)
863 XmlTextWriter xwriter = new XmlTextWriter(writer);
864 xwriter.Formatting = Formatting.Indented;
865 Write(xwriter,namespaceManager);
868 public void Write (System.Xml.XmlWriter writer, System.Xml.XmlNamespaceManager namespaceManager)
870 XmlSerializerNamespaces nss = new XmlSerializerNamespaces ();
872 if (namespaceManager != null) {
874 nss = new XmlSerializerNamespaces ();
875 foreach (string name in namespaceManager) {
876 //xml and xmlns namespaces are added by default in namespaceManager.
877 //So we should ignore them
878 if (name !="xml" && name != "xmlns")
879 nss.Add (name, namespaceManager.LookupNamespace (name));
883 if (Namespaces != null && Namespaces.Count > 0) {
884 nss.Add (String.Empty, XmlSchema.Namespace);
885 foreach (XmlQualifiedName qn in Namespaces.ToArray ()) {
886 nss.Add (qn.Name, qn.Namespace);
890 if (nss.Count == 0) {
891 // Add the xml schema namespace. (It is done
892 // only when no entry exists in Namespaces).
893 nss.Add ("xs", XmlSchema.Namespace);
894 if (TargetNamespace != null)
895 nss.Add ("tns", TargetNamespace);
898 XmlSchemaSerializer xser = new XmlSchemaSerializer ();
899 xser.Serialize (writer, this, nss);
905 class XmlSchemaSerializer : XmlSerializer
907 protected override void Serialize (object o, XmlSerializationWriter writer)
909 XmlSchemaSerializationWriter w = writer as XmlSchemaSerializationWriter;
910 w.WriteRoot_XmlSchema ((XmlSchema) o);
913 protected override XmlSerializationWriter CreateWriter ()
915 return new XmlSchemaSerializationWriter ();