SqlXmlTextReader.cs :  » 2.6.4-mono-.net-core » System.Data » System » Data » SqlClient » C# / CSharp Open Source

//
// System.Data.SqlClient.SqlXmlTextReader.cs
//
// Author:
//   Konstantin Triger (kostat@mainsoft.com)
//
// Copyright (C) 2006 Mainsoft, corp. (http://www.mainsoft.com)
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
// 
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
// 
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//

using System;
using System.IO;
using System.Text;
using System.Xml;

namespace System.Data.SqlClient{
  internal sealed class SqlXmlTextReader : TextReader {

    #region FragmentXmlTextReader

    sealed class FragmentXmlTextReader : XmlTextReader {
      public FragmentXmlTextReader(System.IO.TextReader reader) : base(reader) {}

      public override bool Read() {
        do {
          if (!base.Read())
            return false;
        }while(base.Depth == 0);

        return true;
      }

      public override int Depth {
        get {
          int depth = base.Depth;
          if (depth >= 1)
            depth --;

          return depth;
        }
      }
    }

    #endregion

    #region Fields

    bool _hasPeekedChar;
    readonly char[] _peekedChar = new char[1];
    readonly SqlDataReader _reader;

    string _data;
    int _rootPosition;
    int _position = -1;
    bool _eof;

    static readonly char[] OpenRoot = new char[] {'<', 'X', '>'};
    const int OpenRootLength = 3;
    static readonly char[] CloseRoot = new char[] {'<', '/', 'X', '>'};
    const int CloseRootLength = 4;

    #endregion // Fields

    #region Constructors

    private SqlXmlTextReader (SqlDataReader reader) {
      _reader = reader;
    }

    #endregion

    #region Methods

    public static XmlReader Create(SqlDataReader dataReader) {
      return new FragmentXmlTextReader(new SqlXmlTextReader(dataReader));
    }

    public override void Close() {
      _reader.Close ();  
    }

    public override int Peek () {
      if (!_hasPeekedChar) {

        int consumed = Read(_peekedChar, 0, 1);
        if (consumed < 0)
          return -1;

        _hasPeekedChar = true;
      }

      return _peekedChar[0];
    }
      
    public override int Read () {
      int c = Peek();
      _hasPeekedChar = false;
      return c;
    }  

    public override int Read (char[] buffer, int index, int count) {
      if (buffer == null)
        throw new ArgumentNullException("buffer");

      if (index < 0)
        throw new ArgumentOutOfRangeException("index");

      if (count < 0)
        throw new ArgumentOutOfRangeException("count");

      if (count == 0)
        return 0;

      int got = 0;

      if (_hasPeekedChar) {
        buffer[index++] = _peekedChar[0];
        count--;
        _hasPeekedChar = false;
        got ++;
      }

      if (!_eof) {
        while (count > 0) {

          if (_rootPosition < OpenRootLength) {
            buffer[index++] = OpenRoot[_rootPosition++];
            count --;
            got ++;
            continue;
          }

          if (_position < 0) {
            if (_reader.Read()) {
              _position = 0;
              _data = _reader.GetString(0);
            }
            else {
              if(_reader.NextResult())
                continue;
              else {
                _rootPosition = 0;
                _eof = true;
                break;
              }
            }
          }

          int consumed = ((_position + count) > _data.Length) ? (_data.Length - (int)_position) : count;
          _data.CopyTo(_position, buffer, index, consumed);
            
          if (consumed > 0) {
            _position += consumed;
            got += consumed;
            index += consumed;
            count -= consumed;
          }
          else
            _position = -1;
        }
      }

      while (count > 0 && _rootPosition < CloseRootLength) {
        buffer[index++] = CloseRoot[_rootPosition++];
        count --;
        got ++;
      }


      return got;
    }

    #endregion // Methods
  }
}