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;
66 private string language;
68 // other post schema compilation infoset
69 private Hashtable idCollection;
70 private XmlSchemaObjectTable namedIdentities;
71 private XmlSchemaSet schemas;
73 private XmlNameTable nameTable;
75 internal bool missedSubComponents;
77 // Only compilation-time use
78 private XmlSchemaObjectCollection compilationItems;
79 private Hashtable handledUris;
81 // Compiler specific things
82 const string xmlname = "schema";
86 attributeFormDefault= XmlSchemaForm.None;
87 blockDefault = XmlSchemaDerivationMethod.None;
88 elementFormDefault = XmlSchemaForm.None;
89 finalDefault = XmlSchemaDerivationMethod.None;
90 includes = new XmlSchemaObjectCollection();
92 items = new XmlSchemaObjectCollection();
93 attributeGroups = new XmlSchemaObjectTable();
94 attributes = new XmlSchemaObjectTable();
95 elements = new XmlSchemaObjectTable();
96 groups = new XmlSchemaObjectTable();
97 notations = new XmlSchemaObjectTable();
98 schemaTypes = new XmlSchemaObjectTable();
99 idCollection = new Hashtable ();
100 namedIdentities = new XmlSchemaObjectTable();
105 [DefaultValue (XmlSchemaForm.None)]
106 [System.Xml.Serialization.XmlAttribute ("attributeFormDefault")]
107 public XmlSchemaForm AttributeFormDefault
109 get{ return attributeFormDefault; }
110 set{ this.attributeFormDefault = value;}
113 [DefaultValue (XmlSchemaDerivationMethod.None)]
114 [System.Xml.Serialization.XmlAttribute ("blockDefault")]
115 public XmlSchemaDerivationMethod BlockDefault
117 get{ return blockDefault;}
118 set{ blockDefault = value;}
121 [DefaultValue (XmlSchemaDerivationMethod.None)]
122 [System.Xml.Serialization.XmlAttribute ("finalDefault")]
123 public XmlSchemaDerivationMethod FinalDefault
125 get{ return finalDefault; }
126 set{ finalDefault = value; }
129 [DefaultValue (XmlSchemaForm.None)]
130 [System.Xml.Serialization.XmlAttribute ("elementFormDefault")]
131 public XmlSchemaForm ElementFormDefault
133 get{ return elementFormDefault; }
134 set{ elementFormDefault = value; }
137 [System.Xml.Serialization.XmlAttribute ("targetNamespace")]
138 public string TargetNamespace
140 get{ return targetNamespace; }
141 set{ targetNamespace = value; }
144 [System.Xml.Serialization.XmlAttribute ("version")]
145 public string Version
147 get{ return version; }
148 set{ version = value; }
151 [XmlElement ("include",typeof(XmlSchemaInclude), Namespace="http://www.w3.org/2001/XMLSchema")]
152 [XmlElement ("import",typeof(XmlSchemaImport), Namespace="http://www.w3.org/2001/XMLSchema")]
153 [XmlElement ("redefine",typeof(XmlSchemaRedefine), Namespace="http://www.w3.org/2001/XMLSchema")]
154 public XmlSchemaObjectCollection Includes
156 get{ return includes;}
159 [XmlElement ("simpleType", typeof (XmlSchemaSimpleType), Namespace="http://www.w3.org/2001/XMLSchema")]
160 [XmlElement ("complexType", typeof (XmlSchemaComplexType), Namespace="http://www.w3.org/2001/XMLSchema")]
161 [XmlElement ("group", typeof (XmlSchemaGroup),Namespace="http://www.w3.org/2001/XMLSchema")]
162 //Only Schema's attributeGroup has type XmlSchemaAttributeGroup.
163 //Others (complextype, restrictions etc) must have XmlSchemaAttributeGroupRef
164 [XmlElement ("attributeGroup", typeof (XmlSchemaAttributeGroup), Namespace="http://www.w3.org/2001/XMLSchema")]
165 [XmlElement ("element", typeof (XmlSchemaElement), Namespace="http://www.w3.org/2001/XMLSchema")]
166 [XmlElement ("attribute", typeof (XmlSchemaAttribute), Namespace="http://www.w3.org/2001/XMLSchema")]
167 [XmlElement ("notation", typeof (XmlSchemaNotation), Namespace="http://www.w3.org/2001/XMLSchema")]
168 [XmlElement ("annotation", typeof (XmlSchemaAnnotation), Namespace="http://www.w3.org/2001/XMLSchema")]
169 public XmlSchemaObjectCollection Items
175 public bool IsCompiled
177 get{ return this.CompilationId != Guid.Empty; }
181 public XmlSchemaObjectTable Attributes
183 get{ return attributes; }
187 public XmlSchemaObjectTable AttributeGroups
189 get{ return attributeGroups; }
193 public XmlSchemaObjectTable SchemaTypes
195 get{ return schemaTypes; }
199 public XmlSchemaObjectTable Elements
201 get{ return elements; }
204 [System.Xml.Serialization.XmlAttribute ("id")]
212 public XmlAttribute [] UnhandledAttributes
215 if (unhandledAttributeList != null) {
216 unhandledAttributes = (XmlAttribute []) unhandledAttributeList.ToArray (typeof (XmlAttribute));
217 unhandledAttributeList = null;
219 return unhandledAttributes;
222 unhandledAttributes = value;
223 unhandledAttributeList = null;
228 public XmlSchemaObjectTable Groups
230 get{ return groups; }
234 public XmlSchemaObjectTable Notations
236 get{ return notations; }
239 internal Hashtable IDCollection
241 get { return idCollection; }
244 internal XmlSchemaObjectTable NamedIdentities
246 get { return namedIdentities; }
249 internal XmlSchemaSet Schemas
251 get { return schemas; }
259 /// This compile method does two things:
260 /// 1. It compiles and fills the PSVI dataset
261 /// 2. Validates the schema by calling Validate method.
262 /// Every XmlSchemaObject has a Compile Method which gets called.
265 /// 1. blockDefault must be one of #all | List of (extension | restriction | substitution)
266 /// 2. finalDefault must be one of (#all | List of (extension | restriction| union| list))
267 /// 3. id must be of type ID
268 /// 4. targetNamespace should be any uri
269 /// 5. version should be a normalizedString
270 /// 6. xml:lang should be a language
272 public void Compile (ValidationEventHandler handler)
274 Compile (handler, new XmlUrlResolver ());
278 public void Compile (ValidationEventHandler handler, XmlResolver resolver)
280 internal void Compile (ValidationEventHandler handler, XmlResolver resolver)
283 Compile (handler, new Stack (), this, null, resolver);
286 internal void Compile (ValidationEventHandler handler, XmlSchemaSet col, XmlResolver resolver)
288 Compile (handler, new Stack (), this, col, resolver);
291 private void Compile (ValidationEventHandler handler, Stack schemaLocationStack, XmlSchema rootSchema, XmlSchemaSet col, XmlResolver resolver)
293 if (rootSchema != this) {
294 CompilationId = rootSchema.CompilationId;
295 schemas = rootSchema.schemas;
299 if (schemas == null) {
300 schemas = new XmlSchemaSet ();
301 schemas.CompilationId = Guid.NewGuid ();
303 CompilationId = schemas.CompilationId;
304 this.idCollection.Clear ();
306 if (!schemas.Contains (this)) // e.g. xs:import
309 attributeGroups.Clear ();
314 schemaTypes.Clear ();
315 namedIdentities.Clear ();
317 //1. Union and List are not allowed in block default
318 if (BlockDefault != XmlSchemaDerivationMethod.All) {
319 if((BlockDefault & XmlSchemaDerivationMethod.List)!=0 )
320 error(handler, "list is not allowed in blockDefault attribute");
321 if((BlockDefault & XmlSchemaDerivationMethod.Union)!=0 )
322 error(handler, "union is not allowed in blockDefault attribute");
325 //2. Substitution is not allowed in finaldefault.
326 if (FinalDefault != XmlSchemaDerivationMethod.All) {
327 if((FinalDefault & XmlSchemaDerivationMethod.Substitution)!=0 )
328 error(handler, "substitution is not allowed in finalDefault attribute");
331 //3. id must be of type ID
332 XmlSchemaUtil.CompileID(Id, this, this.IDCollection, handler);
334 //4. targetNamespace should be of type anyURI or absent
335 if (TargetNamespace != null) {
336 if(!XmlSchemaUtil.CheckAnyUri (TargetNamespace))
337 error(handler, TargetNamespace+" is not a valid value for targetNamespace attribute of schema");
340 //5. version should be of type normalizedString
341 if (!XmlSchemaUtil.CheckNormalizedString(Version))
342 error(handler, Version + "is not a valid value for version attribute of schema");
344 //6. xml:lang must be a language (removed)
346 // Compile the content of this schema
348 compilationItems = new XmlSchemaObjectCollection ();
349 for (int i = 0; i < Items.Count; i++)
350 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++) {
357 XmlSchemaExternal ext = Includes [i] as XmlSchemaExternal;
359 error (handler, String.Format ("Object of Type {0} is not valid in Includes Property of XmlSchema", Includes [i].GetType().Name));
363 if (ext.SchemaLocation == null)
366 Stream stream = null;
368 if (resolver != null) {
369 url = GetResolvedUri (resolver, ext.SchemaLocation);
370 if (schemaLocationStack.Contains (url)) {
371 // Just skip nested inclusion.
372 // The spec is "carefully written"
373 // not to handle it as an error.
374 // error (handler, "Nested inclusion was found: " + url);
375 // must skip this inclusion
378 if (rootSchema.handledUris.Contains (url))
379 // This schema is already handled, so simply skip (otherwise, duplicate definition errrors occur.
381 rootSchema.handledUris.Add (url, url);
383 stream = resolver.GetEntity (new Uri (url), null, typeof (Stream)) as Stream;
384 } catch (Exception) {
385 // 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.
386 warn (handler, "Could not resolve schema location URI: " + url);
391 // Process redefinition children in advance.
392 XmlSchemaRedefine redefine = Includes [i] as XmlSchemaRedefine;
393 if (redefine != null) {
394 for (int j = 0; j < redefine.Items.Count; j++) {
395 XmlSchemaObject redefinedObj = redefine.Items [j];
396 redefinedObj.isRedefinedComponent = true;
397 redefinedObj.isRedefineChild = true;
398 if (redefinedObj is XmlSchemaType ||
399 redefinedObj is XmlSchemaGroup ||
400 redefinedObj is XmlSchemaAttributeGroup)
401 compilationItems.Add (redefinedObj);
403 error (handler, "Redefinition is only allowed to simpleType, complexType, group and attributeGroup.");
407 XmlSchema includedSchema = null;
408 if (stream == null) {
409 // It is missing schema components.
410 missedSubComponents = true;
413 schemaLocationStack.Push (url);
414 XmlTextReader xtr = null;
416 xtr = new XmlTextReader (url, stream, nameTable);
417 includedSchema = XmlSchema.Read (xtr, handler);
422 includedSchema.schemas = schemas;
425 // Set - actual - target namespace for the included schema * before compilation*.
426 XmlSchemaImport import = ext as XmlSchemaImport;
427 if (import != null) {
428 if (TargetNamespace == includedSchema.TargetNamespace) {
429 error (handler, "Target namespace must be different from that of included schema.");
431 } else if (includedSchema.TargetNamespace != import.Namespace) {
432 error (handler, "Attribute namespace and its importing schema's target namespace must be the same.");
436 if (TargetNamespace == null &&
437 includedSchema.TargetNamespace != null) {
438 error (handler, "Target namespace is required to include a schema which has its own target namespace");
441 else if (TargetNamespace != null &&
442 includedSchema.TargetNamespace == null)
443 includedSchema.TargetNamespace = TargetNamespace;
446 // Compile included schema.
447 includedSchema.idCollection = this.IDCollection;
448 includedSchema.Compile (handler, schemaLocationStack, rootSchema, col, resolver);
449 schemaLocationStack.Pop ();
452 rootSchema.schemas.Add (includedSchema);
454 // Note that we use compiled items. Items
455 // may not exist in Items, since included
456 // schema also includes another schemas.
457 foreach (DictionaryEntry entry in includedSchema.Attributes)
458 compilationItems.Add ((XmlSchemaObject) entry.Value);
459 foreach (DictionaryEntry entry in includedSchema.Elements)
460 compilationItems.Add ((XmlSchemaObject) entry.Value);
461 foreach (DictionaryEntry entry in includedSchema.SchemaTypes)
462 compilationItems.Add ((XmlSchemaObject) entry.Value);
463 foreach (DictionaryEntry entry in includedSchema.AttributeGroups)
464 compilationItems.Add ((XmlSchemaObject) entry.Value);
465 foreach (DictionaryEntry entry in includedSchema.Groups)
466 compilationItems.Add ((XmlSchemaObject) entry.Value);
467 foreach (DictionaryEntry entry in includedSchema.Notations)
468 compilationItems.Add ((XmlSchemaObject) entry.Value);
471 // Compilation phase.
472 // At least each Compile() must gives unique (qualified) name for each component.
473 // It also checks self-resolvable properties correct.
474 // Post compilation schema information contribution is not required here.
475 // It should be done by Validate().
476 for (int i = 0; i < compilationItems.Count; i++) {
477 XmlSchemaObject obj = compilationItems [i];
478 if(obj is XmlSchemaAnnotation) {
479 int numerr = ((XmlSchemaAnnotation)obj).Compile (handler, this);
480 errorCount += numerr;
481 } else if (obj is XmlSchemaAttribute) {
482 XmlSchemaAttribute attr = (XmlSchemaAttribute) obj;
483 attr.ParentIsSchema = true;
484 int numerr = attr.Compile (handler, this);
485 errorCount += numerr;
488 XmlSchemaUtil.AddToTable (Attributes, attr, attr.QualifiedName, handler);
490 } else if (obj is XmlSchemaAttributeGroup) {
491 XmlSchemaAttributeGroup attrgrp = (XmlSchemaAttributeGroup) obj;
492 int numerr = attrgrp.Compile(handler, this);
493 errorCount += numerr;
495 XmlSchemaUtil.AddToTable (
498 attrgrp.QualifiedName,
500 } else if (obj is XmlSchemaComplexType) {
501 XmlSchemaComplexType ctype = (XmlSchemaComplexType) obj;
502 ctype.ParentIsSchema = true;
503 int numerr = ctype.Compile (handler, this);
504 errorCount += numerr;
506 XmlSchemaUtil.AddToTable (
511 } else if (obj is XmlSchemaSimpleType) {
512 XmlSchemaSimpleType stype = (XmlSchemaSimpleType) obj;
513 stype.islocal = false; //This simple type is toplevel
514 int numerr = stype.Compile (handler, this);
515 errorCount += numerr;
517 XmlSchemaUtil.AddToTable (
522 } else if (obj is XmlSchemaElement) {
523 XmlSchemaElement elem = (XmlSchemaElement) obj;
524 elem.parentIsSchema = true;
525 int numerr = elem.Compile (handler, this);
526 errorCount += numerr;
528 XmlSchemaUtil.AddToTable (
533 } else if (obj is XmlSchemaGroup) {
534 XmlSchemaGroup grp = (XmlSchemaGroup) obj;
535 int numerr = grp.Compile (handler, this);
536 errorCount += numerr;
538 XmlSchemaUtil.AddToTable (
543 } else if (obj is XmlSchemaNotation) {
544 XmlSchemaNotation ntn = (XmlSchemaNotation) obj;
545 int numerr = ntn.Compile (handler, this);
546 errorCount += numerr;
548 XmlSchemaUtil.AddToTable (
554 ValidationHandler.RaiseValidationEvent (
557 String.Format ("Object of Type {0} is not valid in Item Property of Schema", obj.GetType ().Name),
561 XmlSeverityType.Error);
565 if (rootSchema == this)
573 private string GetResolvedUri (XmlResolver resolver, string relativeUri)
576 if (this.SourceUri != null && this.SourceUri != String.Empty)
577 baseUri = new Uri (this.SourceUri);
578 return resolver.ResolveUri (baseUri, relativeUri).ToString ();
581 internal bool IsNamespaceAbsent (string ns)
583 return !schemas.Contains (ns);
588 private void Validate (ValidationEventHandler handler)
590 ValidationId = CompilationId;
592 // Firstly Element needs to be filled their substitution group info
593 foreach (XmlSchemaElement elem in Elements.Values)
594 elem.FillSubstitutionElementInfo ();
597 foreach (XmlSchemaAttribute attr in Attributes.Values)
598 errorCount += attr.Validate (handler, this);
599 foreach (XmlSchemaAttributeGroup attrgrp in AttributeGroups.Values)
600 errorCount += attrgrp.Validate (handler, this);
601 foreach (XmlSchemaType type in SchemaTypes.Values)
602 errorCount += type.Validate (handler, this);
603 foreach (XmlSchemaElement elem in Elements.Values)
604 errorCount += elem.Validate (handler, this);
605 foreach (XmlSchemaGroup grp in Groups.Values)
606 errorCount += grp.Validate (handler, this);
607 foreach (XmlSchemaNotation ntn in Notations.Values)
608 errorCount += ntn.Validate (handler, this);
613 // We cannot use xml deserialization, since it does not provide line info, qname context, and so on.
614 public static XmlSchema Read (TextReader reader, ValidationEventHandler validationEventHandler)
616 return Read (new XmlTextReader (reader),validationEventHandler);
618 public static XmlSchema Read (Stream stream, ValidationEventHandler validationEventHandler)
620 return Read (new XmlTextReader (stream),validationEventHandler);
623 public static XmlSchema Read (XmlReader rdr, ValidationEventHandler validationEventHandler)
625 XmlSchemaReader reader = new XmlSchemaReader (rdr, validationEventHandler);
627 if (reader.ReadState == ReadState.Initial)
628 reader.ReadNextElement ();
630 int startDepth = reader.Depth;
634 switch(reader.NodeType)
636 case XmlNodeType.Element:
637 if(reader.LocalName == "schema")
639 XmlSchema schema = new XmlSchema ();
640 schema.nameTable = rdr.NameTable;
642 schema.LineNumber = reader.LineNumber;
643 schema.LinePosition = reader.LinePosition;
644 schema.SourceUri = reader.BaseURI;
646 ReadAttributes(schema, reader, validationEventHandler);
647 //IsEmptyElement does not behave properly if reader is
648 //positioned at an attribute.
649 reader.MoveToElement();
650 if(!reader.IsEmptyElement)
652 ReadContent(schema, reader, validationEventHandler);
657 if (rdr.NodeType == XmlNodeType.EndElement)
662 //Schema can't be generated. Throw an exception
663 error (validationEventHandler, "The root element must be schema", null);
666 error(validationEventHandler, "This should never happen. XmlSchema.Read 1 ",null);
669 } while(reader.Depth > startDepth && reader.ReadNextElement());
671 // This is thrown regardless of ValidationEventHandler existence.
672 throw new XmlSchemaException ("The top level schema must have namespace " + XmlSchema.Namespace, null);
675 private static void ReadAttributes(XmlSchema schema, XmlSchemaReader reader, ValidationEventHandler h)
679 reader.MoveToElement();
680 while(reader.MoveToNextAttribute())
684 case "attributeFormDefault" :
685 schema.attributeFormDefault = XmlSchemaUtil.ReadFormAttribute(reader,out ex);
687 error(h, reader.Value + " is not a valid value for attributeFormDefault.", ex);
689 case "blockDefault" :
690 schema.blockDefault = XmlSchemaUtil.ReadDerivationAttribute(reader,out ex, "blockDefault",
691 XmlSchemaUtil.ElementBlockAllowed);
693 error (h, ex.Message, ex);
695 case "elementFormDefault":
696 schema.elementFormDefault = XmlSchemaUtil.ReadFormAttribute(reader, out ex);
698 error(h, reader.Value + " is not a valid value for elementFormDefault.", ex);
701 schema.finalDefault = XmlSchemaUtil.ReadDerivationAttribute(reader, out ex, "finalDefault",
702 XmlSchemaUtil.FinalAllowed);
704 error (h, ex.Message , ex);
707 schema.id = reader.Value;
709 case "targetNamespace":
710 schema.targetNamespace = reader.Value;
713 schema.version = reader.Value;
716 schema.language = 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 ();