SetLineInfo() private method

private SetLineInfo ( IXmlLineInfo lineInfo ) : void
lineInfo IXmlLineInfo
return void
Beispiel #1
0
        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);
        }
Beispiel #2
0
        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;
            }
        }
Beispiel #3
0
        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;
            }
        }
Beispiel #4
0
 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();
     }
 }
Beispiel #5
0
 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();
     }
 }
Beispiel #6
0
 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();
     }
 }
Beispiel #7
0
        // 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);
            }
        }
Beispiel #8
0
        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);
        }