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
- WebPartConnectVerb.cs
- ShaderEffect.cs
- HttpChannelHelper.cs
- NumberAction.cs
- Wizard.cs
- Screen.cs
- XhtmlBasicPhoneCallAdapter.cs
- XmlUtf8RawTextWriter.cs
- CodeTypeDeclarationCollection.cs
- SendingRequestEventArgs.cs
- IgnoreDeviceFilterElementCollection.cs
- ViewCellSlot.cs
- MsmqPoisonMessageException.cs
- TextLineResult.cs
- XmlSchemaAnyAttribute.cs
- Binding.cs
- LicenseProviderAttribute.cs
- PreviewKeyDownEventArgs.cs
- ProfilePropertyNameValidator.cs
- IntegrationExceptionEventArgs.cs
- GB18030Encoding.cs
- ChannelHandler.cs
- GridViewColumnCollection.cs
- SystemIcons.cs
- IriParsingElement.cs
- ScriptResourceInfo.cs
- RegisteredExpandoAttribute.cs
- AttributeUsageAttribute.cs
- HttpHeaderCollection.cs
- _FixedSizeReader.cs
- DefaultPropertiesToSend.cs
- StringAnimationBase.cs
- InertiaTranslationBehavior.cs
- Timer.cs
- HtmlTableCell.cs
- ProbeMatches11.cs
- CounterSampleCalculator.cs
- oledbconnectionstring.cs
- Win32PrintDialog.cs
- SchemaImporterExtension.cs
- SmiRequestExecutor.cs
- BasicHttpSecurityMode.cs
- WindowsMenu.cs
- CodeSnippetExpression.cs
- DesignerAutoFormatStyle.cs
- ReadonlyMessageFilter.cs
- ChtmlMobileTextWriter.cs
- EpmContentDeSerializer.cs
- FixedStringLookup.cs
- PathFigureCollection.cs
- DateTimeOffsetStorage.cs
- ActivityWithResultWrapper.cs
- Convert.cs
- EmbeddedMailObject.cs
- PropertyItem.cs
- QilList.cs
- PassportAuthentication.cs
- SessionParameter.cs
- DataConnectionHelper.cs
- ParameterCollection.cs
- ImageSourceValueSerializer.cs
- ColumnTypeConverter.cs
- CodeExpressionStatement.cs
- SqlDataReader.cs
- AuthorizationRuleCollection.cs
- UnicastIPAddressInformationCollection.cs
- OleDbPermission.cs
- EnumValAlphaComparer.cs
- BamlLocalizableResourceKey.cs
- PeerObject.cs
- ActiveXHelper.cs
- Attributes.cs
- EventSinkHelperWriter.cs
- FunctionDetailsReader.cs
- base64Transforms.cs
- TTSVoice.cs
- MarkupExtensionReturnTypeAttribute.cs
- coordinator.cs
- StrokeCollection.cs
- PolyBezierSegment.cs
- SqlWriter.cs
- SqlCacheDependency.cs
- Container.cs
- TransformPattern.cs
- ProviderConnectionPoint.cs
- EntityConnection.cs
- XamlFilter.cs
- AuthenticationModuleElement.cs
- MetadataImporterQuotas.cs
- XmlSchemaAttributeGroupRef.cs
- WsatAdminException.cs
- DataGridViewCellStyle.cs
- TaiwanCalendar.cs
- figurelength.cs
- ProcessHostServerConfig.cs
- PersistChildrenAttribute.cs
- XmlEncodedRawTextWriter.cs
- TableLayoutSettings.cs
- CalendarDesigner.cs
- FormsAuthenticationEventArgs.cs