| private SetBlockResolved ( XmlSchemaDerivationMethod value ) : void | ||
| value | XmlSchemaDerivationMethod | |
| Résultat | void | |
private void PreprocessComplexType(XmlSchemaComplexType complexType, bool local)
{
if (local)
{
if (complexType.Name != null)
{
base.SendValidationEvent("Sch_ForbiddenAttribute", "name", complexType);
}
}
else
{
if (complexType.Name != null)
{
this.ValidateNameAttribute(complexType);
complexType.SetQualifiedName(new XmlQualifiedName(complexType.Name, this.targetNamespace));
}
else
{
base.SendValidationEvent("Sch_MissRequiredAttribute", "name", complexType);
}
if (complexType.Block == XmlSchemaDerivationMethod.All)
{
complexType.SetBlockResolved(XmlSchemaDerivationMethod.All);
}
else if (complexType.Block == XmlSchemaDerivationMethod.None)
{
complexType.SetBlockResolved(this.blockDefault & (XmlSchemaDerivationMethod.Restriction | XmlSchemaDerivationMethod.Extension));
}
else
{
if ((complexType.Block & ~(XmlSchemaDerivationMethod.Restriction | XmlSchemaDerivationMethod.Extension)) != XmlSchemaDerivationMethod.Empty)
{
base.SendValidationEvent("Sch_InvalidComplexTypeBlockValue", complexType);
}
complexType.SetBlockResolved(complexType.Block & (XmlSchemaDerivationMethod.Restriction | XmlSchemaDerivationMethod.Extension));
}
if (complexType.Final == XmlSchemaDerivationMethod.All)
{
complexType.SetFinalResolved(XmlSchemaDerivationMethod.All);
}
else if (complexType.Final == XmlSchemaDerivationMethod.None)
{
if (this.finalDefault == XmlSchemaDerivationMethod.All)
{
complexType.SetFinalResolved(XmlSchemaDerivationMethod.All);
}
else
{
complexType.SetFinalResolved(this.finalDefault & (XmlSchemaDerivationMethod.Restriction | XmlSchemaDerivationMethod.Extension));
}
}
else
{
if ((complexType.Final & ~(XmlSchemaDerivationMethod.Restriction | XmlSchemaDerivationMethod.Extension)) != XmlSchemaDerivationMethod.Empty)
{
base.SendValidationEvent("Sch_InvalidComplexTypeFinalValue", complexType);
}
complexType.SetFinalResolved(complexType.Final & (XmlSchemaDerivationMethod.Restriction | XmlSchemaDerivationMethod.Extension));
}
}
if (complexType.ContentModel != null)
{
this.SetParent(complexType.ContentModel, complexType);
this.PreprocessAnnotation(complexType.ContentModel);
if (complexType.Particle == null)
{
XmlSchemaObjectCollection attributes = complexType.Attributes;
}
if (complexType.ContentModel is XmlSchemaSimpleContent)
{
XmlSchemaSimpleContent contentModel = (XmlSchemaSimpleContent) complexType.ContentModel;
if (contentModel.Content == null)
{
if (complexType.QualifiedName == XmlQualifiedName.Empty)
{
base.SendValidationEvent("Sch_NoRestOrExt", complexType);
}
else
{
base.SendValidationEvent("Sch_NoRestOrExtQName", complexType.QualifiedName.Name, complexType.QualifiedName.Namespace, complexType);
}
}
else
{
this.SetParent(contentModel.Content, contentModel);
this.PreprocessAnnotation(contentModel.Content);
if (contentModel.Content is XmlSchemaSimpleContentExtension)
{
XmlSchemaSimpleContentExtension content = (XmlSchemaSimpleContentExtension) contentModel.Content;
if (content.BaseTypeName.IsEmpty)
{
base.SendValidationEvent("Sch_MissAttribute", "base", content);
}
else
{
this.ValidateQNameAttribute(content, "base", content.BaseTypeName);
}
this.PreprocessAttributes(content.Attributes, content.AnyAttribute, content);
this.ValidateIdAttribute(content);
}
else
{
XmlSchemaSimpleContentRestriction source = (XmlSchemaSimpleContentRestriction) contentModel.Content;
if (source.BaseTypeName.IsEmpty)
{
base.SendValidationEvent("Sch_MissAttribute", "base", source);
}
else
{
this.ValidateQNameAttribute(source, "base", source.BaseTypeName);
}
if (source.BaseType != null)
{
this.SetParent(source.BaseType, source);
this.PreprocessSimpleType(source.BaseType, true);
}
this.PreprocessAttributes(source.Attributes, source.AnyAttribute, source);
this.ValidateIdAttribute(source);
}
}
this.ValidateIdAttribute(contentModel);
}
else
{
XmlSchemaComplexContent parent = (XmlSchemaComplexContent) complexType.ContentModel;
if (parent.Content == null)
{
if (complexType.QualifiedName == XmlQualifiedName.Empty)
{
base.SendValidationEvent("Sch_NoRestOrExt", complexType);
}
else
{
base.SendValidationEvent("Sch_NoRestOrExtQName", complexType.QualifiedName.Name, complexType.QualifiedName.Namespace, complexType);
}
}
else
{
if (!parent.HasMixedAttribute && complexType.IsMixed)
{
parent.IsMixed = true;
}
this.SetParent(parent.Content, parent);
this.PreprocessAnnotation(parent.Content);
if (parent.Content is XmlSchemaComplexContentExtension)
{
XmlSchemaComplexContentExtension extension2 = (XmlSchemaComplexContentExtension) parent.Content;
if (extension2.BaseTypeName.IsEmpty)
{
base.SendValidationEvent("Sch_MissAttribute", "base", extension2);
}
else
{
this.ValidateQNameAttribute(extension2, "base", extension2.BaseTypeName);
}
if (extension2.Particle != null)
{
this.SetParent(extension2.Particle, extension2);
this.PreprocessParticle(extension2.Particle);
}
this.PreprocessAttributes(extension2.Attributes, extension2.AnyAttribute, extension2);
this.ValidateIdAttribute(extension2);
}
else
{
XmlSchemaComplexContentRestriction restriction2 = (XmlSchemaComplexContentRestriction) parent.Content;
if (restriction2.BaseTypeName.IsEmpty)
{
base.SendValidationEvent("Sch_MissAttribute", "base", restriction2);
}
else
{
this.ValidateQNameAttribute(restriction2, "base", restriction2.BaseTypeName);
}
if (restriction2.Particle != null)
{
this.SetParent(restriction2.Particle, restriction2);
this.PreprocessParticle(restriction2.Particle);
}
this.PreprocessAttributes(restriction2.Attributes, restriction2.AnyAttribute, restriction2);
this.ValidateIdAttribute(restriction2);
}
this.ValidateIdAttribute(parent);
}
}
}
else
{
if (complexType.Particle != null)
{
this.SetParent(complexType.Particle, complexType);
this.PreprocessParticle(complexType.Particle);
}
this.PreprocessAttributes(complexType.Attributes, complexType.AnyAttribute, complexType);
}
this.ValidateIdAttribute(complexType);
}
private void PreprocessComplexType(XmlSchemaComplexType complexType, bool local) {
if (local) {
if (complexType.Name != null) {
SendValidationEvent(Res.Sch_ForbiddenAttribute, "name", complexType);
}
}
else {
if (complexType.Name != null) {
ValidateNameAttribute(complexType);
complexType.SetQualifiedName(new XmlQualifiedName(complexType.Name, this.targetNamespace));
}
else {
SendValidationEvent(Res.Sch_MissRequiredAttribute, "name", complexType);
}
if (complexType.Block == XmlSchemaDerivationMethod.All) {
complexType.SetBlockResolved(XmlSchemaDerivationMethod.All);
}
else if (complexType.Block == XmlSchemaDerivationMethod.None) {
complexType.SetBlockResolved(this.blockDefault & complexTypeBlockAllowed);
}
else {
if ((complexType.Block & ~complexTypeBlockAllowed) != 0) {
SendValidationEvent(Res.Sch_InvalidComplexTypeBlockValue, complexType);
}
complexType.SetBlockResolved(complexType.Block & complexTypeBlockAllowed);
}
if (complexType.Final == XmlSchemaDerivationMethod.All) {
complexType.SetFinalResolved(XmlSchemaDerivationMethod.All);
}
else if (complexType.Final == XmlSchemaDerivationMethod.None) {
if (this.finalDefault == XmlSchemaDerivationMethod.All) {
complexType.SetFinalResolved(XmlSchemaDerivationMethod.All);
}
else {
complexType.SetFinalResolved(this.finalDefault & complexTypeFinalAllowed);
}
}
else {
if ((complexType.Final & ~complexTypeFinalAllowed) != 0) {
SendValidationEvent(Res.Sch_InvalidComplexTypeFinalValue, complexType);
}
complexType.SetFinalResolved(complexType.Final & complexTypeFinalAllowed);
}
}
if (complexType.ContentModel != null) {
SetParent(complexType.ContentModel, complexType); //SimpleContent / complexCotent
PreprocessAnnotation(complexType.ContentModel);
if (complexType.Particle != null || complexType.Attributes != null) {
// this is illigal
}
if (complexType.ContentModel is XmlSchemaSimpleContent) {
XmlSchemaSimpleContent content = (XmlSchemaSimpleContent)complexType.ContentModel;
if (content.Content == null) {
if (complexType.QualifiedName == XmlQualifiedName.Empty) {
SendValidationEvent(Res.Sch_NoRestOrExt, complexType);
}
else {
SendValidationEvent(Res.Sch_NoRestOrExtQName, complexType.QualifiedName.Name, complexType.QualifiedName.Namespace, complexType);
}
}
else {
SetParent(content.Content, content); //simplecontent extension / restriction
PreprocessAnnotation(content.Content); //annotation child of simple extension / restriction
if (content.Content is XmlSchemaSimpleContentExtension) {
XmlSchemaSimpleContentExtension contentExtension = (XmlSchemaSimpleContentExtension)content.Content;
if (contentExtension.BaseTypeName.IsEmpty) {
SendValidationEvent(Res.Sch_MissAttribute, "base", contentExtension);
}
else {
ValidateQNameAttribute(contentExtension, "base", contentExtension.BaseTypeName);
}
PreprocessAttributes(contentExtension.Attributes, contentExtension.AnyAttribute, contentExtension);
ValidateIdAttribute(contentExtension);
}
else { //XmlSchemaSimpleContentRestriction
XmlSchemaSimpleContentRestriction contentRestriction = (XmlSchemaSimpleContentRestriction)content.Content;
if (contentRestriction.BaseTypeName.IsEmpty) {
SendValidationEvent(Res.Sch_MissAttribute, "base", contentRestriction);
}
else {
ValidateQNameAttribute(contentRestriction, "base", contentRestriction.BaseTypeName);
}
if (contentRestriction.BaseType != null) {
SetParent(contentRestriction.BaseType, contentRestriction);
PreprocessSimpleType(contentRestriction.BaseType, true);
}
PreprocessAttributes(contentRestriction.Attributes, contentRestriction.AnyAttribute, contentRestriction);
ValidateIdAttribute(contentRestriction);
}
}
ValidateIdAttribute(content);
}
else { // XmlSchemaComplexContent
XmlSchemaComplexContent content = (XmlSchemaComplexContent)complexType.ContentModel;
if (content.Content == null) {
if (complexType.QualifiedName == XmlQualifiedName.Empty) {
SendValidationEvent(Res.Sch_NoRestOrExt, complexType);
}
else {
SendValidationEvent(Res.Sch_NoRestOrExtQName, complexType.QualifiedName.Name, complexType.QualifiedName.Namespace, complexType);
}
}
else {
if ( !content.HasMixedAttribute && complexType.IsMixed) {
content.IsMixed = true; // fixup
}
SetParent(content.Content, content); //complexcontent extension / restriction
PreprocessAnnotation(content.Content); //Annotation child of extension / restriction
if (content.Content is XmlSchemaComplexContentExtension) {
XmlSchemaComplexContentExtension contentExtension = (XmlSchemaComplexContentExtension)content.Content;
if (contentExtension.BaseTypeName.IsEmpty) {
SendValidationEvent(Res.Sch_MissAttribute, "base", contentExtension);
}
else {
ValidateQNameAttribute(contentExtension, "base", contentExtension.BaseTypeName);
}
if (contentExtension.Particle != null) {
SetParent(contentExtension.Particle, contentExtension); //Group / all / choice / sequence
PreprocessParticle(contentExtension.Particle);
}
PreprocessAttributes(contentExtension.Attributes, contentExtension.AnyAttribute, contentExtension);
ValidateIdAttribute(contentExtension);
}
else { // XmlSchemaComplexContentRestriction
XmlSchemaComplexContentRestriction contentRestriction = (XmlSchemaComplexContentRestriction)content.Content;
if (contentRestriction.BaseTypeName.IsEmpty) {
SendValidationEvent(Res.Sch_MissAttribute, "base", contentRestriction);
}
else {
ValidateQNameAttribute(contentRestriction, "base", contentRestriction.BaseTypeName);
}
if (contentRestriction.Particle != null) {
SetParent(contentRestriction.Particle, contentRestriction); //Group / all / choice / sequence
PreprocessParticle(contentRestriction.Particle);
}
PreprocessAttributes(contentRestriction.Attributes, contentRestriction.AnyAttribute, contentRestriction);
ValidateIdAttribute(contentRestriction);
}
ValidateIdAttribute(content);
}
}
}
else {
if (complexType.Particle != null) {
SetParent(complexType.Particle, complexType);
PreprocessParticle(complexType.Particle);
}
PreprocessAttributes(complexType.Attributes, complexType.AnyAttribute, complexType);
}
ValidateIdAttribute(complexType);
}
