| private SetLineInfo ( IXmlLineInfo lineInfo ) : void | ||
| lineInfo | IXmlLineInfo | |
| return | void | |
internal ValidatingReaderNodeData RecordTextNode(string textValue, string originalStringValue, int depth, int lineNo, int linePos)
{
ValidatingReaderNodeData textNode = AddContent(XmlNodeType.Text);
textNode.SetItemData(textValue, originalStringValue);
textNode.SetLineInfo(lineNo, linePos);
textNode.Depth = depth;
return(textNode);
}
internal void RecordEndElementNode()
{
ValidatingReaderNodeData data = this.AddContent(XmlNodeType.EndElement);
data.SetItemData(this.coreReader.LocalName, this.coreReader.Prefix, this.coreReader.NamespaceURI, this.coreReader.Depth);
data.SetLineInfo(this.coreReader as IXmlLineInfo);
if (this.coreReader.IsEmptyElement)
{
this.readAhead = true;
}
}
internal void RecordEndElementNode()
{
ValidatingReaderNodeData recordedNode = AddContent(XmlNodeType.EndElement);
Debug.Assert(_coreReader.NodeType == XmlNodeType.EndElement || (_coreReader.NodeType == XmlNodeType.Element && _coreReader.IsEmptyElement));
recordedNode.SetItemData(_coreReader.LocalName, _coreReader.Prefix, _coreReader.NamespaceURI, _coreReader.Depth);
recordedNode.SetLineInfo(_coreReader as IXmlLineInfo);
if (_coreReader.IsEmptyElement)
{ //Simulated endElement node for <e/>, the coreReader is on cached Element node itself.
_readAhead = true;
}
}
private void RecordAttributes()
{
this.attributeCount = this.coreReader.AttributeCount;
if (this.coreReader.MoveToFirstAttribute())
{
int attIndex = 0;
do
{
ValidatingReaderNodeData data = this.AddAttribute(attIndex);
data.SetItemData(this.coreReader.LocalName, this.coreReader.Prefix, this.coreReader.NamespaceURI, this.coreReader.Depth);
data.SetLineInfo(this.lineInfo);
data.RawValue = this.coreReader.Value;
attIndex++;
}while (this.coreReader.MoveToNextAttribute());
this.coreReader.MoveToElement();
}
}
private void Init()
{
this.coreReaderNameTable = this.coreReader.NameTable;
this.cacheState = CachingReaderState.Init;
this.contentIndex = 0;
this.currentAttrIndex = -1;
this.currentContentIndex = -1;
this.attributeCount = 0;
this.cachedNode = null;
this.readAhead = false;
if (this.coreReader.NodeType == XmlNodeType.Element)
{
ValidatingReaderNodeData data = this.AddContent(this.coreReader.NodeType);
data.SetItemData(this.coreReader.LocalName, this.coreReader.Prefix, this.coreReader.NamespaceURI, this.coreReader.Depth);
data.SetLineInfo(this.lineInfo);
this.RecordAttributes();
}
}
private void Init()
{
_coreReaderNameTable = _coreReader.NameTable;
_cacheState = CachingReaderState.Init;
_contentIndex = 0;
_currentAttrIndex = -1;
_currentContentIndex = -1;
_attributeCount = 0;
_cachedNode = null;
_readAhead = false;
//Initialize the cachingReader with start state
if (_coreReader.NodeType == XmlNodeType.Element)
{
ValidatingReaderNodeData element = AddContent(_coreReader.NodeType);
element.SetItemData(_coreReader.LocalName, _coreReader.Prefix, _coreReader.NamespaceURI, _coreReader.Depth); //Only created for element node type
element.SetLineInfo(_lineInfo);
RecordAttributes();
}
}
// Reads the next node from the stream/TextReader.
public override bool Read()
{
switch (_cacheState)
{
case CachingReaderState.Init:
_cacheState = CachingReaderState.Record;
goto case CachingReaderState.Record;
case CachingReaderState.Record:
ValidatingReaderNodeData recordedNode = null;
if (_coreReader.Read())
{
switch (_coreReader.NodeType)
{
case XmlNodeType.Element:
//Dont record element within the content of a union type since the main reader will break on this and the underlying coreReader will be positioned on this node
_cacheState = CachingReaderState.ReaderClosed;
return(false);
case XmlNodeType.EndElement:
recordedNode = AddContent(_coreReader.NodeType);
recordedNode.SetItemData(_coreReader.LocalName, _coreReader.Prefix, _coreReader.NamespaceURI, _coreReader.Depth); //Only created for element node type
recordedNode.SetLineInfo(_lineInfo);
break;
case XmlNodeType.Comment:
case XmlNodeType.ProcessingInstruction:
case XmlNodeType.Text:
case XmlNodeType.CDATA:
case XmlNodeType.Whitespace:
case XmlNodeType.SignificantWhitespace:
recordedNode = AddContent(_coreReader.NodeType);
recordedNode.SetItemData(_coreReader.Value);
recordedNode.SetLineInfo(_lineInfo);
recordedNode.Depth = _coreReader.Depth;
break;
default:
break;
}
_cachedNode = recordedNode;
return(true);
}
else
{
_cacheState = CachingReaderState.ReaderClosed;
return(false);
}
case CachingReaderState.Replay:
if (_currentContentIndex >= _contentIndex)
{ //When positioned on the last cached node, switch back as the underlying coreReader is still positioned on this node
_cacheState = CachingReaderState.ReaderClosed;
_cacheHandler(this);
if (_coreReader.NodeType != XmlNodeType.Element || _readAhead)
{ //Only when coreReader not positioned on Element node, read ahead, otherwise it is on the next element node already, since this was not cached
return(_coreReader.Read());
}
return(true);
}
_cachedNode = _contentEvents[_currentContentIndex];
if (_currentContentIndex > 0)
{
ClearAttributesInfo();
}
_currentContentIndex++;
return(true);
default:
return(false);
}
}
public override bool Read()
{
switch (this.cacheState)
{
case CachingReaderState.Init:
this.cacheState = CachingReaderState.Record;
break;
case CachingReaderState.Record:
break;
case CachingReaderState.Replay:
if (this.currentContentIndex < this.contentIndex)
{
this.cachedNode = this.contentEvents[this.currentContentIndex];
if (this.currentContentIndex > 0)
{
this.ClearAttributesInfo();
}
this.currentContentIndex++;
return(true);
}
this.cacheState = CachingReaderState.ReaderClosed;
this.cacheHandler(this);
return(((this.coreReader.NodeType == XmlNodeType.Element) && !this.readAhead) || this.coreReader.Read());
default:
return(false);
}
ValidatingReaderNodeData data = null;
if (!this.coreReader.Read())
{
this.cacheState = CachingReaderState.ReaderClosed;
return(false);
}
switch (this.coreReader.NodeType)
{
case XmlNodeType.Element:
this.cacheState = CachingReaderState.ReaderClosed;
return(false);
case XmlNodeType.Text:
case XmlNodeType.CDATA:
case XmlNodeType.ProcessingInstruction:
case XmlNodeType.Comment:
case XmlNodeType.Whitespace:
case XmlNodeType.SignificantWhitespace:
data = this.AddContent(this.coreReader.NodeType);
data.SetItemData(this.coreReader.Value);
data.SetLineInfo(this.lineInfo);
data.Depth = this.coreReader.Depth;
break;
case XmlNodeType.EndElement:
data = this.AddContent(this.coreReader.NodeType);
data.SetItemData(this.coreReader.LocalName, this.coreReader.Prefix, this.coreReader.NamespaceURI, this.coreReader.Depth);
data.SetLineInfo(this.lineInfo);
break;
}
this.cachedNode = data;
return(true);
}