BaseProcessor.cs source code in C# .NET

Source code for the .NET framework in C#

                        

Code:

/ DotNET / DotNET / 8.0 / untmp / whidbey / REDBITS / ndp / fx / src / Xml / System / Xml / schema / BaseProcessor.cs / 2 / BaseProcessor.cs

                            //------------------------------------------------------------------------------ 
// 
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// 
// [....] 
//-----------------------------------------------------------------------------
 
namespace System.Xml.Schema { 

    using System.Collections; 
    using System.Text;
    using System.Diagnostics;

    internal class BaseProcessor { 
        XmlNameTable nameTable;
        SchemaNames schemaNames; 
        ValidationEventHandler eventHandler; 
        XmlSchemaCompilationSettings compilationSettings;
        int errorCount = 0; 
        string NsXml;

        public BaseProcessor(XmlNameTable nameTable, SchemaNames schemaNames, ValidationEventHandler eventHandler)
            : this(nameTable, schemaNames, eventHandler, new XmlSchemaCompilationSettings()) {} //Use the default for XmlSchemaCollection 

        public BaseProcessor(XmlNameTable nameTable, SchemaNames schemaNames, ValidationEventHandler eventHandler, XmlSchemaCompilationSettings compilationSettings) { 
            Debug.Assert(nameTable != null); 
            this.nameTable = nameTable;
            this.schemaNames = schemaNames; 
            this.eventHandler = eventHandler;
            this.compilationSettings = compilationSettings;
            NsXml = nameTable.Add(XmlReservedNs.NsXml);
        } 

        protected XmlNameTable NameTable { 
            get { return nameTable; } 
        }
 
        protected SchemaNames SchemaNames {
            get {
                if (schemaNames == null) {
                    schemaNames = new SchemaNames(nameTable); 
                }
                return schemaNames; 
            } 
        }
 
        protected ValidationEventHandler EventHandler {
            get { return eventHandler; }
        }
 
        protected XmlSchemaCompilationSettings CompilationSettings {
            get { return compilationSettings; } 
        } 

        protected bool HasErrors { 
            get { return errorCount != 0; }
        }

        protected void AddToTable(XmlSchemaObjectTable table, XmlQualifiedName qname, XmlSchemaObject item) { 
            if (qname.Name.Length == 0) {
                return; 
            } 
            XmlSchemaObject existingObject = (XmlSchemaObject)table[qname];
 
            if (existingObject != null) {
                if (existingObject == item) {
                    return;
                } 
                string code = Res.Sch_DupGlobalElement;
                if (item is XmlSchemaAttributeGroup) { 
                    string ns = nameTable.Add(qname.Namespace); 
                    if (Ref.Equal(ns, NsXml)) { //Check for xml namespace
                        XmlSchema schemaForXmlNS = Preprocessor.GetBuildInSchema(); 
                        XmlSchemaObject builtInAttributeGroup = schemaForXmlNS.AttributeGroups[qname];
                        if ((object)existingObject == (object)builtInAttributeGroup) {
                            table.Insert(qname, item);
                            return; 
                        }
                        else if ((object)item == (object)builtInAttributeGroup) { //trying to overwrite customer's component with built-in, ignore built-in 
                            return; 
                        }
                    } 
                    else if (IsValidAttributeGroupRedefine(existingObject, item, table)){ //check for redefines
                        return;
                    }
                    code = Res.Sch_DupAttributeGroup; 
                }
                else if (item is XmlSchemaAttribute) { 
                    string ns = nameTable.Add(qname.Namespace); 
                    if (Ref.Equal(ns, NsXml)) {
                        XmlSchema schemaForXmlNS = Preprocessor.GetBuildInSchema(); 
                        XmlSchemaObject builtInAttribute = schemaForXmlNS.Attributes[qname];
                        if ((object)existingObject == (object)builtInAttribute) { //replace built-in one
                            table.Insert(qname, item);
                            return; 
                        }
                        else if ((object)item == (object)builtInAttribute) { //trying to overwrite customer's component with built-in, ignore built-in 
                            return; 
                        }
                    } 
                    code = Res.Sch_DupGlobalAttribute;
                }
                else if (item is XmlSchemaSimpleType) {
                    if (IsValidTypeRedefine(existingObject, item, table)) { 
                        return;
                    } 
                    code = Res.Sch_DupSimpleType; 
                }
                else if (item is XmlSchemaComplexType) { 
                    if (IsValidTypeRedefine(existingObject, item, table)) {
                        return;
                    }
                    code = Res.Sch_DupComplexType; 
                }
                else if (item is XmlSchemaGroup) { 
                    if (IsValidGroupRedefine(existingObject, item, table)){ //check for redefines 
                        return;
                    } 
                    code = Res.Sch_DupGroup;
                }
                else if (item is XmlSchemaNotation) {
                    code = Res.Sch_DupNotation; 
                }
                else if (item is XmlSchemaIdentityConstraint) { 
                    code = Res.Sch_DupIdentityConstraint; 
                }
                else { 
                    Debug.Assert(item is XmlSchemaElement);
                }
                SendValidationEvent(code, qname.ToString(), item);
            } 
            else {
                table.Add(qname, item); 
            } 
        }
 
