Code:
/ Dotnetfx_Win7_3.5.1 / Dotnetfx_Win7_3.5.1 / 3.5.1 / DEVDIV / depot / DevDiv / releases / whidbey / NetFXspW7 / ndp / fx / src / Xml / System / Xml / schema / XmlSchema.cs / 1 / XmlSchema.cs
//------------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
// [....]
//-----------------------------------------------------------------------------
namespace System.Xml.Schema {
using System.IO;
using System.Collections;
using System.ComponentModel;
using System.Xml.Serialization;
using System.Threading;
using System.Diagnostics;
///
/// [To be supplied.]
///
[XmlRoot("schema", Namespace=XmlSchema.Namespace)]
public class XmlSchema : XmlSchemaObject {
///
/// [To be supplied.]
///
public const string Namespace = XmlReservedNs.NsXs;
///
/// [To be supplied.]
///
public const string InstanceNamespace = XmlReservedNs.NsXsi;
XmlSchemaForm attributeFormDefault = XmlSchemaForm.None;
XmlSchemaForm elementFormDefault = XmlSchemaForm.None;
XmlSchemaDerivationMethod blockDefault = XmlSchemaDerivationMethod.None;
XmlSchemaDerivationMethod finalDefault = XmlSchemaDerivationMethod.None;
string targetNs;
string version;
XmlSchemaObjectCollection includes = new XmlSchemaObjectCollection();
XmlSchemaObjectCollection items = new XmlSchemaObjectCollection();
string id;
XmlAttribute[] moreAttributes;
// compiled info
bool isCompiled = false;
bool isCompiledBySet = false;
bool isPreprocessed = false;
bool isRedefined = false;
int errorCount = 0;
XmlSchemaObjectTable attributes;
XmlSchemaObjectTable attributeGroups = new XmlSchemaObjectTable();
XmlSchemaObjectTable elements = new XmlSchemaObjectTable();
XmlSchemaObjectTable types = new XmlSchemaObjectTable();
XmlSchemaObjectTable groups = new XmlSchemaObjectTable();
XmlSchemaObjectTable notations = new XmlSchemaObjectTable();
XmlSchemaObjectTable identityConstraints = new XmlSchemaObjectTable();
static int globalIdCounter = -1;
ArrayList importedSchemas;
ArrayList importedNamespaces;
int schemaId = -1; //Not added to a set
Uri baseUri;
bool isChameleon;
Hashtable ids = new Hashtable();
XmlDocument document;
XmlNameTable nameTable;
///
/// [To be supplied.]
///
public XmlSchema() {}
///
/// [To be supplied.]
///
public static XmlSchema Read(TextReader reader, ValidationEventHandler validationEventHandler) {
return Read(new XmlTextReader(reader), validationEventHandler);
}
///
/// [To be supplied.]
///
public static XmlSchema Read(Stream stream, ValidationEventHandler validationEventHandler) {
return Read(new XmlTextReader(stream), validationEventHandler);
}
///
/// [To be supplied.]
///
public static XmlSchema Read(XmlReader reader, ValidationEventHandler validationEventHandler) {
XmlNameTable nameTable = reader.NameTable;
Parser parser = new Parser(SchemaType.XSD, nameTable, new SchemaNames(nameTable), validationEventHandler);
try {
parser.Parse(reader, null);
}
catch(XmlSchemaException e) {
if (validationEventHandler != null) {
validationEventHandler(null, new ValidationEventArgs(e));
}
else {
throw e;
}
return null;
}
return parser.XmlSchema;
}
///
/// [To be supplied.]
///
public void Write(Stream stream) {
Write(stream, null);
}
///
/// [To be supplied.]
///
public void Write(Stream stream, XmlNamespaceManager namespaceManager) {
XmlTextWriter xmlWriter = new XmlTextWriter(stream, null);
xmlWriter.Formatting = Formatting.Indented;
Write(xmlWriter, namespaceManager);
}
///
/// [To be supplied.]
///
public void Write(TextWriter writer) {
Write(writer, null);
}
///
/// [To be supplied.]
///
public void Write(TextWriter writer, XmlNamespaceManager namespaceManager) {
XmlTextWriter xmlWriter = new XmlTextWriter(writer);
xmlWriter.Formatting = Formatting.Indented;
Write(xmlWriter, namespaceManager);
}
///
/// [To be supplied.]
///
public void Write(XmlWriter writer) {
Write(writer, null);
}
///
/// [To be supplied.]
///
public void Write(XmlWriter writer, XmlNamespaceManager namespaceManager) {
XmlSerializer serializer = new XmlSerializer(typeof(XmlSchema));
XmlSerializerNamespaces ns;
if (namespaceManager != null) {
ns = new XmlSerializerNamespaces();
bool ignoreXS = false;
if (this.Namespaces != null) { //User may have set both nsManager and Namespaces property on the XmlSchema object
ignoreXS = this.Namespaces.Namespaces["xs"] != null || this.Namespaces.Namespaces.ContainsValue(XmlReservedNs.NsXs);
}
if (!ignoreXS && namespaceManager.LookupPrefix(XmlReservedNs.NsXs) == null &&
namespaceManager.LookupNamespace("xs") == null ) {
ns.Add("xs", XmlReservedNs.NsXs);
}
foreach(string prefix in namespaceManager) {
if (prefix != "xml" && prefix != "xmlns") {
ns.Add(prefix, namespaceManager.LookupNamespace(prefix));
}
}
} else if (this.Namespaces != null && this.Namespaces.Count > 0) {
Hashtable serializerNS = this.Namespaces.Namespaces;
if (serializerNS["xs"] == null && !serializerNS.ContainsValue(XmlReservedNs.NsXs)) { //Prefix xs not defined AND schema namespace not already mapped to a prefix
serializerNS.Add("xs", XmlReservedNs.NsXs);
}
ns = this.Namespaces;
}
else {
ns = new XmlSerializerNamespaces();
ns.Add("xs", XmlSchema.Namespace);
if (targetNs != null && targetNs.Length != 0) {
ns.Add("tns", targetNs);
}
}
serializer.Serialize(writer, this, ns);
}
///
/// [To be supplied.]
///
[Obsolete("Use System.Xml.Schema.XmlSchemaSet for schema compilation and validation. http://go.microsoft.com/fwlink/?linkid=14202")]
public void Compile(ValidationEventHandler validationEventHandler) {
SchemaInfo sInfo = new SchemaInfo();
sInfo.SchemaType = SchemaType.XSD;
CompileSchema(null, new XmlUrlResolver(), sInfo, null, validationEventHandler, NameTable, false);
}
///
/// [To be supplied.]
///
[Obsolete("Use System.Xml.Schema.XmlSchemaSet for schema compilation and validation. http://go.microsoft.com/fwlink/?linkid=14202")]
public void Compile(ValidationEventHandler validationEventHandler, XmlResolver resolver) {
SchemaInfo sInfo = new SchemaInfo();
sInfo.SchemaType = SchemaType.XSD;
CompileSchema(null, resolver, sInfo, null, validationEventHandler, NameTable, false);
}
#pragma warning disable 618
internal bool CompileSchema(XmlSchemaCollection xsc, XmlResolver resolver, SchemaInfo schemaInfo, string ns, ValidationEventHandler validationEventHandler, XmlNameTable nameTable, bool CompileContentModel) {
//Need to lock here to prevent multi-threading problems when same schema is added to set and compiled
lock (this) {
//Preprocessing
SchemaCollectionPreprocessor prep = new SchemaCollectionPreprocessor(nameTable, null, validationEventHandler);
prep.XmlResolver = resolver;
if (!prep.Execute(this, ns, true, xsc)) {
return false;
}
//Compilation
SchemaCollectionCompiler compiler = new SchemaCollectionCompiler(nameTable, validationEventHandler);
isCompiled = compiler.Execute(this, schemaInfo, CompileContentModel);
this.SetIsCompiled(isCompiled);
//
return isCompiled;
}
}
#pragma warning restore 618
internal void CompileSchemaInSet(XmlNameTable nameTable, ValidationEventHandler eventHandler, XmlSchemaCompilationSettings compilationSettings) {
Debug.Assert(this.isPreprocessed);
Compiler setCompiler = new Compiler(nameTable, eventHandler, null, compilationSettings);
setCompiler.Prepare(this, true);
this.isCompiledBySet = setCompiler.Compile();
}
///
/// [To be supplied.]
///
[XmlAttribute("attributeFormDefault"), DefaultValue(XmlSchemaForm.None)]
public XmlSchemaForm AttributeFormDefault {
get { return attributeFormDefault; }
set { attributeFormDefault = value; }
}
///
/// [To be supplied.]
///
[XmlAttribute("blockDefault"), DefaultValue(XmlSchemaDerivationMethod.None)]
public XmlSchemaDerivationMethod BlockDefault {
get { return blockDefault; }
set { blockDefault = value; }
}
///
/// [To be supplied.]
///
[XmlAttribute("finalDefault"), DefaultValue(XmlSchemaDerivationMethod.None)]
public XmlSchemaDerivationMethod FinalDefault {
get { return finalDefault; }
set { finalDefault = value; }
}
///
/// [To be supplied.]
///
[XmlAttribute("elementFormDefault"), DefaultValue(XmlSchemaForm.None)]
public XmlSchemaForm ElementFormDefault {
get { return elementFormDefault; }
set { elementFormDefault = value; }
}
///
/// [To be supplied.]
///
[XmlAttribute("targetNamespace", DataType="anyURI")]
public string TargetNamespace {
get { return targetNs; }
set { targetNs = value; }
}
///
/// [To be supplied.]
///
[XmlAttribute("version", DataType="token")]
public string Version {
get { return version; }
set { version = value; }
}
///
/// [To be supplied.]
///
[XmlElement("include", typeof(XmlSchemaInclude)),
XmlElement("import", typeof(XmlSchemaImport)),
XmlElement("redefine", typeof(XmlSchemaRedefine))]
public XmlSchemaObjectCollection Includes {
get { return includes; }
}
///
/// [To be supplied.]
///
[XmlElement("annotation", typeof(XmlSchemaAnnotation)),
XmlElement("attribute", typeof(XmlSchemaAttribute)),
XmlElement("attributeGroup", typeof(XmlSchemaAttributeGroup)),
XmlElement("complexType", typeof(XmlSchemaComplexType)),
XmlElement("simpleType", typeof(XmlSchemaSimpleType)),
XmlElement("element", typeof(XmlSchemaElement)),
XmlElement("group", typeof(XmlSchemaGroup)),
XmlElement("notation", typeof(XmlSchemaNotation))]
public XmlSchemaObjectCollection Items {
get { return items; }
}
// Compiled info
///
/// [To be supplied.]
///
[XmlIgnore]
public bool IsCompiled {
get {
return isCompiled || isCompiledBySet ;
}
}
[XmlIgnore]
internal bool IsCompiledBySet {
get { return isCompiledBySet; }
set { isCompiledBySet = value; }
}
[XmlIgnore]
internal bool IsPreprocessed {
get { return isPreprocessed; }
set { isPreprocessed = value; }
}
[XmlIgnore]
internal bool IsRedefined {
get { return isRedefined; }
set { isRedefined = value; }
}
///
/// [To be supplied.]
///
[XmlIgnore]
public XmlSchemaObjectTable Attributes {
get {
if (attributes == null) {
attributes = new XmlSchemaObjectTable();
}
return attributes;
}
}
///
/// [To be supplied.]
///
[XmlIgnore]
public XmlSchemaObjectTable AttributeGroups {
get {
if (attributeGroups == null) {
attributeGroups = new XmlSchemaObjectTable();
}
return attributeGroups;
}
}
///
/// [To be supplied.]
///
[XmlIgnore]
public XmlSchemaObjectTable SchemaTypes {
get {
if (types == null) {
types = new XmlSchemaObjectTable();
}
return types;
}
}
///
/// [To be supplied.]
///
[XmlIgnore]
public XmlSchemaObjectTable Elements {
get {
if (elements == null) {
elements = new XmlSchemaObjectTable();
}
return elements;
}
}
///
/// [To be supplied.]
///
[XmlAttribute("id", DataType="ID")]
public string Id {
get { return id; }
set { id = value; }
}
///
/// [To be supplied.]
///
[XmlAnyAttribute]
public XmlAttribute[] UnhandledAttributes {
get { return moreAttributes; }
set { moreAttributes = value; }
}
///
/// [To be supplied.]
///
[XmlIgnore]
public XmlSchemaObjectTable Groups {
get { return groups; }
}
///
/// [To be supplied.]
///
[XmlIgnore]
public XmlSchemaObjectTable Notations {
get { return notations; }
}
[XmlIgnore]
internal XmlSchemaObjectTable IdentityConstraints {
get { return identityConstraints; }
}
[XmlIgnore]
internal Uri BaseUri {
get { return baseUri; }
set {
baseUri = value;
}
}
[XmlIgnore]
internal int SchemaId {
get {
if (schemaId == -1) {
schemaId = Interlocked.Increment(ref globalIdCounter);
}
return schemaId;
}
}
[XmlIgnore]
internal bool IsChameleon {
get { return isChameleon; }
set { isChameleon = value; }
}
[XmlIgnore]
internal Hashtable Ids {
get { return ids; }
}
[XmlIgnore]
internal XmlDocument Document {
get { if (document == null) document = new XmlDocument(); return document; }
}
[XmlIgnore]
internal int ErrorCount {
get { return errorCount; }
set { errorCount = value; }
}
internal new XmlSchema Clone() {
XmlSchema that = new XmlSchema();
that.attributeFormDefault = this.attributeFormDefault;
that.elementFormDefault = this.elementFormDefault;
that.blockDefault = this.blockDefault;
that.finalDefault = this.finalDefault;
that.targetNs = this.targetNs;
that.version = this.version;
that.includes = this.includes;
that.Namespaces = this.Namespaces;
that.items = this.items;
that.BaseUri = this.BaseUri;
SchemaCollectionCompiler.Cleanup(that);
return that;
}
internal XmlSchema DeepClone() {
XmlSchema that = new XmlSchema();
that.attributeFormDefault = this.attributeFormDefault;
that.elementFormDefault = this.elementFormDefault;
that.blockDefault = this.blockDefault;
that.finalDefault = this.finalDefault;
that.targetNs = this.targetNs;
that.version = this.version;
that.isPreprocessed = this.isPreprocessed;
//that.IsProcessing = this.IsProcessing; //Not sure if this is needed
//Clone its Items
foreach (XmlSchemaObject item in this.items) {
XmlSchemaObject newItem = item.Clone();
that.Items.Add(newItem);
}
//Clone Includes
foreach (XmlSchemaExternal include in this.includes) {
XmlSchemaExternal newInclude = (XmlSchemaExternal)include.Clone();
that.Includes.Add(newInclude);
}
that.Namespaces = this.Namespaces;
//that.includes = this.includes; //Need to verify this is OK for redefines
that.BaseUri = this.BaseUri;
return that;
}
[XmlIgnore]
internal override string IdAttribute {
get { return Id; }
set { Id = value; }
}
internal void SetIsCompiled(bool isCompiled) {
this.isCompiled = isCompiled;
}
internal override void SetUnhandledAttributes(XmlAttribute[] moreAttributes) {
this.moreAttributes = moreAttributes;
}
internal override void AddAnnotation(XmlSchemaAnnotation annotation) {
items.Add(annotation);
}
internal XmlNameTable NameTable {
get { if (nameTable == null) nameTable = new System.Xml.NameTable(); return nameTable; }
}
internal ArrayList ImportedSchemas {
get {
if (importedSchemas == null) {
importedSchemas = new ArrayList();
}
return importedSchemas;
}
}
internal ArrayList ImportedNamespaces {
get {
if (importedNamespaces == null) {
importedNamespaces = new ArrayList();
}
return importedNamespaces;
}
}
internal void GetExternalSchemasList(IList extList, XmlSchema schema) {
Debug.Assert(extList != null && schema != null);
if (extList.Contains(schema)) {
return;
}
extList.Add(schema);
foreach (XmlSchemaExternal ext in schema.Includes) {
if (ext.Schema != null) {
GetExternalSchemasList(extList, ext.Schema);
}
}
}
internal void AddCompiledInfo(SchemaInfo schemaInfo) {
XmlQualifiedName itemName;
foreach (XmlSchemaElement element in elements.Values) {
itemName = element.QualifiedName;
schemaInfo.TargetNamespaces[itemName.Namespace] = true;
if (schemaInfo.ElementDecls[itemName] == null) {
schemaInfo.ElementDecls.Add(itemName, element.ElementDecl);
}
}
foreach (XmlSchemaAttribute attribute in attributes.Values) {
itemName = attribute.QualifiedName;
schemaInfo.TargetNamespaces[itemName.Namespace] = true;
if (schemaInfo.ElementDecls[itemName] == null) {
schemaInfo.AttributeDecls.Add(itemName, attribute.AttDef);
}
}
foreach (XmlSchemaType type in types.Values) {
itemName = type.QualifiedName;
schemaInfo.TargetNamespaces[itemName.Namespace] = true;
XmlSchemaComplexType complexType = type as XmlSchemaComplexType;
if ((complexType == null || type != XmlSchemaComplexType.AnyType) && schemaInfo.ElementDeclsByType[itemName] == null) {
schemaInfo.ElementDeclsByType.Add(itemName, type.ElementDecl);
}
}
foreach (XmlSchemaNotation notation in notations.Values) {
itemName = notation.QualifiedName;
schemaInfo.TargetNamespaces[itemName.Namespace] = true;
SchemaNotation no = new SchemaNotation(itemName);
no.SystemLiteral = notation.System;
no.Pubid = notation.Public;
if (schemaInfo.Notations[itemName.Name] == null) {
schemaInfo.Notations.Add(itemName.Name, no);
}
}
}
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
//------------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
// [....]
//-----------------------------------------------------------------------------
namespace System.Xml.Schema {
using System.IO;
using System.Collections;
using System.ComponentModel;
using System.Xml.Serialization;
using System.Threading;
using System.Diagnostics;
///
/// [To be supplied.]
///
[XmlRoot("schema", Namespace=XmlSchema.Namespace)]
public class XmlSchema : XmlSchemaObject {
///
/// [To be supplied.]
///
public const string Namespace = XmlReservedNs.NsXs;
///
/// [To be supplied.]
///
public const string InstanceNamespace = XmlReservedNs.NsXsi;
XmlSchemaForm attributeFormDefault = XmlSchemaForm.None;
XmlSchemaForm elementFormDefault = XmlSchemaForm.None;
XmlSchemaDerivationMethod blockDefault = XmlSchemaDerivationMethod.None;
XmlSchemaDerivationMethod finalDefault = XmlSchemaDerivationMethod.None;
string targetNs;
string version;
XmlSchemaObjectCollection includes = new XmlSchemaObjectCollection();
XmlSchemaObjectCollection items = new XmlSchemaObjectCollection();
string id;
XmlAttribute[] moreAttributes;
// compiled info
bool isCompiled = false;
bool isCompiledBySet = false;
bool isPreprocessed = false;
bool isRedefined = false;
int errorCount = 0;
XmlSchemaObjectTable attributes;
XmlSchemaObjectTable attributeGroups = new XmlSchemaObjectTable();
XmlSchemaObjectTable elements = new XmlSchemaObjectTable();
XmlSchemaObjectTable types = new XmlSchemaObjectTable();
XmlSchemaObjectTable groups = new XmlSchemaObjectTable();
XmlSchemaObjectTable notations = new XmlSchemaObjectTable();
XmlSchemaObjectTable identityConstraints = new XmlSchemaObjectTable();
static int globalIdCounter = -1;
ArrayList importedSchemas;
ArrayList importedNamespaces;
int schemaId = -1; //Not added to a set
Uri baseUri;
bool isChameleon;
Hashtable ids = new Hashtable();
XmlDocument document;
XmlNameTable nameTable;
///
/// [To be supplied.]
///
public XmlSchema() {}
///
/// [To be supplied.]
///
public static XmlSchema Read(TextReader reader, ValidationEventHandler validationEventHandler) {
return Read(new XmlTextReader(reader), validationEventHandler);
}
///
/// [To be supplied.]
///
public static XmlSchema Read(Stream stream, ValidationEventHandler validationEventHandler) {
return Read(new XmlTextReader(stream), validationEventHandler);
}
///
/// [To be supplied.]
///
public static XmlSchema Read(XmlReader reader, ValidationEventHandler validationEventHandler) {
XmlNameTable nameTable = reader.NameTable;
Parser parser = new Parser(SchemaType.XSD, nameTable, new SchemaNames(nameTable), validationEventHandler);
try {
parser.Parse(reader, null);
}
catch(XmlSchemaException e) {
if (validationEventHandler != null) {
validationEventHandler(null, new ValidationEventArgs(e));
}
else {
throw e;
}
return null;
}
return parser.XmlSchema;
}
///
/// [To be supplied.]
///
public void Write(Stream stream) {
Write(stream, null);
}
///
/// [To be supplied.]
///
public void Write(Stream stream, XmlNamespaceManager namespaceManager) {
XmlTextWriter xmlWriter = new XmlTextWriter(stream, null);
xmlWriter.Formatting = Formatting.Indented;
Write(xmlWriter, namespaceManager);
}
///
/// [To be supplied.]
///
public void Write(TextWriter writer) {
Write(writer, null);
}
///
/// [To be supplied.]
///
public void Write(TextWriter writer, XmlNamespaceManager namespaceManager) {
XmlTextWriter xmlWriter = new XmlTextWriter(writer);
xmlWriter.Formatting = Formatting.Indented;
Write(xmlWriter, namespaceManager);
}
///
/// [To be supplied.]
///
public void Write(XmlWriter writer) {
Write(writer, null);
}
///
/// [To be supplied.]
///
public void Write(XmlWriter writer, XmlNamespaceManager namespaceManager) {
XmlSerializer serializer = new XmlSerializer(typeof(XmlSchema));
XmlSerializerNamespaces ns;
if (namespaceManager != null) {
ns = new XmlSerializerNamespaces();
bool ignoreXS = false;
if (this.Namespaces != null) { //User may have set both nsManager and Namespaces property on the XmlSchema object
ignoreXS = this.Namespaces.Namespaces["xs"] != null || this.Namespaces.Namespaces.ContainsValue(XmlReservedNs.NsXs);
}
if (!ignoreXS && namespaceManager.LookupPrefix(XmlReservedNs.NsXs) == null &&
namespaceManager.LookupNamespace("xs") == null ) {
ns.Add("xs", XmlReservedNs.NsXs);
}
foreach(string prefix in namespaceManager) {
if (prefix != "xml" && prefix != "xmlns") {
ns.Add(prefix, namespaceManager.LookupNamespace(prefix));
}
}
} else if (this.Namespaces != null && this.Namespaces.Count > 0) {
Hashtable serializerNS = this.Namespaces.Namespaces;
if (serializerNS["xs"] == null && !serializerNS.ContainsValue(XmlReservedNs.NsXs)) { //Prefix xs not defined AND schema namespace not already mapped to a prefix
serializerNS.Add("xs", XmlReservedNs.NsXs);
}
ns = this.Namespaces;
}
else {
ns = new XmlSerializerNamespaces();
ns.Add("xs", XmlSchema.Namespace);
if (targetNs != null && targetNs.Length != 0) {
ns.Add("tns", targetNs);
}
}
serializer.Serialize(writer, this, ns);
}
///
/// [To be supplied.]
///
[Obsolete("Use System.Xml.Schema.XmlSchemaSet for schema compilation and validation. http://go.microsoft.com/fwlink/?linkid=14202")]
public void Compile(ValidationEventHandler validationEventHandler) {
SchemaInfo sInfo = new SchemaInfo();
sInfo.SchemaType = SchemaType.XSD;
CompileSchema(null, new XmlUrlResolver(), sInfo, null, validationEventHandler, NameTable, false);
}
///
/// [To be supplied.]
///
[Obsolete("Use System.Xml.Schema.XmlSchemaSet for schema compilation and validation. http://go.microsoft.com/fwlink/?linkid=14202")]
public void Compile(ValidationEventHandler validationEventHandler, XmlResolver resolver) {
SchemaInfo sInfo = new SchemaInfo();
sInfo.SchemaType = SchemaType.XSD;
CompileSchema(null, resolver, sInfo, null, validationEventHandler, NameTable, false);
}
#pragma warning disable 618
internal bool CompileSchema(XmlSchemaCollection xsc, XmlResolver resolver, SchemaInfo schemaInfo, string ns, ValidationEventHandler validationEventHandler, XmlNameTable nameTable, bool CompileContentModel) {
//Need to lock here to prevent multi-threading problems when same schema is added to set and compiled
lock (this) {
//Preprocessing
SchemaCollectionPreprocessor prep = new SchemaCollectionPreprocessor(nameTable, null, validationEventHandler);
prep.XmlResolver = resolver;
if (!prep.Execute(this, ns, true, xsc)) {
return false;
}
//Compilation
SchemaCollectionCompiler compiler = new SchemaCollectionCompiler(nameTable, validationEventHandler);
isCompiled = compiler.Execute(this, schemaInfo, CompileContentModel);
this.SetIsCompiled(isCompiled);
//
return isCompiled;
}
}
#pragma warning restore 618
internal void CompileSchemaInSet(XmlNameTable nameTable, ValidationEventHandler eventHandler, XmlSchemaCompilationSettings compilationSettings) {
Debug.Assert(this.isPreprocessed);
Compiler setCompiler = new Compiler(nameTable, eventHandler, null, compilationSettings);
setCompiler.Prepare(this, true);
this.isCompiledBySet = setCompiler.Compile();
}
///
/// [To be supplied.]
///
[XmlAttribute("attributeFormDefault"), DefaultValue(XmlSchemaForm.None)]
public XmlSchemaForm AttributeFormDefault {
get { return attributeFormDefault; }
set { attributeFormDefault = value; }
}
///
/// [To be supplied.]
///
[XmlAttribute("blockDefault"), DefaultValue(XmlSchemaDerivationMethod.None)]
public XmlSchemaDerivationMethod BlockDefault {
get { return blockDefault; }
set { blockDefault = value; }
}
///
/// [To be supplied.]
///
[XmlAttribute("finalDefault"), DefaultValue(XmlSchemaDerivationMethod.None)]
public XmlSchemaDerivationMethod FinalDefault {
get { return finalDefault; }
set { finalDefault = value; }
}
///
/// [To be supplied.]
///
[XmlAttribute("elementFormDefault"), DefaultValue(XmlSchemaForm.None)]
public XmlSchemaForm ElementFormDefault {
get { return elementFormDefault; }
set { elementFormDefault = value; }
}
///
/// [To be supplied.]
///
[XmlAttribute("targetNamespace", DataType="anyURI")]
public string TargetNamespace {
get { return targetNs; }
set { targetNs = value; }
}
///
/// [To be supplied.]
///
[XmlAttribute("version", DataType="token")]
public string Version {
get { return version; }
set { version = value; }
}
///
/// [To be supplied.]
///
[XmlElement("include", typeof(XmlSchemaInclude)),
XmlElement("import", typeof(XmlSchemaImport)),
XmlElement("redefine", typeof(XmlSchemaRedefine))]
public XmlSchemaObjectCollection Includes {
get { return includes; }
}
///
/// [To be supplied.]
///
[XmlElement("annotation", typeof(XmlSchemaAnnotation)),
XmlElement("attribute", typeof(XmlSchemaAttribute)),
XmlElement("attributeGroup", typeof(XmlSchemaAttributeGroup)),
XmlElement("complexType", typeof(XmlSchemaComplexType)),
XmlElement("simpleType", typeof(XmlSchemaSimpleType)),
XmlElement("element", typeof(XmlSchemaElement)),
XmlElement("group", typeof(XmlSchemaGroup)),
XmlElement("notation", typeof(XmlSchemaNotation))]
public XmlSchemaObjectCollection Items {
get { return items; }
}
// Compiled info
///
/// [To be supplied.]
///
[XmlIgnore]
public bool IsCompiled {
get {
return isCompiled || isCompiledBySet ;
}
}
[XmlIgnore]
internal bool IsCompiledBySet {
get { return isCompiledBySet; }
set { isCompiledBySet = value; }
}
[XmlIgnore]
internal bool IsPreprocessed {
get { return isPreprocessed; }
set { isPreprocessed = value; }
}
[XmlIgnore]
internal bool IsRedefined {
get { return isRedefined; }
set { isRedefined = value; }
}
///
/// [To be supplied.]
///
[XmlIgnore]
public XmlSchemaObjectTable Attributes {
get {
if (attributes == null) {
attributes = new XmlSchemaObjectTable();
}
return attributes;
}
}
///
/// [To be supplied.]
///
[XmlIgnore]
public XmlSchemaObjectTable AttributeGroups {
get {
if (attributeGroups == null) {
attributeGroups = new XmlSchemaObjectTable();
}
return attributeGroups;
}
}
///
/// [To be supplied.]
///
[XmlIgnore]
public XmlSchemaObjectTable SchemaTypes {
get {
if (types == null) {
types = new XmlSchemaObjectTable();
}
return types;
}
}
///
/// [To be supplied.]
///
[XmlIgnore]
public XmlSchemaObjectTable Elements {
get {
if (elements == null) {
elements = new XmlSchemaObjectTable();
}
return elements;
}
}
///
/// [To be supplied.]
///
[XmlAttribute("id", DataType="ID")]
public string Id {
get { return id; }
set { id = value; }
}
///
/// [To be supplied.]
///
[XmlAnyAttribute]
public XmlAttribute[] UnhandledAttributes {
get { return moreAttributes; }
set { moreAttributes = value; }
}
///
/// [To be supplied.]
///
[XmlIgnore]
public XmlSchemaObjectTable Groups {
get { return groups; }
}
///
/// [To be supplied.]
///
[XmlIgnore]
public XmlSchemaObjectTable Notations {
get { return notations; }
}
[XmlIgnore]
internal XmlSchemaObjectTable IdentityConstraints {
get { return identityConstraints; }
}
[XmlIgnore]
internal Uri BaseUri {
get { return baseUri; }
set {
baseUri = value;
}
}
[XmlIgnore]
internal int SchemaId {
get {
if (schemaId == -1) {
schemaId = Interlocked.Increment(ref globalIdCounter);
}
return schemaId;
}
}
[XmlIgnore]
internal bool IsChameleon {
get { return isChameleon; }
set { isChameleon = value; }
}
[XmlIgnore]
internal Hashtable Ids {
get { return ids; }
}
[XmlIgnore]
internal XmlDocument Document {
get { if (document == null) document = new XmlDocument(); return document; }
}
[XmlIgnore]
internal int ErrorCount {
get { return errorCount; }
set { errorCount = value; }
}
internal new XmlSchema Clone() {
XmlSchema that = new XmlSchema();
that.attributeFormDefault = this.attributeFormDefault;
that.elementFormDefault = this.elementFormDefault;
that.blockDefault = this.blockDefault;
that.finalDefault = this.finalDefault;
that.targetNs = this.targetNs;
that.version = this.version;
that.includes = this.includes;
that.Namespaces = this.Namespaces;
that.items = this.items;
that.BaseUri = this.BaseUri;
SchemaCollectionCompiler.Cleanup(that);
return that;
}
internal XmlSchema DeepClone() {
XmlSchema that = new XmlSchema();
that.attributeFormDefault = this.attributeFormDefault;
that.elementFormDefault = this.elementFormDefault;
that.blockDefault = this.blockDefault;
that.finalDefault = this.finalDefault;
that.targetNs = this.targetNs;
that.version = this.version;
that.isPreprocessed = this.isPreprocessed;
//that.IsProcessing = this.IsProcessing; //Not sure if this is needed
//Clone its Items
foreach (XmlSchemaObject item in this.items) {
XmlSchemaObject newItem = item.Clone();
that.Items.Add(newItem);
}
//Clone Includes
foreach (XmlSchemaExternal include in this.includes) {
XmlSchemaExternal newInclude = (XmlSchemaExternal)include.Clone();
that.Includes.Add(newInclude);
}
that.Namespaces = this.Namespaces;
//that.includes = this.includes; //Need to verify this is OK for redefines
that.BaseUri = this.BaseUri;
return that;
}
[XmlIgnore]
internal override string IdAttribute {
get { return Id; }
set { Id = value; }
}
internal void SetIsCompiled(bool isCompiled) {
this.isCompiled = isCompiled;
}
internal override void SetUnhandledAttributes(XmlAttribute[] moreAttributes) {
this.moreAttributes = moreAttributes;
}
internal override void AddAnnotation(XmlSchemaAnnotation annotation) {
items.Add(annotation);
}
internal XmlNameTable NameTable {
get { if (nameTable == null) nameTable = new System.Xml.NameTable(); return nameTable; }
}
internal ArrayList ImportedSchemas {
get {
if (importedSchemas == null) {
importedSchemas = new ArrayList();
}
return importedSchemas;
}
}
internal ArrayList ImportedNamespaces {
get {
if (importedNamespaces == null) {
importedNamespaces = new ArrayList();
}
return importedNamespaces;
}
}
internal void GetExternalSchemasList(IList extList, XmlSchema schema) {
Debug.Assert(extList != null && schema != null);
if (extList.Contains(schema)) {
return;
}
extList.Add(schema);
foreach (XmlSchemaExternal ext in schema.Includes) {
if (ext.Schema != null) {
GetExternalSchemasList(extList, ext.Schema);
}
}
}
internal void AddCompiledInfo(SchemaInfo schemaInfo) {
XmlQualifiedName itemName;
foreach (XmlSchemaElement element in elements.Values) {
itemName = element.QualifiedName;
schemaInfo.TargetNamespaces[itemName.Namespace] = true;
if (schemaInfo.ElementDecls[itemName] == null) {
schemaInfo.ElementDecls.Add(itemName, element.ElementDecl);
}
}
foreach (XmlSchemaAttribute attribute in attributes.Values) {
itemName = attribute.QualifiedName;
schemaInfo.TargetNamespaces[itemName.Namespace] = true;
if (schemaInfo.ElementDecls[itemName] == null) {
schemaInfo.AttributeDecls.Add(itemName, attribute.AttDef);
}
}
foreach (XmlSchemaType type in types.Values) {
itemName = type.QualifiedName;
schemaInfo.TargetNamespaces[itemName.Namespace] = true;
XmlSchemaComplexType complexType = type as XmlSchemaComplexType;
if ((complexType == null || type != XmlSchemaComplexType.AnyType) && schemaInfo.ElementDeclsByType[itemName] == null) {
schemaInfo.ElementDeclsByType.Add(itemName, type.ElementDecl);
}
}
foreach (XmlSchemaNotation notation in notations.Values) {
itemName = notation.QualifiedName;
schemaInfo.TargetNamespaces[itemName.Namespace] = true;
SchemaNotation no = new SchemaNotation(itemName);
no.SystemLiteral = notation.System;
no.Pubid = notation.Public;
if (schemaInfo.Notations[itemName.Name] == null) {
schemaInfo.Notations.Add(itemName.Name, no);
}
}
}
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- MultipartContentParser.cs
- TextDecorationCollection.cs
- TextServicesManager.cs
- SystemInformation.cs
- BindingMemberInfo.cs
- DiscreteKeyFrames.cs
- SystemTcpStatistics.cs
- EntityContainerRelationshipSet.cs
- TextRangeBase.cs
- ReferentialConstraint.cs
- TagMapCollection.cs
- sqlinternaltransaction.cs
- AnimationClock.cs
- FamilyTypeface.cs
- MissingFieldException.cs
- StringFreezingAttribute.cs
- XmlTextWriter.cs
- CommandHelpers.cs
- HijriCalendar.cs
- ObfuscationAttribute.cs
- Number.cs
- OleStrCAMarshaler.cs
- CustomCredentialPolicy.cs
- PasswordBoxAutomationPeer.cs
- CollectionConverter.cs
- ClientRolePrincipal.cs
- ThreadPool.cs
- SettingsPropertyValueCollection.cs
- ZipIOLocalFileHeader.cs
- ListBindingHelper.cs
- Substitution.cs
- AddInAdapter.cs
- HostVisual.cs
- TextServicesPropertyRanges.cs
- ObjectDataSourceMethodEventArgs.cs
- ActivityTypeDesigner.xaml.cs
- Effect.cs
- RelationHandler.cs
- PolicyLevel.cs
- AutomationTextAttribute.cs
- TableCellCollection.cs
- DateTimePicker.cs
- EncoderExceptionFallback.cs
- DataColumnCollection.cs
- MimeFormatExtensions.cs
- XmlValueConverter.cs
- DependencySource.cs
- SocketAddress.cs
- SoundPlayer.cs
- ListBoxDesigner.cs
- XmlNodeComparer.cs
- DesignColumnCollection.cs
- DataGridViewRowHeightInfoPushedEventArgs.cs
- ContentPresenter.cs
- RowBinding.cs
- Vector3D.cs
- CultureInfo.cs
- XmlObjectSerializerWriteContextComplex.cs
- TransformProviderWrapper.cs
- DeleteMemberBinder.cs
- ScrollBarRenderer.cs
- RightNameExpirationInfoPair.cs
- ThicknessConverter.cs
- ListContractAdapter.cs
- XmlSchemaComplexContent.cs
- AVElementHelper.cs
- KeyValuePairs.cs
- _LocalDataStore.cs
- QilPatternFactory.cs
- X509PeerCertificateElement.cs
- ChtmlImageAdapter.cs
- PasswordBox.cs
- ValidationEventArgs.cs
- input.cs
- QueryCoreOp.cs
- TimeStampChecker.cs
- RowTypePropertyElement.cs
- PublisherMembershipCondition.cs
- DataGridAutoGeneratingColumnEventArgs.cs
- XhtmlConformanceSection.cs
- RectAnimationBase.cs
- XmlSchemaExporter.cs
- PageAsyncTask.cs
- SqlTypeConverter.cs
- ScriptIgnoreAttribute.cs
- DiscoveryDocumentSearchPattern.cs
- SpanIndex.cs
- XhtmlBasicTextViewAdapter.cs
- webclient.cs
- UnaryExpression.cs
- RuntimeConfigLKG.cs
- MimeMapping.cs
- Pkcs9Attribute.cs
- EmptyControlCollection.cs
- EndpointIdentity.cs
- GeometryGroup.cs
- SplineKeyFrames.cs
- SrgsOneOf.cs
- XmlSchemaGroupRef.cs
- X509Utils.cs