private void PreprocessRedefine(RedefineEntry redefineEntry) {
XmlSchemaRedefine redefine = redefineEntry.redefine;
XmlSchema originalSchema = redefine.Schema;
currentSchema = GetParentSchema(redefine); //Set this for correct schema context in ValidateIdAttribute & ValidateQNameAttribute for redefines
Debug.Assert(currentSchema != null);
SetSchemaDefaults(currentSchema);
if (originalSchema.IsRedefined) {
SendValidationEvent(Res.Sch_MultipleRedefine, redefine, XmlSeverityType.Warning);
return;
}
originalSchema.IsRedefined = true;
XmlSchema schemaToUpdate = redefineEntry.schemaToUpdate;
ArrayList includesOfRedefine = new ArrayList();
GetIncludedSet(originalSchema, includesOfRedefine);
string targetNS = schemaToUpdate.TargetNamespace == null ? string.Empty : schemaToUpdate.TargetNamespace;
foreach(XmlSchemaObject item in redefine.Items) {
SetParent(item, redefine);
if (item is XmlSchemaGroup) {
XmlSchemaGroup group = (XmlSchemaGroup)item;
PreprocessGroup(group);
group.QualifiedName.SetNamespace(targetNS); //Since PreprocessGroup will use this.targetNamespace and that will be that of the root schema's
if (redefine.Groups[group.QualifiedName] != null) {
SendValidationEvent(Res.Sch_GroupDoubleRedefine, group);
}
else {
AddToTable(redefine.Groups, group.QualifiedName, group);
XmlSchemaGroup originalGroup = (XmlSchemaGroup)schemaToUpdate.Groups[group.QualifiedName];
XmlSchema parentSchema = GetParentSchema(originalGroup);
if (originalGroup == null || (parentSchema != originalSchema && !includesOfRedefine.Contains(parentSchema)) ) {
SendValidationEvent(Res.Sch_ComponentRedefineNotFound, "<group>", group.QualifiedName.ToString(), group);
}
else {
group.Redefined = originalGroup;
schemaToUpdate.Groups.Insert(group.QualifiedName, group);
CheckRefinedGroup(group);
}
}
}
else if (item is XmlSchemaAttributeGroup) {
XmlSchemaAttributeGroup attributeGroup = (XmlSchemaAttributeGroup)item;
PreprocessAttributeGroup(attributeGroup);
attributeGroup.QualifiedName.SetNamespace(targetNS); //Since PreprocessAttributeGroup will use this.targetNamespace and that will be that of the root schema's
if (redefine.AttributeGroups[attributeGroup.QualifiedName] != null) {
SendValidationEvent(Res.Sch_AttrGroupDoubleRedefine, attributeGroup);
}
else {
AddToTable(redefine.AttributeGroups, attributeGroup.QualifiedName, attributeGroup);
XmlSchemaAttributeGroup originalAttrGroup = (XmlSchemaAttributeGroup)schemaToUpdate.AttributeGroups[attributeGroup.QualifiedName];
XmlSchema parentSchema = GetParentSchema(originalAttrGroup);
if (originalAttrGroup == null || (parentSchema != originalSchema && !includesOfRedefine.Contains(parentSchema)) ) {
SendValidationEvent(Res.Sch_ComponentRedefineNotFound, "<attributeGroup>", attributeGroup.QualifiedName.ToString(), attributeGroup);
}
else {
attributeGroup.Redefined = originalAttrGroup;
schemaToUpdate.AttributeGroups.Insert(attributeGroup.QualifiedName, attributeGroup);
CheckRefinedAttributeGroup(attributeGroup);
}
}
}
else if (item is XmlSchemaComplexType) {
XmlSchemaComplexType complexType = (XmlSchemaComplexType)item;
PreprocessComplexType(complexType, false);
complexType.QualifiedName.SetNamespace(targetNS); //Since PreprocessComplexType will use this.targetNamespace and that will be that of the root schema's
if (redefine.SchemaTypes[complexType.QualifiedName] != null) {
SendValidationEvent(Res.Sch_ComplexTypeDoubleRedefine, complexType);
}
else {
AddToTable(redefine.SchemaTypes, complexType.QualifiedName, complexType);
XmlSchemaType originalType = (XmlSchemaType)schemaToUpdate.SchemaTypes[complexType.QualifiedName];
XmlSchema parentSchema = GetParentSchema(originalType);
if (originalType == null || (parentSchema != originalSchema && !includesOfRedefine.Contains(parentSchema)) ) {
SendValidationEvent(Res.Sch_ComponentRedefineNotFound, "<complexType>", complexType.QualifiedName.ToString(), complexType);
}
else if (originalType is XmlSchemaComplexType) {
complexType.Redefined = originalType;
schemaToUpdate.SchemaTypes.Insert(complexType.QualifiedName, complexType);
CheckRefinedComplexType(complexType);
}
else {
SendValidationEvent(Res.Sch_SimpleToComplexTypeRedefine, complexType);
}
}
}
else if (item is XmlSchemaSimpleType) {
XmlSchemaSimpleType simpleType = (XmlSchemaSimpleType)item;
PreprocessSimpleType(simpleType, false);
simpleType.QualifiedName.SetNamespace(targetNS); //Since PreprocessSimpleType will use this.targetNamespace and that will be that of the root schema's
if (redefine.SchemaTypes[simpleType.QualifiedName] != null) {
SendValidationEvent(Res.Sch_SimpleTypeDoubleRedefine, simpleType);
}
else {
AddToTable(redefine.SchemaTypes, simpleType.QualifiedName, simpleType);
XmlSchemaType originalType = (XmlSchemaType)schemaToUpdate.SchemaTypes[simpleType.QualifiedName];
XmlSchema parentSchema = GetParentSchema(originalType);
if (originalType == null || (parentSchema != originalSchema && !includesOfRedefine.Contains(parentSchema)) ) {
SendValidationEvent(Res.Sch_ComponentRedefineNotFound, "<simpleType>", simpleType.QualifiedName.ToString(), simpleType);
}
else if (originalType is XmlSchemaSimpleType) {
simpleType.Redefined = originalType;
schemaToUpdate.SchemaTypes.Insert(simpleType.QualifiedName, simpleType);
CheckRefinedSimpleType(simpleType);
}
else {
SendValidationEvent(Res.Sch_ComplexToSimpleTypeRedefine, simpleType);
}
}
}
}
}
