public RedefineEntry(XmlSchemaRedefine external, XmlSchema schema) {
redefine = external;
schemaToUpdate = schema;
}
private void SetContainer(State state, object container) {
switch (state) {
case State.Root:
break;
case State.Schema:
break;
case State.Annotation:
this.annotation = (XmlSchemaAnnotation)container;
break;
case State.Include:
this.include = (XmlSchemaInclude)container;
break;
case State.Import:
this.import = (XmlSchemaImport)container;
break;
case State.Element:
this.element = (XmlSchemaElement)container;
break;
case State.Attribute:
this.attribute = (XmlSchemaAttribute)container;
break;
case State.AttributeGroup:
this.attributeGroup = (XmlSchemaAttributeGroup)container;
break;
case State.AttributeGroupRef:
this.attributeGroupRef = (XmlSchemaAttributeGroupRef)container;
break;
case State.AnyAttribute:
this.anyAttribute = (XmlSchemaAnyAttribute)container;
break;
case State.Group:
this.group = (XmlSchemaGroup)container;
break;
case State.GroupRef:
this.groupRef = (XmlSchemaGroupRef)container;
break;
case State.All:
this.all = (XmlSchemaAll)container;
break;
case State.Choice:
this.choice = (XmlSchemaChoice)container;
break;
case State.Sequence:
this.sequence = (XmlSchemaSequence)container;
break;
case State.Any:
this.anyElement = (XmlSchemaAny)container;
break;
case State.Notation:
this.notation = (XmlSchemaNotation)container;
break;
case State.SimpleType:
this.simpleType = (XmlSchemaSimpleType)container;
break;
case State.ComplexType:
this.complexType = (XmlSchemaComplexType)container;
break;
case State.ComplexContent:
this.complexContent = (XmlSchemaComplexContent)container;
break;
case State.ComplexContentExtension:
this.complexContentExtension = (XmlSchemaComplexContentExtension)container;
break;
case State.ComplexContentRestriction:
this.complexContentRestriction = (XmlSchemaComplexContentRestriction)container;
break;
case State.SimpleContent:
this.simpleContent = (XmlSchemaSimpleContent)container;
break;
case State.SimpleContentExtension:
this.simpleContentExtension = (XmlSchemaSimpleContentExtension)container;
break;
case State.SimpleContentRestriction:
this.simpleContentRestriction = (XmlSchemaSimpleContentRestriction)container;
break;
case State.SimpleTypeUnion:
this.simpleTypeUnion = (XmlSchemaSimpleTypeUnion)container;
break;
case State.SimpleTypeList:
this.simpleTypeList = (XmlSchemaSimpleTypeList)container;
break;
case State.SimpleTypeRestriction:
this.simpleTypeRestriction = (XmlSchemaSimpleTypeRestriction)container;
break;
case State.Unique:
case State.Key:
case State.KeyRef:
this.identityConstraint = (XmlSchemaIdentityConstraint)container;
break;
case State.Selector:
case State.Field:
this.xpath = (XmlSchemaXPath)container;
break;
case State.MinExclusive:
case State.MinInclusive:
case State.MaxExclusive:
case State.MaxInclusive:
case State.TotalDigits:
case State.FractionDigits:
case State.Length:
case State.MinLength:
case State.MaxLength:
case State.Enumeration:
case State.Pattern:
case State.WhiteSpace:
this.facet = (XmlSchemaFacet)container;
break;
case State.AppInfo:
this.appInfo = (XmlSchemaAppInfo)container;
break;
case State.Documentation:
this.documentation = (XmlSchemaDocumentation)container;
break;
case State.Redefine:
this.redefine = (XmlSchemaRedefine)container;
break;
default:
Debug.Assert(false, "State is " + state);
break;
}
}
void ProcessExternal(ValidationEventHandler handler, List <CompiledSchemaMemo> handledUris, XmlResolver resolver, XmlSchemaExternal ext, XmlSchemaSet col)
{
if (ext == null)
{
error(handler, String.Format("Object of Type {0} is not valid in Includes Property of XmlSchema", ext.GetType().Name));
return;
}
// The only case we want to handle where the SchemaLocation is null is if the external is an import.
XmlSchemaImport import = ext as XmlSchemaImport;
if (ext.SchemaLocation == null && import == null)
{
return;
}
XmlSchema includedSchema = null;
if (ext.SchemaLocation != null)
{
Stream stream = null;
string url = null;
if (resolver != null)
{
url = GetResolvedUri(resolver, ext.SchemaLocation);
foreach (var i in handledUris)
{
if (i.SourceUri.Equals(url))
{
// This schema is already handled, so simply skip (otherwise, duplicate definition errrors occur.
return;
}
}
handledUris.Add(new CompiledSchemaMemo()
{
SourceUri = url
});
try {
stream = resolver.GetEntity(new Uri(url), null, typeof(Stream)) as Stream;
} catch (Exception) {
// 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.
warn(handler, "Could not resolve schema location URI: " + url);
stream = null;
}
}
// Process redefinition children in advance.
XmlSchemaRedefine redefine = ext as XmlSchemaRedefine;
if (redefine != null)
{
for (int j = 0; j < redefine.Items.Count; j++)
{
XmlSchemaObject redefinedObj = redefine.Items [j];
redefinedObj.isRedefinedComponent = true;
redefinedObj.isRedefineChild = true;
if (redefinedObj is XmlSchemaType ||
redefinedObj is XmlSchemaGroup ||
redefinedObj is XmlSchemaAttributeGroup)
{
compilationItems.Add(redefinedObj);
}
else
{
error(handler, "Redefinition is only allowed to simpleType, complexType, group and attributeGroup.");
}
}
}
if (stream == null)
{
// It is missing schema components.
missedSubComponents = true;
return;
}
else
{
XmlTextReader xtr = null;
try {
xtr = new XmlTextReader(url, stream, nameTable);
includedSchema = XmlSchema.Read(xtr, handler);
} finally {
if (xtr != null)
{
xtr.Close();
}
}
includedSchema.schemas = schemas;
}
includedSchema.SetParent();
ext.Schema = includedSchema;
}
// Set - actual - target namespace for the included schema * before compilation*.
if (import != null)
{
if (ext.Schema == null && ext.SchemaLocation == null)
{
// if a schema location wasn't specified, check the other schemas we have to see if one of those
// is a match.
foreach (XmlSchema schema in col.Schemas())
{
if (schema.TargetNamespace == import.Namespace)
{
includedSchema = schema;
includedSchema.schemas = schemas;
includedSchema.SetParent();
ext.Schema = includedSchema;
break;
}
}
// handle case where target namespace doesn't exist in schema collection - i.e can't find it at all
if (includedSchema == null)
{
return;
}
}
else if (includedSchema != null)
{
if (TargetNamespace == includedSchema.TargetNamespace)
{
error(handler, "Target namespace must be different from that of included schema.");
return;
}
else if (includedSchema.TargetNamespace != import.Namespace)
{
error(handler, "Attribute namespace and its importing schema's target namespace must be the same.");
return;
}
}
}
else if (includedSchema != null)
{
if (TargetNamespace == null &&
includedSchema.TargetNamespace != null)
{
includedSchema.error(handler, String.Format("On {0} element, targetNamespace is required to include a schema which has its own target namespace", ext.GetType().Name));
return;
}
else if (TargetNamespace != null &&
includedSchema.TargetNamespace == null)
{
includedSchema.TargetNamespace = TargetNamespace;
}
}
// Do not compile included schema here.
if (includedSchema != null)
{
AddExternalComponentsTo(includedSchema, compilationItems, handler, handledUris, resolver, col);
}
}
private static void ReadContent(XmlSchema schema, XmlSchemaReader reader, ValidationEventHandler h)
{
reader.MoveToElement();
if (reader.LocalName != "schema" && reader.NamespaceURI != XmlSchema.Namespace && reader.NodeType != XmlNodeType.Element)
{
error(h, "UNREACHABLE CODE REACHED: Method: Schema.ReadContent, " + reader.LocalName + ", " + reader.NamespaceURI, null);
}
//(include | import | redefine | annotation)*,
//((simpleType | complexType | group | attributeGroup | element | attribute | notation | annotation)*
int level = 1;
while (reader.ReadNextElement())
{
if (reader.NodeType == XmlNodeType.EndElement)
{
if (reader.LocalName != xmlname)
{
error(h, "Should not happen :2: XmlSchema.Read, name=" + reader.Name, null);
}
break;
}
if (level <= 1)
{
if (reader.LocalName == "include")
{
XmlSchemaInclude include = XmlSchemaInclude.Read(reader, h);
if (include != null)
{
schema.includes.Add(include);
}
continue;
}
if (reader.LocalName == "import")
{
XmlSchemaImport import = XmlSchemaImport.Read(reader, h);
if (import != null)
{
schema.includes.Add(import);
}
continue;
}
if (reader.LocalName == "redefine")
{
XmlSchemaRedefine redefine = XmlSchemaRedefine.Read(reader, h);
if (redefine != null)
{
schema.includes.Add(redefine);
}
continue;
}
if (reader.LocalName == "annotation")
{
XmlSchemaAnnotation annotation = XmlSchemaAnnotation.Read(reader, h);
if (annotation != null)
{
schema.items.Add(annotation);
}
continue;
}
}
if (level <= 2)
{
level = 2;
if (reader.LocalName == "simpleType")
{
XmlSchemaSimpleType stype = XmlSchemaSimpleType.Read(reader, h);
if (stype != null)
{
schema.items.Add(stype);
}
continue;
}
if (reader.LocalName == "complexType")
{
XmlSchemaComplexType ctype = XmlSchemaComplexType.Read(reader, h);
if (ctype != null)
{
schema.items.Add(ctype);
}
continue;
}
if (reader.LocalName == "group")
{
XmlSchemaGroup group = XmlSchemaGroup.Read(reader, h);
if (group != null)
{
schema.items.Add(group);
}
continue;
}
if (reader.LocalName == "attributeGroup")
{
XmlSchemaAttributeGroup attributeGroup = XmlSchemaAttributeGroup.Read(reader, h);
if (attributeGroup != null)
{
schema.items.Add(attributeGroup);
}
continue;
}
if (reader.LocalName == "element")
{
XmlSchemaElement element = XmlSchemaElement.Read(reader, h);
if (element != null)
{
schema.items.Add(element);
}
continue;
}
if (reader.LocalName == "attribute")
{
XmlSchemaAttribute attr = XmlSchemaAttribute.Read(reader, h);
if (attr != null)
{
schema.items.Add(attr);
}
continue;
}
if (reader.LocalName == "notation")
{
XmlSchemaNotation notation = XmlSchemaNotation.Read(reader, h);
if (notation != null)
{
schema.items.Add(notation);
}
continue;
}
if (reader.LocalName == "annotation")
{
XmlSchemaAnnotation annotation = XmlSchemaAnnotation.Read(reader, h);
if (annotation != null)
{
schema.items.Add(annotation);
}
continue;
}
}
reader.RaiseInvalidElementError();
}
}
void DoCompile(ValidationEventHandler handler, Hashtable handledUris, XmlSchemaSet col, XmlResolver resolver)
{
SetParent();
CompilationId = col.CompilationId;
schemas = col;
if (!schemas.Contains(this)) // e.g. xs:import
{
schemas.Add(this);
}
attributeGroups.Clear();
attributes.Clear();
elements.Clear();
groups.Clear();
notations.Clear();
schemaTypes.Clear();
//1. Union and List are not allowed in block default
if (BlockDefault != XmlSchemaDerivationMethod.All)
{
if ((BlockDefault & XmlSchemaDerivationMethod.List) != 0)
{
error(handler, "list is not allowed in blockDefault attribute");
}
if ((BlockDefault & XmlSchemaDerivationMethod.Union) != 0)
{
error(handler, "union is not allowed in blockDefault attribute");
}
}
//2. Substitution is not allowed in finaldefault.
if (FinalDefault != XmlSchemaDerivationMethod.All)
{
if ((FinalDefault & XmlSchemaDerivationMethod.Substitution) != 0)
{
error(handler, "substitution is not allowed in finalDefault attribute");
}
}
//3. id must be of type ID
XmlSchemaUtil.CompileID(Id, this, col.IDCollection, handler);
//4. targetNamespace should be of type anyURI or absent
if (TargetNamespace != null)
{
if (TargetNamespace.Length == 0)
{
error(handler, "The targetNamespace attribute cannot have have empty string as its value.");
}
if (!XmlSchemaUtil.CheckAnyUri(TargetNamespace))
{
error(handler, TargetNamespace + " is not a valid value for targetNamespace attribute of schema");
}
}
//5. version should be of type normalizedString
if (!XmlSchemaUtil.CheckNormalizedString(Version))
{
error(handler, Version + "is not a valid value for version attribute of schema");
}
// Compile the content of this schema
compilationItems = new XmlSchemaObjectCollection();
for (int i = 0; i < Items.Count; i++)
{
compilationItems.Add(Items [i]);
}
// First, we run into inclusion schemas to collect
// compilation target items into compiledItems.
for (int i = 0; i < Includes.Count; i++)
{
XmlSchemaExternal ext = Includes [i] as XmlSchemaExternal;
if (ext == null)
{
error(handler, String.Format("Object of Type {0} is not valid in Includes Property of XmlSchema", Includes [i].GetType().Name));
continue;
}
if (ext.SchemaLocation == null)
{
continue;
}
Stream stream = null;
string url = null;
if (resolver != null)
{
url = GetResolvedUri(resolver, ext.SchemaLocation);
if (handledUris.Contains(url))
{
// This schema is already handled, so simply skip (otherwise, duplicate definition errrors occur.
continue;
}
handledUris.Add(url, url);
try {
stream = resolver.GetEntity(new Uri(url), null, typeof(Stream)) as Stream;
} catch (Exception) {
// 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.
warn(handler, "Could not resolve schema location URI: " + url);
stream = null;
}
}
// Process redefinition children in advance.
XmlSchemaRedefine redefine = Includes [i] as XmlSchemaRedefine;
if (redefine != null)
{
for (int j = 0; j < redefine.Items.Count; j++)
{
XmlSchemaObject redefinedObj = redefine.Items [j];
redefinedObj.isRedefinedComponent = true;
redefinedObj.isRedefineChild = true;
if (redefinedObj is XmlSchemaType ||
redefinedObj is XmlSchemaGroup ||
redefinedObj is XmlSchemaAttributeGroup)
{
compilationItems.Add(redefinedObj);
}
else
{
error(handler, "Redefinition is only allowed to simpleType, complexType, group and attributeGroup.");
}
}
}
XmlSchema includedSchema = null;
if (stream == null)
{
// It is missing schema components.
missedSubComponents = true;
continue;
}
else
{
XmlTextReader xtr = null;
try {
xtr = new XmlTextReader(url, stream, nameTable);
includedSchema = XmlSchema.Read(xtr, handler);
} finally {
if (xtr != null)
{
xtr.Close();
}
}
includedSchema.schemas = schemas;
}
includedSchema.SetParent();
ext.Schema = includedSchema;
// Set - actual - target namespace for the included schema * before compilation*.
XmlSchemaImport import = ext as XmlSchemaImport;
if (import != null)
{
if (TargetNamespace == includedSchema.TargetNamespace)
{
error(handler, "Target namespace must be different from that of included schema.");
continue;
}
else if (includedSchema.TargetNamespace != import.Namespace)
{
error(handler, "Attribute namespace and its importing schema's target namespace must be the same.");
continue;
}
}
else
{
if (TargetNamespace == null &&
includedSchema.TargetNamespace != null)
{
error(handler, "Target namespace is required to include a schema which has its own target namespace");
continue;
}
else if (TargetNamespace != null &&
includedSchema.TargetNamespace == null)
{
includedSchema.TargetNamespace = TargetNamespace;
}
}
// Do not compile included schema here.
AddExternalComponentsTo(includedSchema, compilationItems);
}
// Compilation phase.
// At least each Compile() must give unique (qualified) name for each component.
// It also checks self-resolvable properties correctness.
// Post compilation schema information contribution is not done here.
// It should be done by Validate().
for (int i = 0; i < compilationItems.Count; i++)
{
XmlSchemaObject obj = compilationItems [i];
if (obj is XmlSchemaAnnotation)
{
int numerr = ((XmlSchemaAnnotation)obj).Compile(handler, this);
errorCount += numerr;
}
else if (obj is XmlSchemaAttribute)
{
XmlSchemaAttribute attr = (XmlSchemaAttribute)obj;
int numerr = attr.Compile(handler, this);
errorCount += numerr;
if (numerr == 0)
{
XmlSchemaUtil.AddToTable(Attributes, attr, attr.QualifiedName, handler);
}
}
else if (obj is XmlSchemaAttributeGroup)
{
XmlSchemaAttributeGroup attrgrp = (XmlSchemaAttributeGroup)obj;
int numerr = attrgrp.Compile(handler, this);
errorCount += numerr;
if (numerr == 0)
{
XmlSchemaUtil.AddToTable(
AttributeGroups,
attrgrp,
attrgrp.QualifiedName,
handler);
}
}
else if (obj is XmlSchemaComplexType)
{
XmlSchemaComplexType ctype = (XmlSchemaComplexType)obj;
int numerr = ctype.Compile(handler, this);
errorCount += numerr;
if (numerr == 0)
{
XmlSchemaUtil.AddToTable(
schemaTypes,
ctype,
ctype.QualifiedName,
handler);
}
}
else if (obj is XmlSchemaSimpleType)
{
XmlSchemaSimpleType stype = (XmlSchemaSimpleType)obj;
stype.islocal = false; //This simple type is toplevel
int numerr = stype.Compile(handler, this);
errorCount += numerr;
if (numerr == 0)
{
XmlSchemaUtil.AddToTable(
SchemaTypes,
stype,
stype.QualifiedName,
handler);
}
}
else if (obj is XmlSchemaElement)
{
XmlSchemaElement elem = (XmlSchemaElement)obj;
elem.parentIsSchema = true;
int numerr = elem.Compile(handler, this);
errorCount += numerr;
if (numerr == 0)
{
XmlSchemaUtil.AddToTable(
Elements,
elem,
elem.QualifiedName,
handler);
}
}
else if (obj is XmlSchemaGroup)
{
XmlSchemaGroup grp = (XmlSchemaGroup)obj;
int numerr = grp.Compile(handler, this);
errorCount += numerr;
if (numerr == 0)
{
XmlSchemaUtil.AddToTable(
Groups,
grp,
grp.QualifiedName,
handler);
}
}
else if (obj is XmlSchemaNotation)
{
XmlSchemaNotation ntn = (XmlSchemaNotation)obj;
int numerr = ntn.Compile(handler, this);
errorCount += numerr;
if (numerr == 0)
{
XmlSchemaUtil.AddToTable(
Notations,
ntn,
ntn.QualifiedName,
handler);
}
}
else
{
ValidationHandler.RaiseValidationEvent(
handler,
null,
String.Format("Object of Type {0} is not valid in Item Property of Schema", obj.GetType().Name),
null,
this,
null,
XmlSeverityType.Error);
}
}
}
/// <summary>
/// Merges annotations between redefined and redefining schemas</summary>
/// <param name="schemaRedefine">XmlSchemeRefine</param>
private void MergeRedefinedTypeAnnotations(XmlSchemaRedefine schemaRedefine)
{
// get index to original complex types
Dictionary<XmlQualifiedName, XmlSchemaComplexType> originalTypes =
new Dictionary<XmlQualifiedName, XmlSchemaComplexType>();
foreach (XmlSchemaObject schemaItem in schemaRedefine.Schema.Items)
{
XmlSchemaComplexType complexType = schemaItem as XmlSchemaComplexType;
if (complexType != null)
originalTypes.Add(complexType.QualifiedName, complexType);
}
// merge annotation for redefined complex types
foreach (XmlSchemaObject schemaItem in schemaRedefine.Items)
{
XmlSchemaComplexType complexType = schemaItem as XmlSchemaComplexType;
if (complexType != null)
{
XmlQualifiedName name = complexType.QualifiedName;
XmlSchemaComplexType originalType = originalTypes[name];
if (originalType.IsAbstract != complexType.IsAbstract)
throw new InvalidOperationException(
"Type redefinition changes abstractness. (" + originalType.Name + ")");
string typeName = name.ToString();
DomNodeType nodeType;
if (m_nodeTypes.TryGetValue(typeName, out nodeType))
{
IList<XmlNode> annotations;
if (m_annotations.TryGetValue(nodeType, out annotations))
{
// Call protected virtual merge method - allowing clients to define if & how annotations are being merged
IEnumerable<XmlNode> mergedAnnotations = MergeRedefinedTypeAnnotations(
GetAnnotation(originalType),
annotations);
m_annotations[nodeType] = mergedAnnotations as IList<XmlNode> ?? mergedAnnotations.ToList();
}
}
}
}
}
public virtual void Check (ConformanceCheckContext ctx, XmlSchemaRedefine value) {}
private void PreprocessRedefine(XmlSchemaRedefine redefine) {
for (int i = 0; i < redefine.Items.Count; ++i) {
SetParent(redefine.Items[i], redefine);
XmlSchemaGroup group = redefine.Items[i] as XmlSchemaGroup;
if (group != null) {
PreprocessGroup(group);
if (redefine.Groups[group.QualifiedName] != null) {
SendValidationEvent(Res.Sch_GroupDoubleRedefine, group);
}
else {
AddToTable(redefine.Groups, group.QualifiedName, group);
group.Redefined = (XmlSchemaGroup)redefine.Schema.Groups[group.QualifiedName];
if (group.Redefined != null) {
CheckRefinedGroup(group);
}
else {
SendValidationEvent(Res.Sch_GroupRedefineNotFound, group);
}
}
}
else if (redefine.Items[i] is XmlSchemaAttributeGroup) {
XmlSchemaAttributeGroup attributeGroup = (XmlSchemaAttributeGroup)redefine.Items[i];
PreprocessAttributeGroup(attributeGroup);
if (redefine.AttributeGroups[attributeGroup.QualifiedName] != null) {
SendValidationEvent(Res.Sch_AttrGroupDoubleRedefine, attributeGroup);
}
else {
AddToTable(redefine.AttributeGroups, attributeGroup.QualifiedName, attributeGroup);
attributeGroup.Redefined = (XmlSchemaAttributeGroup)redefine.Schema.AttributeGroups[attributeGroup.QualifiedName];
if (attributeGroup.Redefined != null) {
CheckRefinedAttributeGroup(attributeGroup);
}
else {
SendValidationEvent(Res.Sch_AttrGroupRedefineNotFound, attributeGroup);
}
}
}
else if (redefine.Items[i] is XmlSchemaComplexType) {
XmlSchemaComplexType complexType = (XmlSchemaComplexType)redefine.Items[i];
PreprocessComplexType(complexType, false);
if (redefine.SchemaTypes[complexType.QualifiedName] != null) {
SendValidationEvent(Res.Sch_ComplexTypeDoubleRedefine, complexType);
}
else {
AddToTable(redefine.SchemaTypes, complexType.QualifiedName, complexType);
XmlSchemaType type = (XmlSchemaType)redefine.Schema.SchemaTypes[complexType.QualifiedName];
if (type != null) {
if (type is XmlSchemaComplexType) {
complexType.Redefined = type;
CheckRefinedComplexType(complexType);
}
else {
SendValidationEvent(Res.Sch_SimpleToComplexTypeRedefine, complexType);
}
}
else {
SendValidationEvent(Res.Sch_ComplexTypeRedefineNotFound, complexType);
}
}
}
else if (redefine.Items[i] is XmlSchemaSimpleType) {
XmlSchemaSimpleType simpleType = (XmlSchemaSimpleType)redefine.Items[i];
PreprocessSimpleType(simpleType, false);
if (redefine.SchemaTypes[simpleType.QualifiedName] != null) {
SendValidationEvent(Res.Sch_SimpleTypeDoubleRedefine, simpleType);
}
else {
AddToTable(redefine.SchemaTypes, simpleType.QualifiedName, simpleType);
XmlSchemaType type = (XmlSchemaType)redefine.Schema.SchemaTypes[simpleType.QualifiedName];
if (type != null) {
if (type is XmlSchemaSimpleType) {
simpleType.Redefined = type;
CheckRefinedSimpleType(simpleType);
}
else {
SendValidationEvent(Res.Sch_ComplexToSimpleTypeRedefine, simpleType);
}
}
else {
SendValidationEvent(Res.Sch_SimpleTypeRedefineNotFound, simpleType);
}
}
}
}
foreach (DictionaryEntry entry in redefine.Groups) {
redefine.Schema.Groups.Insert((XmlQualifiedName)entry.Key, (XmlSchemaObject)entry.Value);
}
foreach (DictionaryEntry entry in redefine.AttributeGroups) {
redefine.Schema.AttributeGroups.Insert((XmlQualifiedName)entry.Key, (XmlSchemaObject)entry.Value);
}
foreach (DictionaryEntry entry in redefine.SchemaTypes) {
redefine.Schema.SchemaTypes.Insert((XmlQualifiedName)entry.Key, (XmlSchemaObject)entry.Value);
}
}
protected override void Visit(XmlSchemaRedefine redefine)
{
TraverseExternalSchema(redefine);
}
//<redefine
// id = ID
// schemaLocation = anyURI
// {any attributes with non-schema namespace . . .}>
// Content: (annotation | (simpleType | complexType | group | attributeGroup))*
//</redefine>
internal static XmlSchemaRedefine Read(XmlSchemaReader reader, ValidationEventHandler h)
{
XmlSchemaRedefine redefine = new XmlSchemaRedefine();
reader.MoveToElement();
if (reader.NamespaceURI != XmlSchema.Namespace || reader.LocalName != xmlname)
{
error(h, "Should not happen :1: XmlSchemaRedefine.Read, name=" + reader.Name, null);
reader.Skip();
return(null);
}
redefine.LineNumber = reader.LineNumber;
redefine.LinePosition = reader.LinePosition;
redefine.SourceUri = reader.BaseURI;
while (reader.MoveToNextAttribute())
{
if (reader.Name == "id")
{
redefine.Id = reader.Value;
}
else if (reader.Name == "schemaLocation")
{
redefine.SchemaLocation = reader.Value;
}
else if ((reader.NamespaceURI == "" && reader.Name != "xmlns") || reader.NamespaceURI == XmlSchema.Namespace)
{
error(h, reader.Name + " is not a valid attribute for redefine", null);
}
else
{
XmlSchemaUtil.ReadUnhandledAttribute(reader, redefine);
}
}
reader.MoveToElement();
if (reader.IsEmptyElement)
{
return(redefine);
}
//(annotation | (simpleType | complexType | group | attributeGroup))*
while (reader.ReadNextElement())
{
if (reader.NodeType == XmlNodeType.EndElement)
{
if (reader.LocalName != xmlname)
{
error(h, "Should not happen :2: XmlSchemaRedefine.Read, name=" + reader.Name, null);
}
break;
}
if (reader.LocalName == "annotation")
{
XmlSchemaAnnotation annotation = XmlSchemaAnnotation.Read(reader, h);
if (annotation != null)
{
redefine.items.Add(annotation);
}
continue;
}
if (reader.LocalName == "simpleType")
{
XmlSchemaSimpleType simpleType = XmlSchemaSimpleType.Read(reader, h);
if (simpleType != null)
{
redefine.items.Add(simpleType);
}
continue;
}
if (reader.LocalName == "complexType")
{
XmlSchemaComplexType complexType = XmlSchemaComplexType.Read(reader, h);
if (complexType != null)
{
redefine.items.Add(complexType);
}
continue;
}
if (reader.LocalName == "group")
{
XmlSchemaGroup group = XmlSchemaGroup.Read(reader, h);
if (group != null)
{
redefine.items.Add(group);
}
continue;
}
if (reader.LocalName == "attributeGroup")
{
XmlSchemaAttributeGroup attributeGroup = XmlSchemaAttributeGroup.Read(reader, h);
if (attributeGroup != null)
{
redefine.items.Add(attributeGroup);
}
continue;
}
reader.RaiseInvalidElementError();
}
return(redefine);
}
internal static XmlSchemaRedefine Read(XmlSchemaReader reader, ValidationEventHandler h)
{
XmlSchemaRedefine xmlSchemaRedefine = new XmlSchemaRedefine();
reader.MoveToElement();
if (reader.NamespaceURI != "http://www.w3.org/2001/XMLSchema" || reader.LocalName != "redefine")
{
XmlSchemaObject.error(h, "Should not happen :1: XmlSchemaRedefine.Read, name=" + reader.Name, null);
reader.Skip();
return(null);
}
xmlSchemaRedefine.LineNumber = reader.LineNumber;
xmlSchemaRedefine.LinePosition = reader.LinePosition;
xmlSchemaRedefine.SourceUri = reader.BaseURI;
while (reader.MoveToNextAttribute())
{
if (reader.Name == "id")
{
xmlSchemaRedefine.Id = reader.Value;
}
else if (reader.Name == "schemaLocation")
{
xmlSchemaRedefine.SchemaLocation = reader.Value;
}
else if ((reader.NamespaceURI == string.Empty && reader.Name != "xmlns") || reader.NamespaceURI == "http://www.w3.org/2001/XMLSchema")
{
XmlSchemaObject.error(h, reader.Name + " is not a valid attribute for redefine", null);
}
else
{
XmlSchemaUtil.ReadUnhandledAttribute(reader, xmlSchemaRedefine);
}
}
reader.MoveToElement();
if (reader.IsEmptyElement)
{
return(xmlSchemaRedefine);
}
while (reader.ReadNextElement())
{
if (reader.NodeType == XmlNodeType.EndElement)
{
if (reader.LocalName != "redefine")
{
XmlSchemaObject.error(h, "Should not happen :2: XmlSchemaRedefine.Read, name=" + reader.Name, null);
}
break;
}
if (reader.LocalName == "annotation")
{
XmlSchemaAnnotation xmlSchemaAnnotation = XmlSchemaAnnotation.Read(reader, h);
if (xmlSchemaAnnotation != null)
{
xmlSchemaRedefine.items.Add(xmlSchemaAnnotation);
}
}
else if (reader.LocalName == "simpleType")
{
XmlSchemaSimpleType xmlSchemaSimpleType = XmlSchemaSimpleType.Read(reader, h);
if (xmlSchemaSimpleType != null)
{
xmlSchemaRedefine.items.Add(xmlSchemaSimpleType);
}
}
else if (reader.LocalName == "complexType")
{
XmlSchemaComplexType xmlSchemaComplexType = XmlSchemaComplexType.Read(reader, h);
if (xmlSchemaComplexType != null)
{
xmlSchemaRedefine.items.Add(xmlSchemaComplexType);
}
}
else if (reader.LocalName == "group")
{
XmlSchemaGroup xmlSchemaGroup = XmlSchemaGroup.Read(reader, h);
if (xmlSchemaGroup != null)
{
xmlSchemaRedefine.items.Add(xmlSchemaGroup);
}
}
else if (reader.LocalName == "attributeGroup")
{
XmlSchemaAttributeGroup xmlSchemaAttributeGroup = XmlSchemaAttributeGroup.Read(reader, h);
if (xmlSchemaAttributeGroup != null)
{
xmlSchemaRedefine.items.Add(xmlSchemaAttributeGroup);
}
}
else
{
reader.RaiseInvalidElementError();
}
}
return(xmlSchemaRedefine);
}
protected virtual void Visit(XmlSchemaRedefine redefine)
{
}
//<redefine
// id = ID
// schemaLocation = anyURI
// {any attributes with non-schema namespace . . .}>
// Content: (annotation | (simpleType | complexType | group | attributeGroup))*
//</redefine>
internal static XmlSchemaRedefine Read(XmlSchemaReader reader, ValidationEventHandler h)
{
XmlSchemaRedefine redefine = new XmlSchemaRedefine();
reader.MoveToElement();
if(reader.NamespaceURI != XmlSchema.Namespace || reader.LocalName != xmlname)
{
error(h,"Should not happen :1: XmlSchemaRedefine.Read, name="+reader.Name,null);
reader.Skip();
return null;
}
redefine.LineNumber = reader.LineNumber;
redefine.LinePosition = reader.LinePosition;
redefine.SourceUri = reader.BaseURI;
while(reader.MoveToNextAttribute())
{
if(reader.Name == "id")
{
redefine.Id = reader.Value;
}
else if(reader.Name == "schemaLocation")
{
redefine.SchemaLocation = reader.Value;
}
else if((reader.NamespaceURI == "" && reader.Name != "xmlns") || reader.NamespaceURI == XmlSchema.Namespace)
{
error(h,reader.Name + " is not a valid attribute for redefine",null);
}
else
{
XmlSchemaUtil.ReadUnhandledAttribute(reader,redefine);
}
}
reader.MoveToElement();
if(reader.IsEmptyElement)
return redefine;
//(annotation | (simpleType | complexType | group | attributeGroup))*
while(reader.ReadNextElement())
{
if(reader.NodeType == XmlNodeType.EndElement)
{
if(reader.LocalName != xmlname)
error(h,"Should not happen :2: XmlSchemaRedefine.Read, name="+reader.Name,null);
break;
}
if(reader.LocalName == "annotation")
{
XmlSchemaAnnotation annotation = XmlSchemaAnnotation.Read(reader,h);
if(annotation != null)
redefine.items.Add(annotation);
continue;
}
if(reader.LocalName == "simpleType")
{
XmlSchemaSimpleType simpleType = XmlSchemaSimpleType.Read(reader,h);
if(simpleType != null)
redefine.items.Add(simpleType);
continue;
}
if(reader.LocalName == "complexType")
{
XmlSchemaComplexType complexType = XmlSchemaComplexType.Read(reader,h);
if(complexType != null)
redefine.items.Add(complexType);
continue;
}
if(reader.LocalName == "group")
{
XmlSchemaGroup group = XmlSchemaGroup.Read(reader,h);
if(group != null)
redefine.items.Add(group);
continue;
}
if(reader.LocalName == "attributeGroup")
{
XmlSchemaAttributeGroup attributeGroup = XmlSchemaAttributeGroup.Read(reader,h);
if(attributeGroup != null)
redefine.items.Add(attributeGroup);
continue;
}
reader.RaiseInvalidElementError();
}
return redefine;
}
public RedefineEntry(XmlSchemaRedefine external, XmlSchema schema)
{
this.redefine = external;
this.schemaToUpdate = schema;
}
private void Write64_XmlSchemaRedefine(string n, string ns, XmlSchemaRedefine o, bool isNullable, bool needType)
{
if (o == null)
{
if (isNullable)
{
base.WriteNullTagLiteral(n, ns);
}
}
else
{
if (!needType && !(o.GetType() == typeof(XmlSchemaRedefine)))
{
throw base.CreateUnknownTypeException(o);
}
base.EscapeName = false;
base.WriteStartElement(n, ns, o, false, o.Namespaces);
if (needType)
{
base.WriteXsiType("XmlSchemaRedefine", "http://www.w3.org/2001/XMLSchema");
}
base.WriteAttribute("schemaLocation", "", o.SchemaLocation);
base.WriteAttribute("id", "", o.Id);
XmlAttribute[] unhandledAttributes = o.UnhandledAttributes;
if (unhandledAttributes != null)
{
for (int i = 0; i < unhandledAttributes.Length; i++)
{
XmlAttribute node = unhandledAttributes[i];
base.WriteXmlAttribute(node, o);
}
}
XmlSchemaObjectCollection items = o.Items;
if (items != null)
{
for (int j = 0; j < items.Count; j++)
{
XmlSchemaObject obj2 = items[j];
if (obj2 is XmlSchemaSimpleType)
{
this.Write34_XmlSchemaSimpleType("simpleType", "http://www.w3.org/2001/XMLSchema", (XmlSchemaSimpleType) obj2, false, false);
}
else if (obj2 is XmlSchemaComplexType)
{
this.Write62_XmlSchemaComplexType("complexType", "http://www.w3.org/2001/XMLSchema", (XmlSchemaComplexType) obj2, false, false);
}
else if (obj2 is XmlSchemaGroup)
{
this.Write63_XmlSchemaGroup("group", "http://www.w3.org/2001/XMLSchema", (XmlSchemaGroup) obj2, false, false);
}
else if (obj2 is XmlSchemaAttributeGroup)
{
this.Write40_XmlSchemaAttributeGroup("attributeGroup", "http://www.w3.org/2001/XMLSchema", (XmlSchemaAttributeGroup) obj2, false, false);
}
else if (obj2 is XmlSchemaAnnotation)
{
this.Write11_XmlSchemaAnnotation("annotation", "http://www.w3.org/2001/XMLSchema", (XmlSchemaAnnotation) obj2, false, false);
}
else if (obj2 != null)
{
throw base.CreateUnknownTypeException(obj2);
}
}
}
base.WriteEndElement(o);
}
}