        private bool IsValidAttributeGroupRedefine(XmlSchemaObject existingObject, XmlSchemaObject item, XmlSchemaObjectTable table) {
            XmlSchemaAttributeGroup attGroup = item as XmlSchemaAttributeGroup;
            XmlSchemaAttributeGroup existingAttGroup = existingObject as XmlSchemaAttributeGroup;
            if (existingAttGroup == attGroup.Redefined) { //attribute group is the redefinition of existingObject 
                if (existingAttGroup.AttributeUses.Count == 0) { //If the existing one is not already compiled, then replace.
                    table.Insert(attGroup.QualifiedName, attGroup); //Update with redefined entry			 
                    return true; 
                }
            } 
            else if (existingAttGroup.Redefined == attGroup) { //Redefined type already exists in the set, original type is added after redefined type, ignore the original type
 		return true;
            }
            return false; 
        }
 
        private bool IsValidGroupRedefine(XmlSchemaObject existingObject, XmlSchemaObject item, XmlSchemaObjectTable table) { 
            XmlSchemaGroup group = item as XmlSchemaGroup;
            XmlSchemaGroup existingGroup = existingObject as XmlSchemaGroup; 
            if (existingGroup == group.Redefined) { //group is the redefinition of existingObject
                if (existingGroup.CanonicalParticle == null) { //If the existing one is not already compiled, then replace.
                    table.Insert(group.QualifiedName, group); //Update with redefined entry			
                    return true; 
                }
            } 
            else if (existingGroup.Redefined == group) { //Redefined type already exists in the set, original type is added after redefined type, ignore the original type 
		return true;
            } 
            return false;
        }

        private bool IsValidTypeRedefine(XmlSchemaObject existingObject, XmlSchemaObject item, XmlSchemaObjectTable table) { 
            XmlSchemaType schemaType = item as XmlSchemaType;
            XmlSchemaType existingType = existingObject as XmlSchemaType; 
            if (existingType == schemaType.Redefined) { //schemaType is the redefinition of existingObject 
                if (existingType.ElementDecl == null) { //If the existing one is not already compiled, then replace.
                    table.Insert(schemaType.QualifiedName, schemaType); //Update with redefined entry			 
                    return true;
                }
            }
            else if (existingType.Redefined == schemaType) { //Redefined type already exists in the set, original type is added after redefined type, ignore the original type 
		return true;
            } 
            return false; 
        }
 
        protected void SendValidationEvent(string code, XmlSchemaObject source) {
            SendValidationEvent(new XmlSchemaException(code, source), XmlSeverityType.Error);
        }
 
        protected void SendValidationEvent(string code, string msg, XmlSchemaObject source) {
            SendValidationEvent(new XmlSchemaException(code, msg, source), XmlSeverityType.Error); 
        } 

        protected void SendValidationEvent(string code, string msg1, string msg2, XmlSchemaObject source) { 
            SendValidationEvent(new XmlSchemaException(code, new string[] { msg1, msg2 }, source), XmlSeverityType.Error);
        }

        protected void SendValidationEvent(string code, string[] args, Exception innerException, XmlSchemaObject source) { 
            SendValidationEvent(new XmlSchemaException(code, args, innerException, source.SourceUri, source.LineNumber, source.LinePosition, source), XmlSeverityType.Error);
        } 
 
        protected void SendValidationEvent(string code, string msg1, string msg2, string sourceUri, int lineNumber, int linePosition) {
            SendValidationEvent(new XmlSchemaException(code, new string[] { msg1, msg2 }, sourceUri, lineNumber, linePosition), XmlSeverityType.Error); 
        }

        protected void SendValidationEvent(string code, XmlSchemaObject source, XmlSeverityType severity) {
            SendValidationEvent(new XmlSchemaException(code, source), severity); 
        }
 
        protected void SendValidationEvent(XmlSchemaException e) { 
            SendValidationEvent(e, XmlSeverityType.Error);
        } 

        protected void SendValidationEvent(string code, string msg, XmlSchemaObject source, XmlSeverityType severity) {
            SendValidationEvent(new XmlSchemaException(code, msg, source), severity);
        } 

        protected void SendValidationEvent(XmlSchemaException e, XmlSeverityType severity) { 
            if (severity == XmlSeverityType.Error) { 
                errorCount ++;
            } 
            if (eventHandler != null) {
                eventHandler(null, new ValidationEventArgs(e, severity));
            }
            else if (severity == XmlSeverityType.Error) { 
                throw e;
            } 
        } 

        protected void SendValidationEventNoThrow(XmlSchemaException e, XmlSeverityType severity) { 
            if (severity == XmlSeverityType.Error) {
                errorCount ++;
            }
            if (eventHandler != null) { 
                eventHandler(null, new ValidationEventArgs(e, severity));
            } 
        } 
    };
 
} // namespace System.Xml

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
                        

Link Menu

Network programming in C#, Network Programming in VB.NET, Network Programming in .NET
This book is available now!
Buy at Amazon US or
Buy at Amazon UK