Simplify Reading and Writing of XML Fragments

/* Copyright (c) 2006 notmasteryet */
using System;
using System.Xml;

namespace XmlChunk
{
    /// <summary>
    /// XmlChunkReader can be created using XmlReader while it�s reading 
    /// XML element node. It can be used as standalone XmlReader, e.g. 
    /// to perform deserialization operation. When XmlChunkReader is closed, 
    /// main reader points to next XML node. Using of XmlChunkReader 
    /// helps avoid such calls as ReadInnerXml.
    /// </summary>
    public class XmlChunkReader : XmlReader
    {
        private XmlReader baseReader;
        private int depth;
        private State state;
        private bool isRootElementEmpty;

        /// <summary>
        /// Cointains base reader
        /// </summary>
        public XmlReader BaseReader
        {
            get { return baseReader; }
        }

        /// <summary>
        /// Creates reader
        /// </summary>
        /// <param name="reader">Base reader</param>
        public XmlChunkReader(XmlReader reader)
        {
            if (reader == null)
                throw new ArgumentNullException("reader");
            if(reader.NodeType != XmlNodeType.Element)
                throw new ArgumentException(Properties.Resources.ReaderInvalidState, "reader");

            this.baseReader = reader;
            this.depth = baseReader.Depth;
            this.state = State.Idle;
        }

        public override int AttributeCount
        {
            get { return BaseReader.AttributeCount; }
        }

        public override string BaseURI
        {
            get { return BaseReader.BaseURI; }
        }

        public override void Close()
        {
            while (state != State.Completed) Skip();
        }

        public override int Depth
        {
            get { return BaseReader.Depth - depth; }
        }

        public override bool EOF
        {
            get { return state == State.Completed; }
        }

        public override string GetAttribute(int i)
        {
            return BaseReader.GetAttribute(i);
        }

        public override string GetAttribute(string name, string namespaceURI)
        {
            return BaseReader.GetAttribute(name, namespaceURI);
        }

        public override string GetAttribute(string name)
        {
            return BaseReader.GetAttribute(name);
        }

        public override bool HasValue
        {
            get { return BaseReader.HasValue; }
        }

        public override bool IsEmptyElement
        {
            get { return BaseReader.IsEmptyElement; }
        }

        public override string LocalName
        {
            get { return BaseReader.LocalName; }
        }

        public override string LookupNamespace(string prefix)
        {
            return BaseReader.LookupNamespace(prefix);
        }

        private bool ChangeStateIfTrue(bool check, State newState)
        {
            if (check) state = newState;
            return check;
        }

        public override bool MoveToAttribute(string name, string ns)
        {
            return ChangeStateIfTrue(BaseReader.MoveToAttribute(name, ns), State.OnAttribute);
        }

        public override bool MoveToAttribute(string name)
        {
            return ChangeStateIfTrue(BaseReader.MoveToAttribute(name), State.OnAttribute);
        }

        public override bool MoveToElement()
        {
            return ChangeStateIfTrue(BaseReader.MoveToElement(), State.InProcess);
        }

        public override bool MoveToFirstAttribute()
        {
            return ChangeStateIfTrue(BaseReader.MoveToFirstAttribute(), State.OnAttribute);
        }

        public override bool MoveToNextAttribute()
        {
            return BaseReader.MoveToNextAttribute();
        }

        public override XmlNameTable NameTable
        {
            get { return BaseReader.NameTable; }
        }

        public override string NamespaceURI
        {
            get { return BaseReader.NamespaceURI; }
        }

        public override XmlNodeType NodeType
        {
            get { return BaseReader.NodeType; }
        }

        public override string Prefix
        {
            get { return BaseReader.Prefix; }
        }

        public override bool Read()
        {
            switch (state)
            {
                case State.Idle:
                    state = State.InProcess;
                    isRootElementEmpty = BaseReader.IsEmptyElement;
                    return true;
                case State.OnAttribute:
                    return BaseReader.Read();
                case State.Completed:
                    return false;
                default:
                case State.InProcess:                    
                    if (BaseReader.Depth == depth &&
                        (isRootElementEmpty || BaseReader.NodeType == XmlNodeType.EndElement))
                    {
                        // reading last node of the "root" element
                        state = State.Completed;
                        BaseReader.Read();
                        return false;
                    }
                    else
                    {
                        // normal reading
                        bool moreData = BaseReader.Read();
                        if (!moreData) state = State.Completed;
                        return moreData;
                    }
            }
        }

        public override bool ReadAttributeValue()
        {
            return BaseReader.ReadAttributeValue();
        }

        public override ReadState ReadState
        {
            get 
            {
                switch (state)
                {
                    case State.Idle:
                        return ReadState.Initial;
                    case State.Completed:
                        return ReadState.EndOfFile;
                    default:
                    case State.InProcess:
                        return BaseReader.ReadState;
                }
            }
        }

        public override void ResolveEntity()
        {
            BaseReader.ResolveEntity();
        }

        public override string Value
        {
            get { return BaseReader.Value; }
        }

        private enum State
        {
            Idle,
            InProcess,
            OnAttribute,
            Completed
        }
    }
}