internal BuilderInfo Clone()
{
BuilderInfo info = new BuilderInfo();
info.Initialize(this);
Debug.Assert(info.NodeType != XmlNodeType.Text || XmlCharType.Instance.IsOnlyWhitespace(info.Value));
return info;
}
internal void Initialize(BuilderInfo src) {
this.prefix = src.Prefix;
this.localName = src.LocalName;
this.namespaceURI = src.NamespaceURI;
this.name = null;
this.depth = src.Depth;
this.nodeType = src.NodeType;
this.htmlProps = src.htmlProps;
this.htmlAttrProps = src.htmlAttrProps;
this.TextInfoCount = 0;
EnsureTextInfoSize(src.TextInfoCount);
src.TextInfo.CopyTo(this.TextInfo, 0);
this.TextInfoCount = src.TextInfoCount;
}
void WriteEndElement(RecordBuilder record)
{
BuilderInfo node = record.MainNode;
HtmlElementProps htmlProps = record.Manager.CurrentElementScope.HtmlElementProps;
if (htmlProps != null && htmlProps.Empty)
{
return;
}
Indent(record);
Write(s_LessThanSlash);
WriteName(record.MainNode.Prefix, record.MainNode.LocalName);
Write(s_GreaterThan);
}
internal void Initialize(BuilderInfo src)
{
this.prefix = src.Prefix;
this.localName = src.LocalName;
this.namespaceURI = src.NamespaceURI;
this.name = null;
this.depth = src.Depth;
this.nodeType = src.NodeType;
this.htmlProps = src.htmlProps;
this.htmlAttrProps = src.htmlAttrProps;
this.TextInfoCount = 0;
EnsureTextInfoSize(src.TextInfoCount);
src.TextInfo.CopyTo(this.TextInfo, 0);
this.TextInfoCount = src.TextInfoCount;
}
private void WriteProcessingInstruction(BuilderInfo node)
{
Write(s_LessThanQuestion);
WriteName(node.Prefix, node.LocalName);
Write(s_Space);
Write(node.Value);
if (_isHtmlOutput)
{
Write(s_GreaterThan);
}
else
{
Write(s_QuestionGreaterThan);
}
}
private void WriteTextNode(BuilderInfo node)
{
for (int i = 0; i < node.TextInfoCount; i++)
{
string?text = node.TextInfo[i];
if (text == null)
{ // disableEscaping marker
i++;
Debug.Assert(i < node.TextInfoCount, "disableEscaping marker can't be last TextInfo record");
Write(node.TextInfo[i]);
}
else
{
WriteWithReplace(text, s_TextValueFind, s_TextValueReplace);
}
}
}
private void OutputCachedRecords()
{
if (_outputCache == null)
{
return;
}
for (int record = 0; record < _outputCache.Count; record++)
{
Debug.Assert(_outputCache[record] is BuilderInfo);
BuilderInfo info = (BuilderInfo)_outputCache[record] !;
OutputRecord(info);
}
_outputCache = null;
}
private void ResetRecord(int state)
{
Debug.Assert(_recordState == NoRecord || _recordState == SomeRecord);
if ((state & StateMachine.BeginRecord) != 0)
{
_attributeCount = 0;
_namespaceCount = 0;
_currentInfo = _mainNode;
_currentInfo.Initialize(_atoms.Empty, _atoms.Empty, _atoms.Empty);
_currentInfo.NodeType = XmlNodeType.None;
_currentInfo.IsEmptyTag = false;
_currentInfo.htmlProps = null;
_currentInfo.htmlAttrProps = null;
}
}
private void FixupAttributes(int attributeCount)
{
for (int attr = 0; attr < attributeCount; attr++)
{
Debug.Assert(this.attributeList[attr] is BuilderInfo);
BuilderInfo info = (BuilderInfo)this.attributeList[attr];
if (Keywords.Equals(info.NamespaceURI, this.atoms.Empty))
{
info.Prefix = this.atoms.Empty;
}
else
{
if (Keywords.Equals(info.Prefix, this.atoms.Empty))
{
info.Prefix = GetPrefixForNamespace(info.NamespaceURI);
}
else
{
bool thisScope = false;
string nspace = this.scopeManager.ResolveNamespace(info.Prefix, out thisScope);
if (nspace != null)
{
if (!Keywords.Equals(info.NamespaceURI, nspace))
{
if (thisScope) // prefix conflict
{
info.Prefix = GetPrefixForNamespace(info.NamespaceURI);
}
else
{
DeclareNamespace(info.NamespaceURI, info.Prefix);
}
}
}
else
{
DeclareNamespace(info.NamespaceURI, info.Prefix);
}
}
}
}
}
private void FixupAttributes(int attributeCount)
{
for (int attr = 0; attr < attributeCount; attr++)
{
Debug.Assert(_attributeList[attr] is BuilderInfo);
BuilderInfo info = (BuilderInfo)_attributeList[attr] !;
if (Ref.Equal(info.NamespaceURI, _atoms.Empty))
{
info.Prefix = _atoms.Empty;
}
else
{
if (Ref.Equal(info.Prefix, _atoms.Empty))
{
info.Prefix = GetPrefixForNamespace(info.NamespaceURI);
}
else
{
bool thisScope = false;
string?nspace = _scopeManager.ResolveNamespace(info.Prefix, out thisScope);
if (nspace != null)
{
if (!Ref.Equal(info.NamespaceURI, nspace))
{
if (thisScope)
{ // prefix conflict
info.Prefix = GetPrefixForNamespace(info.NamespaceURI);
}
else
{
DeclareNamespace(info.NamespaceURI, info.Prefix);
}
}
}
else
{
DeclareNamespace(info.NamespaceURI, info.Prefix);
}
}
}
}
}
//
// RecordOutput interface method implementation
//
public Processor.OutputResult RecordDone(RecordBuilder record)
{
BuilderInfo mainNode = record.MainNode;
switch (mainNode.NodeType)
{
case XmlNodeType.Text:
case XmlNodeType.Whitespace:
case XmlNodeType.SignificantWhitespace:
_writer.Write(mainNode.Value);
break;
default:
break;
}
record.Reset();
return(Processor.OutputResult.Continue);
}
private void BeginNamespace(string name, string nspace)
{
bool thisScope = false;
if (Ref.Equal(name, _atoms.Empty))
{
if (Ref.Equal(nspace, _scopeManager.DefaultNamespace))
{
// Main Node is OK
}
else if (Ref.Equal(_mainNode.NamespaceURI, _atoms.Empty))
{
// http://www.w3.org/1999/11/REC-xslt-19991116-errata/ E25
// Should throw an error but ingnoring it in Everett.
// Would be a breaking change
}
else
{
DeclareNamespace(nspace, name);
}
}
else
{
string nspaceDeclared = _scopeManager.ResolveNamespace(name, out thisScope);
if (nspaceDeclared != null)
{
if (!Ref.Equal(nspace, nspaceDeclared))
{
if (!thisScope)
{
DeclareNamespace(nspace, name);
}
}
}
else
{
DeclareNamespace(nspace, name);
}
}
_currentInfo = _dummy;
_currentInfo.NodeType = XmlNodeType.Attribute;
}
private void BeginAttribute(string prefix, string name, string nspace, object?htmlAttrProps, bool search)
{
int attrib = FindAttribute(name, nspace, ref prefix);
if (attrib == -1)
{
attrib = NewAttribute();
}
Debug.Assert(_attributeList[attrib] != null && _attributeList[attrib] is BuilderInfo);
BuilderInfo attribute = (BuilderInfo)_attributeList[attrib] !;
attribute.Initialize(prefix, name, nspace);
attribute.Depth = _recordDepth;
attribute.NodeType = XmlNodeType.Attribute;
attribute.htmlAttrProps = htmlAttrProps as HtmlAttributeProps;
attribute.search = search;
_currentInfo = attribute;
}
private void WriteTextNode(RecordBuilder record)
{
BuilderInfo mainNode = record.MainNode;
OutputScope scope = record.Manager.CurrentElementScope;
scope.Mixed = true;
if (scope.HtmlElementProps != null && scope.HtmlElementProps.NoEntities)
{
// script or stile
Write(mainNode.Value);
}
else if (scope.ToCData)
{
WriteCDataSection(mainNode.Value);
}
else
{
WriteTextNode(mainNode);
}
}
private void BeginNamespace(string name, string nspace)
{
bool thisScope = false;
if (Keywords.Equals(name, this.atoms.Empty))
{
if (Keywords.Equals(nspace, this.scopeManager.DefaultNamespace))
{
// Main Node is OK
}
else if (Keywords.Equals(this.mainNode.NamespaceURI, this.atoms.Empty))
{
}
else
{
DeclareNamespace(nspace, name);
}
}
else
{
string nspaceDeclared = this.scopeManager.ResolveNamespace(name, out thisScope);
if (nspaceDeclared != null)
{
if (!Keywords.Equals(nspace, nspaceDeclared))
{
if (!thisScope)
{
DeclareNamespace(nspace, name);
}
}
}
else
{
DeclareNamespace(nspace, name);
}
}
this.currentInfo = dummy;
currentInfo.NodeType = XmlNodeType.Attribute;
}
private void DeclareNamespace(string nspace, string prefix)
{
int index = NewNamespace();
Debug.Assert(_namespaceList[index] != null && _namespaceList[index] is BuilderInfo);
BuilderInfo ns = (BuilderInfo)_namespaceList[index] !;
if (prefix == _atoms.Empty)
{
ns.Initialize(_atoms.Empty, _atoms.Xmlns, _atoms.XmlnsNamespace);
}
else
{
ns.Initialize(_atoms.Xmlns, prefix, _atoms.XmlnsNamespace);
}
ns.Depth = _recordDepth;
ns.NodeType = XmlNodeType.Attribute;
ns.Value = nspace;
_scopeManager.PushNamespace(prefix, nspace);
}
private bool FindAttribute(String name, out int attrIndex)
{
if (name == null)
{
name = string.Empty;
}
for (int index = 0; index < this.attributeCount; index++)
{
Debug.Assert(this.attributeList[index] is BuilderInfo);
BuilderInfo attribute = (BuilderInfo)this.attributeList[index];
if (attribute.Name == name)
{
attrIndex = index;
return(true);
}
}
attrIndex = -1;
return(false);
}
public override bool ReadAttributeValue()
{
if (ReadState != ReadState.Interactive || NodeType != XmlNodeType.Attribute)
{
return(false);
}
if (this.attributeValue == null)
{
this.attributeValue = new BuilderInfo();
this.attributeValue.NodeType = XmlNodeType.Text;
}
if (this.currentInfo == this.attributeValue)
{
return(false);
}
this.attributeValue.Value = this.currentInfo.Value;
this.attributeValue.Depth = this.currentInfo.Depth + 1;
this.currentInfo = this.attributeValue;
return(true);
}
private void AnalyzeSpaceLang()
{
Debug.Assert(_mainNode.NodeType == XmlNodeType.Element);
for (int attr = 0; attr < _attributeCount; attr++)
{
Debug.Assert(_attributeList[attr] is BuilderInfo);
BuilderInfo info = (BuilderInfo)_attributeList[attr] !;
if (Ref.Equal(info.Prefix, _atoms.Xml))
{
OutputScope scope = _scopeManager.CurrentElementScope;
if (Ref.Equal(info.LocalName, _atoms.Lang))
{
scope.Lang = info.Value;
}
else if (Ref.Equal(info.LocalName, _atoms.Space))
{
scope.Space = TranslateXmlSpace(info.Value);
}
}
}
}
//
// Implementation internals
//
private void SetMainNode()
{
_currentIndex = -1;
_currentInfo = _mainNode;
}
//
// Particular outputs
//
private void WriteStartElement(RecordBuilder record)
{
Debug.Assert(record.MainNode.NodeType == XmlNodeType.Element);
BuilderInfo mainNode = record.MainNode;
HtmlElementProps?htmlProps = null;
if (_isHtmlOutput)
{
if (mainNode.Prefix.Length == 0)
{
htmlProps = mainNode.htmlProps;
if (htmlProps == null && mainNode.search)
{
htmlProps = HtmlElementProps.GetProps(mainNode.LocalName);
}
record.Manager.CurrentElementScope.HtmlElementProps = htmlProps;
mainNode.IsEmptyTag = false;
}
}
else if (_isXmlOutput)
{
if (mainNode.Depth == 0)
{
if (
_secondRoot && (
_output.DoctypeSystem != null ||
_output.Standalone
)
)
{
throw XsltException.Create(SR.Xslt_MultipleRoots);
}
_secondRoot = true;
}
}
if (_outputDoctype)
{
WriteDoctype(mainNode);
_outputDoctype = false;
}
if (_cdataElements != null && _cdataElements.Contains(new XmlQualifiedName(mainNode.LocalName, mainNode.NamespaceURI)) && _isXmlOutput)
{
record.Manager.CurrentElementScope.ToCData = true;
}
Indent(record);
Write(s_LessThan);
WriteName(mainNode.Prefix, mainNode.LocalName);
WriteAttributes(record.AttributeList, record.AttributeCount, htmlProps);
if (mainNode.IsEmptyTag)
{
Debug.Assert(!_isHtmlOutput || mainNode.Prefix != null, "Html can't have abbreviated elements");
Write(s_SlashGreaterThan);
}
else
{
Write(s_GreaterThan);
}
if (htmlProps != null && htmlProps.Head)
{
mainNode.Depth++;
Indent(record);
mainNode.Depth--;
Write("<META http-equiv=\"Content-Type\" content=\"");
Write(_output.MediaType);
Write("; charset=");
Write(this.encoding !.WebName);
Write("\">");
}
}
private void SetAttribute(int attrib)
{
Debug.Assert(0 <= attrib && attrib < _attributeCount);
Debug.Assert(0 <= attrib && attrib < _attributeList.Count);
Debug.Assert(_attributeList[attrib] is BuilderInfo);
_currentIndex = attrib;
_currentInfo = (BuilderInfo)_attributeList[attrib];
}
private void Reset()
{
_currentIndex = -1;
_currentInfo = s_DefaultInfo;
_mainNode = s_DefaultInfo;
_manager = null;
}
void WriteDoctype(BuilderInfo mainNode) {
Debug.Assert(this.outputDoctype == true, "It supposed to check this condition before actual call");
Debug.Assert(this.output.DoctypeSystem != null || (this.isHtmlOutput && this.output.DoctypePublic != null), "We set outputDoctype == true only if");
Indent(0);
Write(s_DocType);
if (this.isXmlOutput) {
WriteName(mainNode.Prefix, mainNode.LocalName);
}
else {
WriteName(string.Empty, "html");
}
Write(s_Space);
if (output.DoctypePublic != null) {
Write(s_Public);
Write(s_Quote);
Write(output.DoctypePublic);
Write(s_QuoteSpace);
}
else {
Write(s_System);
}
if (output.DoctypeSystem != null) {
Write(s_Quote);
Write(output.DoctypeSystem);
Write(s_Quote);
}
Write(s_GreaterThan);
}
void WriteProcessingInstruction(BuilderInfo node) {
Write(s_LessThanQuestion);
WriteName(node.Prefix, node.LocalName);
Write(s_Space);
Write(node.Value);
if(this.isHtmlOutput) {
Write(s_GreaterThan);
}
else {
Write(s_QuestionGreaterThan);
}
}
private void SetAttribute(int attrib) {
Debug.Assert(0 <= attrib && attrib < this.attributeCount);
Debug.Assert(0 <= attrib && attrib < this.attributeList.Count);
Debug.Assert(this.attributeList[attrib] is BuilderInfo);
this.currentIndex = attrib;
this.currentInfo = (BuilderInfo) this.attributeList[attrib];
}
//
// Implementation internals
//
private void SetMainNode() {
this.currentIndex = -1;
this.currentInfo = this.mainNode;
}
//
// Implementation internals
//
private void SetMainNode()
{
_currentIndex = -1;
_currentInfo = _mainNode;
}
public override string GetAttribute(int i)
{
BuilderInfo attribute = GetBuilderInfo(i);
return(attribute.Value);
}
private void BeginNamespace(string name, string nspace) {
bool thisScope = false;
if (Keywords.Equals(name, this.atoms.Empty)) {
if (Keywords.Equals(nspace, this.scopeManager.DefaultNamespace)) {
// Main Node is OK
}
else if (Keywords.Equals(this.mainNode.NamespaceURI, this.atoms.Empty)) {
}
else {
DeclareNamespace(nspace, name);
}
}
else {
string nspaceDeclared = this.scopeManager.ResolveNamespace(name, out thisScope);
if (nspaceDeclared != null) {
if (! Keywords.Equals(nspace, nspaceDeclared)) {
if(!thisScope) {
DeclareNamespace(nspace, name);
}
}
}
else {
DeclareNamespace(nspace, name);
}
}
this.currentInfo = dummy;
currentInfo.NodeType = XmlNodeType.Attribute;
}
private void OutputRecord(BuilderInfo node) {
if(this.outputXmlDecl) {
WriteXmlDeclaration();
}
Indent(0); // we can have only top level stuff here
switch (node.NodeType) {
case XmlNodeType.Element:
Debug.Fail("Should never get here");
break;
case XmlNodeType.Text:
case XmlNodeType.Whitespace:
case XmlNodeType.SignificantWhitespace:
WriteTextNode(node);
break;
case XmlNodeType.CDATA:
Debug.Fail("Should never get here");
break;
case XmlNodeType.EntityReference:
Write(s_Ampersand);
WriteName(node.Prefix, node.LocalName);
Write(s_Semicolon);
break;
case XmlNodeType.ProcessingInstruction:
WriteProcessingInstruction(node);
break;
case XmlNodeType.Comment:
Write(s_CommentBegin);
Write(node.Value);
Write(s_CommentEnd);
break;
case XmlNodeType.Document:
break;
case XmlNodeType.DocumentType:
Write(node.Value);
break;
case XmlNodeType.EndElement:
Debug.Fail("Should never get here");
break;
default:
break;
}
}
private bool DecideDefaultOutput(BuilderInfo node) {
XsltOutput.OutputMethod method = XsltOutput.OutputMethod.Xml;
switch (node.NodeType) {
case XmlNodeType.Element:
if (node.NamespaceURI.Length == 0 && String.Compare("html", node.LocalName, StringComparison.OrdinalIgnoreCase) == 0) {
method = XsltOutput.OutputMethod.Html;
}
break;
case XmlNodeType.Text:
case XmlNodeType.Whitespace:
case XmlNodeType.SignificantWhitespace:
if (xmlCharType.IsOnlyWhitespace(node.Value)) {
return false;
}
method = XsltOutput.OutputMethod.Xml;
break;
default :
return false;
}
if(this.processor.SetDefaultOutput(method)) {
CacheOuptutProps(processor.Output);
}
return true;
}
private void Reset() {
this.currentIndex = -1;
this.currentInfo = s_DefaultInfo;
this.mainNode = s_DefaultInfo;
this.manager = null;
}
public Processor.OutputResult RecordDone(RecordBuilder record)
{
Debug.Assert(record != null);
BuilderInfo mainNode = record.MainNode;
_documentIndex++;
switch (mainNode.NodeType)
{
case XmlNodeType.Element:
{
_wr.WriteStartElement(mainNode.Prefix, mainNode.LocalName, mainNode.NamespaceURI);
for (int attrib = 0; attrib < record.AttributeCount; attrib++)
{
_documentIndex++;
Debug.Assert(record.AttributeList[attrib] is BuilderInfo);
BuilderInfo attrInfo = (BuilderInfo)record.AttributeList[attrib] !;
if (attrInfo.NamespaceURI == XmlReservedNs.NsXmlNs)
{
if (attrInfo.Prefix.Length == 0)
{
_wr.WriteNamespaceDeclaration(string.Empty, attrInfo.Value);
}
else
{
_wr.WriteNamespaceDeclaration(attrInfo.LocalName, attrInfo.Value);
}
}
else
{
_wr.WriteAttributeString(attrInfo.Prefix, attrInfo.LocalName, attrInfo.NamespaceURI, attrInfo.Value);
}
}
_wr.StartElementContent();
if (mainNode.IsEmptyTag)
{
_wr.WriteEndElement(mainNode.Prefix, mainNode.LocalName, mainNode.NamespaceURI);
}
break;
}
case XmlNodeType.Text:
_wr.WriteString(mainNode.Value);
break;
case XmlNodeType.Whitespace:
break;
case XmlNodeType.SignificantWhitespace:
_wr.WriteString(mainNode.Value);
break;
case XmlNodeType.ProcessingInstruction:
_wr.WriteProcessingInstruction(mainNode.LocalName, mainNode.Value);
break;
case XmlNodeType.Comment:
_wr.WriteComment(mainNode.Value);
break;
case XmlNodeType.Document:
break;
case XmlNodeType.EndElement:
_wr.WriteEndElement(mainNode.Prefix, mainNode.LocalName, mainNode.NamespaceURI);
break;
default:
Debug.Fail($"Invalid NodeType on output: {mainNode.NodeType}");
break;
}
record.Reset();
return(Processor.OutputResult.Continue);
}
private void BeginAttribute(string prefix, string name, string nspace, Object htmlAttrProps, bool search) {
int attrib = FindAttribute(name, nspace, ref prefix);
if (attrib == -1) {
attrib = NewAttribute();
}
Debug.Assert(this.attributeList[attrib] != null && this.attributeList[attrib] is BuilderInfo);
BuilderInfo attribute = (BuilderInfo) this.attributeList[attrib];
attribute.Initialize(prefix, name, nspace);
attribute.Depth = this.recordDepth;
attribute.NodeType = XmlNodeType.Attribute;
attribute.htmlAttrProps = htmlAttrProps as HtmlAttributeProps;
attribute.search = search;
this.currentInfo = attribute;
}
void WriteTextNode(BuilderInfo node) {
for (int i = 0; i < node.TextInfoCount; i ++) {
string text = node.TextInfo[i];
if (text == null) { // disableEscaping marker
i++;
Debug.Assert(i < node.TextInfoCount, "disableEscaping marker can't be last TextInfo record");
Write(node.TextInfo[i]);
} else {
WriteWithReplace(text, s_TextValueFind, s_TextValueReplace);
}
}
}
private void BeginNamespace(string name, string nspace) {
bool thisScope = false;
if (Ref.Equal(name, this.atoms.Empty)) {
if (Ref.Equal(nspace, this.scopeManager.DefaultNamespace)) {
// Main Node is OK
}
else if (Ref.Equal(this.mainNode.NamespaceURI, this.atoms.Empty)) {
// http://www.w3.org/1999/11/REC-xslt-19991116-errata/ E25
// Should throw an error but ingnoring it in Everett.
// Would be a breaking change
}
else {
DeclareNamespace(nspace, name);
}
}
else {
string nspaceDeclared = this.scopeManager.ResolveNamespace(name, out thisScope);
if (nspaceDeclared != null) {
if (! Ref.Equal(nspace, nspaceDeclared)) {
if(!thisScope) {
DeclareNamespace(nspace, name);
}
}
}
else {
DeclareNamespace(nspace, name);
}
}
this.currentInfo = dummy;
currentInfo.NodeType = XmlNodeType.Attribute;
}
private void ResetRecord(int state) {
Debug.Assert(this.recordState == NoRecord || this.recordState == SomeRecord);
if ((state & StateMachine.BeginRecord) != 0) {
this.attributeCount = 0;
this.namespaceCount = 0;
this.currentInfo = this.mainNode;
this.currentInfo.Initialize(this.atoms.Empty, this.atoms.Empty, this.atoms.Empty);
this.currentInfo.NodeType = XmlNodeType.None;
this.currentInfo.IsEmptyTag = false;
this.currentInfo.htmlProps = null;
this.currentInfo.htmlAttrProps = null;
}
}
// RecordOutput interface method implementation
//
public Processor.OutputResult RecordDone(RecordBuilder record)
{
BuilderInfo mainNode = record.MainNode;
switch (mainNode.NodeType)
{
case XmlNodeType.Element:
_writer.WriteStartElement(mainNode.Prefix, mainNode.LocalName, mainNode.NamespaceURI);
WriteAttributes(record.AttributeList, record.AttributeCount);
if (mainNode.IsEmptyTag)
{
_writer.WriteEndElement();
}
break;
case XmlNodeType.Text:
case XmlNodeType.Whitespace:
case XmlNodeType.SignificantWhitespace:
_writer.WriteString(mainNode.Value);
break;
case XmlNodeType.CDATA:
Debug.Fail("XSLT never gives us CDATA");
_writer.WriteCData(mainNode.Value);
break;
case XmlNodeType.EntityReference:
_writer.WriteEntityRef(mainNode.LocalName);
break;
case XmlNodeType.ProcessingInstruction:
_writer.WriteProcessingInstruction(mainNode.LocalName, mainNode.Value);
break;
case XmlNodeType.Comment:
_writer.WriteComment(mainNode.Value);
break;
case XmlNodeType.Document:
break;
case XmlNodeType.DocumentType:
_writer.WriteRaw(mainNode.Value);
break;
case XmlNodeType.EndElement:
_writer.WriteFullEndElement();
break;
case XmlNodeType.None:
case XmlNodeType.Attribute:
case XmlNodeType.Entity:
case XmlNodeType.Notation:
case XmlNodeType.DocumentFragment:
case XmlNodeType.EndEntity:
break;
default:
Debug.Fail("Invalid NodeType on output: " + mainNode.NodeType);
break;
}
record.Reset();
return(Processor.OutputResult.Continue);
}
public override bool ReadAttributeValue() {
if (ReadState != ReadState.Interactive || NodeType != XmlNodeType.Attribute) {
return false;
}
if (this.attributeValue == null) {
this.attributeValue = new BuilderInfo();
this.attributeValue.NodeType = XmlNodeType.Text;
}
if (this.currentInfo == this.attributeValue) {
return false;
}
this.attributeValue.Value = this.currentInfo.Value;
this.attributeValue.Depth = this.currentInfo.Depth + 1;
this.currentInfo = this.attributeValue;
return true;
}
//
// Implementation internals
//
private void SetMainNode()
{
this.currentIndex = -1;
this.currentInfo = this.mainNode;
}
//
// RecordOutput interface method implementation
//
public Processor.OutputResult RecordDone(RecordBuilder record) {
this.builder = record;
this.mainNode = record.MainNode;
this.attributeList = record.AttributeList;
this.attributeCount = record.AttributeCount;
this.manager = record.Manager;
this.haveRecord = true;
SetMainNode();
return Processor.OutputResult.Interrupt;
}
public override bool ReadAttributeValue()
{
if (ReadState != ReadState.Interactive || NodeType != XmlNodeType.Attribute)
{
return false;
}
if (_attributeValue == null)
{
_attributeValue = new BuilderInfo();
_attributeValue.NodeType = XmlNodeType.Text;
}
if (_currentInfo == _attributeValue)
{
return false;
}
_attributeValue.Value = _currentInfo.Value;
_attributeValue.Depth = _currentInfo.Depth + 1;
_currentInfo = _attributeValue;
return true;
}
