Code:
/ Dotnetfx_Vista_SP2 / Dotnetfx_Vista_SP2 / 8.0.50727.4016 / DEVDIV / depot / DevDiv / releases / whidbey / NetFxQFE / ndp / fx / src / Xml / System / Xml / schema / BaseProcessor.cs / 1 / 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.
//
// [....]
//-----------------------------------------------------------------------------
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.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- AuthenticationConfig.cs
- Util.cs
- TextServicesDisplayAttributePropertyRanges.cs
- FunctionDefinition.cs
- Activator.cs
- Models.cs
- SvcMapFile.cs
- ControlPager.cs
- DataGridTextBoxColumn.cs
- ResourceAttributes.cs
- DetailsView.cs
- KnownTypesProvider.cs
- SimpleMailWebEventProvider.cs
- WindowHideOrCloseTracker.cs
- CompiledRegexRunner.cs
- SqlStream.cs
- XmlWrappingWriter.cs
- LogArchiveSnapshot.cs
- EntityCollection.cs
- BaseCodeDomTreeGenerator.cs
- DocumentViewerBaseAutomationPeer.cs
- EncryptedType.cs
- SafeFindHandle.cs
- SessionStateSection.cs
- Deserializer.cs
- ConnectionPoint.cs
- DataGridTable.cs
- TdsParserHelperClasses.cs
- DataBindingCollection.cs
- VSDExceptions.cs
- ZoneButton.cs
- Help.cs
- ExpressionBuilderCollection.cs
- DelegateBodyWriter.cs
- DriveInfo.cs
- InputScopeConverter.cs
- SendActivity.cs
- CalendarDay.cs
- TrackingStringDictionary.cs
- sqlinternaltransaction.cs
- StreamSecurityUpgradeInitiator.cs
- InkPresenterAutomationPeer.cs
- SettingsPropertyValueCollection.cs
- StrongNameMembershipCondition.cs
- TraceSection.cs
- ListViewGroupConverter.cs
- AttachedPropertyMethodSelector.cs
- QuadraticBezierSegment.cs
- CaretElement.cs
- XamlDesignerSerializationManager.cs
- Int16.cs
- XmlNamespaceMapping.cs
- Vars.cs
- RadioButton.cs
- HatchBrush.cs
- hwndwrapper.cs
- TypedColumnHandler.cs
- Vector.cs
- AsyncOperation.cs
- AttributeParameterInfo.cs
- MdImport.cs
- LineBreakRecord.cs
- DataTablePropertyDescriptor.cs
- ParseHttpDate.cs
- ZoneIdentityPermission.cs
- SafeFreeMibTable.cs
- AppDomainProtocolHandler.cs
- DateTimeSerializationSection.cs
- CodeTypeReferenceCollection.cs
- PropertyItem.cs
- hwndwrapper.cs
- DSACryptoServiceProvider.cs
- DetailsViewInsertedEventArgs.cs
- SpellerError.cs
- Environment.cs
- InputLanguageCollection.cs
- JsonByteArrayDataContract.cs
- FloaterParaClient.cs
- WebPartConnectionsCloseVerb.cs
- DebuggerAttributes.cs
- DataServiceSaveChangesEventArgs.cs
- CopyCodeAction.cs
- System.Data.OracleClient_BID.cs
- TextDecorationCollection.cs
- CompilerGeneratedAttribute.cs
- StateWorkerRequest.cs
- RuleElement.cs
- QueryExpression.cs
- Utils.cs
- SimpleBitVector32.cs
- SortedList.cs
- SafeLibraryHandle.cs
- XXXInfos.cs
- GridViewRowPresenterBase.cs
- GiveFeedbackEventArgs.cs
- ObjectAnimationUsingKeyFrames.cs
- DelegatedStream.cs
- Line.cs
- HttpStreamMessage.cs
- RegexGroup.cs