File: System\Xml\XmlBinaryReader.cs
Project: ndp\cdf\src\WCF\Serialization\System.Runtime.Serialization.csproj (System.Runtime.Serialization)
//------------------------------------------------------------
// Copyright (c) Microsoft Corporation.  All rights reserved.
//------------------------------------------------------------
namespace System.Xml
{
    using System;
    using System.IO;
    using System.Runtime;
    using System.Runtime.Serialization;
    using System.Security;
 
    public interface IXmlBinaryReaderInitializer
    {
        void SetInput(byte[] buffer, int offset, int count,
                            IXmlDictionary dictionary,
                            XmlDictionaryReaderQuotas quotas,
                            XmlBinaryReaderSession session,
                            OnXmlDictionaryReaderClose onClose);
        void SetInput(Stream stream,
                             IXmlDictionary dictionary,
                             XmlDictionaryReaderQuotas quotas,
                             XmlBinaryReaderSession session,
                             OnXmlDictionaryReaderClose onClose);
    }
 
    class XmlBinaryReader : XmlBaseReader, IXmlBinaryReaderInitializer
    {
        bool isTextWithEndElement;
        bool buffered;
        ArrayState arrayState;
        int arrayCount;
        int maxBytesPerRead;
        XmlBinaryNodeType arrayNodeType;
        OnXmlDictionaryReaderClose onClose;
 
        public XmlBinaryReader()
        {
        }
 
        public void SetInput(byte[] buffer, int offset, int count,
                            IXmlDictionary dictionary,
                            XmlDictionaryReaderQuotas quotas,
                            XmlBinaryReaderSession session,
                            OnXmlDictionaryReaderClose onClose)
        {
            if (buffer == null)
                throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("buffer");
            if (offset < 0)
                throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("offset", SR.GetString(SR.ValueMustBeNonNegative)));
            if (offset > buffer.Length)
                throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("offset", SR.GetString(SR.OffsetExceedsBufferSize, buffer.Length)));
            if (count < 0)
                throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("count", SR.GetString(SR.ValueMustBeNonNegative)));
            if (count > buffer.Length - offset)
                throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("count", SR.GetString(SR.SizeExceedsRemainingBufferSpace, buffer.Length - offset)));
            MoveToInitial(quotas, session, onClose);
            BufferReader.SetBuffer(buffer, offset, count, dictionary, session);
            this.buffered = true;
        }
 
        public void SetInput(Stream stream,
                             IXmlDictionary dictionary,
                             XmlDictionaryReaderQuotas quotas,
                             XmlBinaryReaderSession session,
                             OnXmlDictionaryReaderClose onClose)
        {
            if (stream == null)
                throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("stream");
            MoveToInitial(quotas, session, onClose);
            BufferReader.SetBuffer(stream, dictionary, session);
            this.buffered = false;
        }
 
        void MoveToInitial(XmlDictionaryReaderQuotas quotas, XmlBinaryReaderSession session, OnXmlDictionaryReaderClose onClose)
        {
            MoveToInitial(quotas);
            this.maxBytesPerRead = quotas.MaxBytesPerRead;
            this.arrayState = ArrayState.None;
            this.onClose = onClose;
            this.isTextWithEndElement = false;
        }
 
        public override void Close()
        {
            base.Close();
            OnXmlDictionaryReaderClose onClose = this.onClose;
            this.onClose = null;
            if (onClose != null)
            {
                try
                {
                    onClose(this);
                }
                catch (Exception e)
                {
                    if (Fx.IsFatal(e)) throw;
 
                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperCallback(e);
                }
            }
        }
 
        public override string ReadElementContentAsString()
        {
            if (this.Node.NodeType != XmlNodeType.Element)
                MoveToStartElement();
            if (!CanOptimizeReadElementContent())
                return base.ReadElementContentAsString();
            string value;
            switch (GetNodeType())
            {
                case XmlBinaryNodeType.Chars8TextWithEndElement:
                    SkipNodeType();
                    value = BufferReader.ReadUTF8String(ReadUInt8());
                    ReadTextWithEndElement();
                    break;
                case XmlBinaryNodeType.DictionaryTextWithEndElement:
                    SkipNodeType();
                    value = BufferReader.GetDictionaryString(ReadDictionaryKey()).Value;
                    ReadTextWithEndElement();
                    break;
                default:
                    value = base.ReadElementContentAsString();
                    break;
            }
            if (value.Length > Quotas.MaxStringContentLength)
                XmlExceptionHelper.ThrowMaxStringContentLengthExceeded(this, Quotas.MaxStringContentLength);
            return value;
        }
 
        public override bool ReadElementContentAsBoolean()
        {
            if (this.Node.NodeType != XmlNodeType.Element)
                MoveToStartElement();
            if (!CanOptimizeReadElementContent())
                return base.ReadElementContentAsBoolean();
            bool value;
            switch (GetNodeType())
            {
                case XmlBinaryNodeType.TrueTextWithEndElement:
                    SkipNodeType();
                    value = true;
                    ReadTextWithEndElement();
                    break;
                case XmlBinaryNodeType.FalseTextWithEndElement:
                    SkipNodeType();
                    value = false;
                    ReadTextWithEndElement();
                    break;
                case XmlBinaryNodeType.BoolTextWithEndElement:
                    SkipNodeType();
                    value = (BufferReader.ReadUInt8() != 0);
                    ReadTextWithEndElement();
                    break;
                default:
                    value = base.ReadElementContentAsBoolean();
                    break;
            }
            return value;
        }
 
        public override int ReadElementContentAsInt()
        {
            if (this.Node.NodeType != XmlNodeType.Element)
                MoveToStartElement();
            if (!CanOptimizeReadElementContent())
                return base.ReadElementContentAsInt();
            int value;
            switch (GetNodeType())
            {
                case XmlBinaryNodeType.ZeroTextWithEndElement:
                    SkipNodeType();
                    value = 0;
                    ReadTextWithEndElement();
                    break;
                case XmlBinaryNodeType.OneTextWithEndElement:
                    SkipNodeType();
                    value = 1;
                    ReadTextWithEndElement();
                    break;
                case XmlBinaryNodeType.Int8TextWithEndElement:
                    SkipNodeType();
                    value = BufferReader.ReadInt8();
                    ReadTextWithEndElement();
                    break;
                case XmlBinaryNodeType.Int16TextWithEndElement:
                    SkipNodeType();
                    value = BufferReader.ReadInt16();
                    ReadTextWithEndElement();
                    break;
                case XmlBinaryNodeType.Int32TextWithEndElement:
                    SkipNodeType();
                    value = BufferReader.ReadInt32();
                    ReadTextWithEndElement();
                    break;
                default:
                    value = base.ReadElementContentAsInt();
                    break;
            }
            return value;
        }
 
        bool CanOptimizeReadElementContent()
        {
            return (arrayState == ArrayState.None && !Signing);
        }
 
        public override float ReadElementContentAsFloat()
        {
            if (this.Node.NodeType != XmlNodeType.Element)
                MoveToStartElement();
            if (CanOptimizeReadElementContent() && GetNodeType() == XmlBinaryNodeType.FloatTextWithEndElement)
            {
                SkipNodeType();
                float value = BufferReader.ReadSingle();
                ReadTextWithEndElement();
                return value;
            }
            return base.ReadElementContentAsFloat();
        }
 
        public override double ReadElementContentAsDouble()
        {
            if (this.Node.NodeType != XmlNodeType.Element)
                MoveToStartElement();
            if (CanOptimizeReadElementContent() && GetNodeType() == XmlBinaryNodeType.DoubleTextWithEndElement)
            {
                SkipNodeType();
                double value = BufferReader.ReadDouble();
                ReadTextWithEndElement();
                return value;
            }
            return base.ReadElementContentAsDouble();
        }
 
        public override decimal ReadElementContentAsDecimal()
        {
            if (this.Node.NodeType != XmlNodeType.Element)
                MoveToStartElement();
            if (CanOptimizeReadElementContent() && GetNodeType() == XmlBinaryNodeType.DecimalTextWithEndElement)
            {
                SkipNodeType();
                decimal value = BufferReader.ReadDecimal();
                ReadTextWithEndElement();
                return value;
            }
            return base.ReadElementContentAsDecimal();
        }
 
        public override DateTime ReadElementContentAsDateTime()
        {
            if (this.Node.NodeType != XmlNodeType.Element)
                MoveToStartElement();
            if (CanOptimizeReadElementContent() && GetNodeType() == XmlBinaryNodeType.DateTimeTextWithEndElement)
            {
                SkipNodeType();
                DateTime value = BufferReader.ReadDateTime();
                ReadTextWithEndElement();
                return value;
            }
            return base.ReadElementContentAsDateTime();
        }
 
        public override TimeSpan ReadElementContentAsTimeSpan()
        {
            if (this.Node.NodeType != XmlNodeType.Element)
                MoveToStartElement();
            if (CanOptimizeReadElementContent() && GetNodeType() == XmlBinaryNodeType.TimeSpanTextWithEndElement)
            {
                SkipNodeType();
                TimeSpan value = BufferReader.ReadTimeSpan();
                ReadTextWithEndElement();
                return value;
            }
            return base.ReadElementContentAsTimeSpan();
        }
 
        public override Guid ReadElementContentAsGuid()
        {
            if (this.Node.NodeType != XmlNodeType.Element)
                MoveToStartElement();
            if (CanOptimizeReadElementContent() && GetNodeType() == XmlBinaryNodeType.GuidTextWithEndElement)
            {
                SkipNodeType();
                Guid value = BufferReader.ReadGuid();
                ReadTextWithEndElement();
                return value;
            }
            return base.ReadElementContentAsGuid();
        }
 
        public override UniqueId ReadElementContentAsUniqueId()
        {
            if (this.Node.NodeType != XmlNodeType.Element)
                MoveToStartElement();
            if (CanOptimizeReadElementContent() && GetNodeType() == XmlBinaryNodeType.UniqueIdTextWithEndElement)
            {
                SkipNodeType();
                UniqueId value = BufferReader.ReadUniqueId();
                ReadTextWithEndElement();
                return value;
            }
            return base.ReadElementContentAsUniqueId();
        }
 
        public override bool TryGetBase64ContentLength(out int length)
        {
            length = 0;
            if (!buffered)
                return false;
            if (arrayState != ArrayState.None)
                return false;
            int totalLength;
            if (!this.Node.Value.TryGetByteArrayLength(out totalLength))
                return false;
            int offset = BufferReader.Offset;
            try
            {
                bool done = false;
                while (!done && !BufferReader.EndOfFile)
                {
                    XmlBinaryNodeType nodeType = GetNodeType();
                    SkipNodeType();
                    int actual;
                    switch (nodeType)
                    {
                        case XmlBinaryNodeType.Bytes8TextWithEndElement:
                            actual = BufferReader.ReadUInt8();
                            done = true;
                            break;
                        case XmlBinaryNodeType.Bytes16TextWithEndElement:
                            actual = BufferReader.ReadUInt16();
                            done = true;
                            break;
                        case XmlBinaryNodeType.Bytes32TextWithEndElement:
                            actual = BufferReader.ReadUInt31();
                            done = true;
                            break;
                        case XmlBinaryNodeType.EndElement:
                            actual = 0;
                            done = true;
                            break;
                        case XmlBinaryNodeType.Bytes8Text:
                            actual = BufferReader.ReadUInt8();
                            break;
                        case XmlBinaryNodeType.Bytes16Text:
                            actual = BufferReader.ReadUInt16();
                            break;
                        case XmlBinaryNodeType.Bytes32Text:
                            actual = BufferReader.ReadUInt31();
                            break;
                        default:
                            // Non-optimal or unexpected node - fallback
                            return false;
                    }
                    BufferReader.Advance(actual);
                    if (totalLength > int.MaxValue - actual)
                        return false;
                    totalLength += actual;
                }
                length = totalLength;
                return true;
            }
            finally
            {
                BufferReader.Offset = offset;
            }
        }
 
        void ReadTextWithEndElement()
        {
            ExitScope();
            ReadNode();
        }
 
        XmlAtomicTextNode MoveToAtomicTextWithEndElement()
        {
            isTextWithEndElement = true;
            return MoveToAtomicText();
        }
 
        public override bool Read()
        {
            if (this.Node.ReadState == ReadState.Closed)
                return false;
            SignNode();
            if (isTextWithEndElement)
            {
                isTextWithEndElement = false;
                MoveToEndElement();
                return true;
            }
            if (arrayState == ArrayState.Content)
            {
                if (arrayCount != 0)
                {
                    MoveToArrayElement();
                    return true;
                }
                arrayState = ArrayState.None;
            }
            if (this.Node.ExitScope)
            {
                ExitScope();
            }
            return ReadNode();
        }
 
        bool ReadNode()
        {
            if (!buffered)
                BufferReader.SetWindow(ElementNode.BufferOffset, this.maxBytesPerRead);
 
            if (BufferReader.EndOfFile)
            {
                MoveToEndOfFile();
                return false;
            }
 
 
            XmlBinaryNodeType nodeType;
            if (arrayState == ArrayState.None)
            {
                nodeType = GetNodeType();
                SkipNodeType();
            }
            else
            {
                Fx.Assert(arrayState == ArrayState.Element, "");
                nodeType = arrayNodeType;
                arrayCount--;
                arrayState = ArrayState.Content;
            }
 
            XmlElementNode elementNode;
            PrefixHandleType prefix;
            switch (nodeType)
            {
                case XmlBinaryNodeType.ShortElement:
                    elementNode = EnterScope();
                    elementNode.Prefix.SetValue(PrefixHandleType.Empty);
                    ReadName(elementNode.LocalName);
                    ReadAttributes();
                    elementNode.Namespace = LookupNamespace(PrefixHandleType.Empty);
                    elementNode.BufferOffset = BufferReader.Offset;
                    return true;
                case XmlBinaryNodeType.Element:
                    elementNode = EnterScope();
                    ReadName(elementNode.Prefix);
                    ReadName(elementNode.LocalName);
                    ReadAttributes();
                    elementNode.Namespace = LookupNamespace(elementNode.Prefix);
                    elementNode.BufferOffset = BufferReader.Offset;
                    return true;
                case XmlBinaryNodeType.ShortDictionaryElement:
                    elementNode = EnterScope();
                    elementNode.Prefix.SetValue(PrefixHandleType.Empty);
                    ReadDictionaryName(elementNode.LocalName);
                    ReadAttributes();
                    elementNode.Namespace = LookupNamespace(PrefixHandleType.Empty);
                    elementNode.BufferOffset = BufferReader.Offset;
                    return true;
                case XmlBinaryNodeType.DictionaryElement:
                    elementNode = EnterScope();
                    ReadName(elementNode.Prefix);
                    ReadDictionaryName(elementNode.LocalName);
                    ReadAttributes();
                    elementNode.Namespace = LookupNamespace(elementNode.Prefix);
                    elementNode.BufferOffset = BufferReader.Offset;
                    return true;
                case XmlBinaryNodeType.PrefixElementA:
                case XmlBinaryNodeType.PrefixElementB:
                case XmlBinaryNodeType.PrefixElementC:
                case XmlBinaryNodeType.PrefixElementD:
                case XmlBinaryNodeType.PrefixElementE:
                case XmlBinaryNodeType.PrefixElementF:
                case XmlBinaryNodeType.PrefixElementG:
                case XmlBinaryNodeType.PrefixElementH:
                case XmlBinaryNodeType.PrefixElementI:
                case XmlBinaryNodeType.PrefixElementJ:
                case XmlBinaryNodeType.PrefixElementK:
                case XmlBinaryNodeType.PrefixElementL:
                case XmlBinaryNodeType.PrefixElementM:
                case XmlBinaryNodeType.PrefixElementN:
                case XmlBinaryNodeType.PrefixElementO:
                case XmlBinaryNodeType.PrefixElementP:
                case XmlBinaryNodeType.PrefixElementQ:
                case XmlBinaryNodeType.PrefixElementR:
                case XmlBinaryNodeType.PrefixElementS:
                case XmlBinaryNodeType.PrefixElementT:
                case XmlBinaryNodeType.PrefixElementU:
                case XmlBinaryNodeType.PrefixElementV:
                case XmlBinaryNodeType.PrefixElementW:
                case XmlBinaryNodeType.PrefixElementX:
                case XmlBinaryNodeType.PrefixElementY:
                case XmlBinaryNodeType.PrefixElementZ:
                    elementNode = EnterScope();
                    prefix = PrefixHandle.GetAlphaPrefix((int)nodeType - (int)XmlBinaryNodeType.PrefixElementA);
                    elementNode.Prefix.SetValue(prefix);
                    ReadName(elementNode.LocalName);
                    ReadAttributes();
                    elementNode.Namespace = LookupNamespace(prefix);
                    elementNode.BufferOffset = BufferReader.Offset;
                    return true;
                case XmlBinaryNodeType.PrefixDictionaryElementA:
                case XmlBinaryNodeType.PrefixDictionaryElementB:
                case XmlBinaryNodeType.PrefixDictionaryElementC:
                case XmlBinaryNodeType.PrefixDictionaryElementD:
                case XmlBinaryNodeType.PrefixDictionaryElementE:
                case XmlBinaryNodeType.PrefixDictionaryElementF:
                case XmlBinaryNodeType.PrefixDictionaryElementG:
                case XmlBinaryNodeType.PrefixDictionaryElementH:
                case XmlBinaryNodeType.PrefixDictionaryElementI:
                case XmlBinaryNodeType.PrefixDictionaryElementJ:
                case XmlBinaryNodeType.PrefixDictionaryElementK:
                case XmlBinaryNodeType.PrefixDictionaryElementL:
                case XmlBinaryNodeType.PrefixDictionaryElementM:
                case XmlBinaryNodeType.PrefixDictionaryElementN:
                case XmlBinaryNodeType.PrefixDictionaryElementO:
                case XmlBinaryNodeType.PrefixDictionaryElementP:
                case XmlBinaryNodeType.PrefixDictionaryElementQ:
                case XmlBinaryNodeType.PrefixDictionaryElementR:
                case XmlBinaryNodeType.PrefixDictionaryElementS:
                case XmlBinaryNodeType.PrefixDictionaryElementT:
                case XmlBinaryNodeType.PrefixDictionaryElementU:
                case XmlBinaryNodeType.PrefixDictionaryElementV:
                case XmlBinaryNodeType.PrefixDictionaryElementW:
                case XmlBinaryNodeType.PrefixDictionaryElementX:
                case XmlBinaryNodeType.PrefixDictionaryElementY:
                case XmlBinaryNodeType.PrefixDictionaryElementZ:
                    elementNode = EnterScope();
                    prefix = PrefixHandle.GetAlphaPrefix((int)nodeType - (int)XmlBinaryNodeType.PrefixDictionaryElementA);
                    elementNode.Prefix.SetValue(prefix);
                    ReadDictionaryName(elementNode.LocalName);
                    ReadAttributes();
                    elementNode.Namespace = LookupNamespace(prefix);
                    elementNode.BufferOffset = BufferReader.Offset;
                    return true;
                case XmlBinaryNodeType.EndElement:
                    MoveToEndElement();
                    return true;
                case XmlBinaryNodeType.Comment:
                    ReadName(MoveToComment().Value);
                    return true;
                case XmlBinaryNodeType.EmptyTextWithEndElement:
                    MoveToAtomicTextWithEndElement().Value.SetValue(ValueHandleType.Empty);
                    if (this.OutsideRootElement)
                        VerifyWhitespace();
                    return true;
                case XmlBinaryNodeType.ZeroTextWithEndElement:
                    MoveToAtomicTextWithEndElement().Value.SetValue(ValueHandleType.Zero);
                    if (this.OutsideRootElement)
                        VerifyWhitespace();
                    return true;
                case XmlBinaryNodeType.OneTextWithEndElement:
                    MoveToAtomicTextWithEndElement().Value.SetValue(ValueHandleType.One);
                    if (this.OutsideRootElement)
                        VerifyWhitespace();
                    return true;
                case XmlBinaryNodeType.TrueTextWithEndElement:
                    MoveToAtomicTextWithEndElement().Value.SetValue(ValueHandleType.True);
                    if (this.OutsideRootElement)
                        VerifyWhitespace();
                    return true;
                case XmlBinaryNodeType.FalseTextWithEndElement:
                    MoveToAtomicTextWithEndElement().Value.SetValue(ValueHandleType.False);
                    if (this.OutsideRootElement)
                        VerifyWhitespace();
                    return true;
                case XmlBinaryNodeType.BoolTextWithEndElement:
                    MoveToAtomicTextWithEndElement().Value.SetValue(ReadUInt8() != 0 ? ValueHandleType.True : ValueHandleType.False);
                    if (this.OutsideRootElement)
                        VerifyWhitespace();
                    return true;
                case XmlBinaryNodeType.Chars8TextWithEndElement:
                    if (buffered)
                        ReadText(MoveToAtomicTextWithEndElement(), ValueHandleType.UTF8, ReadUInt8());
                    else
                        ReadPartialUTF8Text(true, ReadUInt8());
                    return true;
                case XmlBinaryNodeType.Chars8Text:
                    if (buffered)
                        ReadText(MoveToComplexText(), ValueHandleType.UTF8, ReadUInt8());
                    else
                        ReadPartialUTF8Text(false, ReadUInt8());
                    return true;
                case XmlBinaryNodeType.Chars16TextWithEndElement:
                    if (buffered)
                        ReadText(MoveToAtomicTextWithEndElement(), ValueHandleType.UTF8, ReadUInt16());
                    else
                        ReadPartialUTF8Text(true, ReadUInt16());
                    return true;
                case XmlBinaryNodeType.Chars16Text:
                    if (buffered)
                        ReadText(MoveToComplexText(), ValueHandleType.UTF8, ReadUInt16());
                    else
                        ReadPartialUTF8Text(false, ReadUInt16());
                    return true;
                case XmlBinaryNodeType.Chars32TextWithEndElement:
                    if (buffered)
                        ReadText(MoveToAtomicTextWithEndElement(), ValueHandleType.UTF8, ReadUInt31());
                    else
                        ReadPartialUTF8Text(true, ReadUInt31());
                    return true;
                case XmlBinaryNodeType.Chars32Text:
                    if (buffered)
                        ReadText(MoveToComplexText(), ValueHandleType.UTF8, ReadUInt31());
                    else
                        ReadPartialUTF8Text(false, ReadUInt31());
                    return true;
                case XmlBinaryNodeType.UnicodeChars8TextWithEndElement:
                    ReadUnicodeText(true, ReadUInt8());
                    return true;
                case XmlBinaryNodeType.UnicodeChars8Text:
                    ReadUnicodeText(false, ReadUInt8());
                    return true;
                case XmlBinaryNodeType.UnicodeChars16TextWithEndElement:
                    ReadUnicodeText(true, ReadUInt16());
                    return true;
                case XmlBinaryNodeType.UnicodeChars16Text:
                    ReadUnicodeText(false, ReadUInt16());
                    return true;
                case XmlBinaryNodeType.UnicodeChars32TextWithEndElement:
                    ReadUnicodeText(true, ReadUInt31());
                    return true;
                case XmlBinaryNodeType.UnicodeChars32Text:
                    ReadUnicodeText(false, ReadUInt31());
                    return true;
                case XmlBinaryNodeType.Bytes8TextWithEndElement:
                    if (buffered)
                        ReadBinaryText(MoveToAtomicTextWithEndElement(), ReadUInt8());
                    else
                        ReadPartialBinaryText(true, ReadUInt8());
                    return true;
                case XmlBinaryNodeType.Bytes8Text:
                    if (buffered)
                        ReadBinaryText(MoveToComplexText(), ReadUInt8());
                    else
                        ReadPartialBinaryText(false, ReadUInt8());
                    return true;
                case XmlBinaryNodeType.Bytes16TextWithEndElement:
                    if (buffered)
                        ReadBinaryText(MoveToAtomicTextWithEndElement(), ReadUInt16());
                    else
                        ReadPartialBinaryText(true, ReadUInt16());
                    return true;
                case XmlBinaryNodeType.Bytes16Text:
                    if (buffered)
                        ReadBinaryText(MoveToComplexText(), ReadUInt16());
                    else
                        ReadPartialBinaryText(false, ReadUInt16());
                    return true;
                case XmlBinaryNodeType.Bytes32TextWithEndElement:
                    if (buffered)
                        ReadBinaryText(MoveToAtomicTextWithEndElement(), ReadUInt31());
                    else
                        ReadPartialBinaryText(true, ReadUInt31());
                    return true;
                case XmlBinaryNodeType.Bytes32Text:
                    if (buffered)
                        ReadBinaryText(MoveToComplexText(), ReadUInt31());
                    else
                        ReadPartialBinaryText(false, ReadUInt31());
                    return true;
                case XmlBinaryNodeType.DictionaryTextWithEndElement:
                    MoveToAtomicTextWithEndElement().Value.SetDictionaryValue(ReadDictionaryKey());
                    return true;
                case XmlBinaryNodeType.UniqueIdTextWithEndElement:
                    ReadText(MoveToAtomicTextWithEndElement(), ValueHandleType.UniqueId, ValueHandleLength.UniqueId);
                    return true;
                case XmlBinaryNodeType.GuidTextWithEndElement:
                    ReadText(MoveToAtomicTextWithEndElement(), ValueHandleType.Guid, ValueHandleLength.Guid);
                    return true;
                case XmlBinaryNodeType.DecimalTextWithEndElement:
                    ReadText(MoveToAtomicTextWithEndElement(), ValueHandleType.Decimal, ValueHandleLength.Decimal);
                    return true;
                case XmlBinaryNodeType.Int8TextWithEndElement:
                    ReadText(MoveToAtomicTextWithEndElement(), ValueHandleType.Int8, ValueHandleLength.Int8);
                    return true;
                case XmlBinaryNodeType.Int16TextWithEndElement:
                    ReadText(MoveToAtomicTextWithEndElement(), ValueHandleType.Int16, ValueHandleLength.Int16);
                    return true;
                case XmlBinaryNodeType.Int32TextWithEndElement:
                    ReadText(MoveToAtomicTextWithEndElement(), ValueHandleType.Int32, ValueHandleLength.Int32);
                    return true;
                case XmlBinaryNodeType.Int64TextWithEndElement:
                    ReadText(MoveToAtomicTextWithEndElement(), ValueHandleType.Int64, ValueHandleLength.Int64);
                    return true;
                case XmlBinaryNodeType.UInt64TextWithEndElement:
                    ReadText(MoveToAtomicTextWithEndElement(), ValueHandleType.UInt64, ValueHandleLength.UInt64);
                    return true;
                case XmlBinaryNodeType.FloatTextWithEndElement:
                    ReadText(MoveToAtomicTextWithEndElement(), ValueHandleType.Single, ValueHandleLength.Single);
                    return true;
                case XmlBinaryNodeType.DoubleTextWithEndElement:
                    ReadText(MoveToAtomicTextWithEndElement(), ValueHandleType.Double, ValueHandleLength.Double);
                    return true;
                case XmlBinaryNodeType.TimeSpanTextWithEndElement:
                    ReadText(MoveToAtomicTextWithEndElement(), ValueHandleType.TimeSpan, ValueHandleLength.TimeSpan);
                    return true;
                case XmlBinaryNodeType.DateTimeTextWithEndElement:
                    ReadText(MoveToAtomicTextWithEndElement(), ValueHandleType.DateTime, ValueHandleLength.DateTime);
                    return true;
                case XmlBinaryNodeType.QNameDictionaryTextWithEndElement:
                    BufferReader.ReadQName(MoveToAtomicTextWithEndElement().Value);
                    return true;
                case XmlBinaryNodeType.Array:
                    ReadArray();
                    return true;
                default:
                    BufferReader.ReadValue(nodeType, MoveToComplexText().Value);
                    return true;
            }
        }
 
        void VerifyWhitespace()
        {
            if (!this.Node.Value.IsWhitespace())
                XmlExceptionHelper.ThrowInvalidBinaryFormat(this);
        }
 
        void ReadAttributes()
        {
            XmlBinaryNodeType nodeType = GetNodeType();
            if (nodeType < XmlBinaryNodeType.MinAttribute || nodeType > XmlBinaryNodeType.MaxAttribute)
                return;
            ReadAttributes2();
        }
 
        void ReadAttributes2()
        {
            int startOffset = 0;
            if (buffered)
                startOffset = BufferReader.Offset;
 
            while (true)
            {
                XmlAttributeNode attributeNode;
                Namespace nameSpace;
                PrefixHandleType prefix;
                XmlBinaryNodeType nodeType = GetNodeType();
                switch (nodeType)
                {
                    case XmlBinaryNodeType.ShortAttribute:
                        SkipNodeType();
                        attributeNode = AddAttribute();
                        attributeNode.Prefix.SetValue(PrefixHandleType.Empty);
                        ReadName(attributeNode.LocalName);
                        ReadAttributeText(attributeNode.AttributeText);
                        break;
                    case XmlBinaryNodeType.Attribute:
                        SkipNodeType();
                        attributeNode = AddAttribute();
                        ReadName(attributeNode.Prefix);
                        ReadName(attributeNode.LocalName);
                        ReadAttributeText(attributeNode.AttributeText);
                        FixXmlAttribute(attributeNode);
                        break;
                    case XmlBinaryNodeType.ShortDictionaryAttribute:
                        SkipNodeType();
                        attributeNode = AddAttribute();
                        attributeNode.Prefix.SetValue(PrefixHandleType.Empty);
                        ReadDictionaryName(attributeNode.LocalName);
                        ReadAttributeText(attributeNode.AttributeText);
                        break;
                    case XmlBinaryNodeType.DictionaryAttribute:
                        SkipNodeType();
                        attributeNode = AddAttribute();
                        ReadName(attributeNode.Prefix);
                        ReadDictionaryName(attributeNode.LocalName);
                        ReadAttributeText(attributeNode.AttributeText);
                        break;
                    case XmlBinaryNodeType.XmlnsAttribute:
                        SkipNodeType();
                        nameSpace = AddNamespace();
                        ReadName(nameSpace.Prefix);
                        ReadName(nameSpace.Uri);
                        attributeNode = AddXmlnsAttribute(nameSpace);
                        break;
                    case XmlBinaryNodeType.ShortXmlnsAttribute:
                        SkipNodeType();
                        nameSpace = AddNamespace();
                        nameSpace.Prefix.SetValue(PrefixHandleType.Empty);
                        ReadName(nameSpace.Uri);
                        attributeNode = AddXmlnsAttribute(nameSpace);
                        break;
                    case XmlBinaryNodeType.ShortDictionaryXmlnsAttribute:
                        SkipNodeType();
                        nameSpace = AddNamespace();
                        nameSpace.Prefix.SetValue(PrefixHandleType.Empty);
                        ReadDictionaryName(nameSpace.Uri);
                        attributeNode = AddXmlnsAttribute(nameSpace);
                        break;
                    case XmlBinaryNodeType.DictionaryXmlnsAttribute:
                        SkipNodeType();
                        nameSpace = AddNamespace();
                        ReadName(nameSpace.Prefix);
                        ReadDictionaryName(nameSpace.Uri);
                        attributeNode = AddXmlnsAttribute(nameSpace);
                        break;
                    case XmlBinaryNodeType.PrefixDictionaryAttributeA:
                    case XmlBinaryNodeType.PrefixDictionaryAttributeB:
                    case XmlBinaryNodeType.PrefixDictionaryAttributeC:
                    case XmlBinaryNodeType.PrefixDictionaryAttributeD:
                    case XmlBinaryNodeType.PrefixDictionaryAttributeE:
                    case XmlBinaryNodeType.PrefixDictionaryAttributeF:
                    case XmlBinaryNodeType.PrefixDictionaryAttributeG:
                    case XmlBinaryNodeType.PrefixDictionaryAttributeH:
                    case XmlBinaryNodeType.PrefixDictionaryAttributeI:
                    case XmlBinaryNodeType.PrefixDictionaryAttributeJ:
                    case XmlBinaryNodeType.PrefixDictionaryAttributeK:
                    case XmlBinaryNodeType.PrefixDictionaryAttributeL:
                    case XmlBinaryNodeType.PrefixDictionaryAttributeM:
                    case XmlBinaryNodeType.PrefixDictionaryAttributeN:
                    case XmlBinaryNodeType.PrefixDictionaryAttributeO:
                    case XmlBinaryNodeType.PrefixDictionaryAttributeP:
                    case XmlBinaryNodeType.PrefixDictionaryAttributeQ:
                    case XmlBinaryNodeType.PrefixDictionaryAttributeR:
                    case XmlBinaryNodeType.PrefixDictionaryAttributeS:
                    case XmlBinaryNodeType.PrefixDictionaryAttributeT:
                    case XmlBinaryNodeType.PrefixDictionaryAttributeU:
                    case XmlBinaryNodeType.PrefixDictionaryAttributeV:
                    case XmlBinaryNodeType.PrefixDictionaryAttributeW:
                    case XmlBinaryNodeType.PrefixDictionaryAttributeX:
                    case XmlBinaryNodeType.PrefixDictionaryAttributeY:
                    case XmlBinaryNodeType.PrefixDictionaryAttributeZ:
                        SkipNodeType();
                        attributeNode = AddAttribute();
                        prefix = PrefixHandle.GetAlphaPrefix((int)nodeType - (int)XmlBinaryNodeType.PrefixDictionaryAttributeA);
                        attributeNode.Prefix.SetValue(prefix);
                        ReadDictionaryName(attributeNode.LocalName);
                        ReadAttributeText(attributeNode.AttributeText);
                        break;
                    case XmlBinaryNodeType.PrefixAttributeA:
                    case XmlBinaryNodeType.PrefixAttributeB:
                    case XmlBinaryNodeType.PrefixAttributeC:
                    case XmlBinaryNodeType.PrefixAttributeD:
                    case XmlBinaryNodeType.PrefixAttributeE:
                    case XmlBinaryNodeType.PrefixAttributeF:
                    case XmlBinaryNodeType.PrefixAttributeG:
                    case XmlBinaryNodeType.PrefixAttributeH:
                    case XmlBinaryNodeType.PrefixAttributeI:
                    case XmlBinaryNodeType.PrefixAttributeJ:
                    case XmlBinaryNodeType.PrefixAttributeK:
                    case XmlBinaryNodeType.PrefixAttributeL:
                    case XmlBinaryNodeType.PrefixAttributeM:
                    case XmlBinaryNodeType.PrefixAttributeN:
                    case XmlBinaryNodeType.PrefixAttributeO:
                    case XmlBinaryNodeType.PrefixAttributeP:
                    case XmlBinaryNodeType.PrefixAttributeQ:
                    case XmlBinaryNodeType.PrefixAttributeR:
                    case XmlBinaryNodeType.PrefixAttributeS:
                    case XmlBinaryNodeType.PrefixAttributeT:
                    case XmlBinaryNodeType.PrefixAttributeU:
                    case XmlBinaryNodeType.PrefixAttributeV:
                    case XmlBinaryNodeType.PrefixAttributeW:
                    case XmlBinaryNodeType.PrefixAttributeX:
                    case XmlBinaryNodeType.PrefixAttributeY:
                    case XmlBinaryNodeType.PrefixAttributeZ:
                        SkipNodeType();
                        attributeNode = AddAttribute();
                        prefix = PrefixHandle.GetAlphaPrefix((int)nodeType - (int)XmlBinaryNodeType.PrefixAttributeA);
                        attributeNode.Prefix.SetValue(prefix);
                        ReadName(attributeNode.LocalName);
                        ReadAttributeText(attributeNode.AttributeText);
                        break;
                    default:
                        if (buffered && (BufferReader.Offset - startOffset) > this.maxBytesPerRead)
                            XmlExceptionHelper.ThrowMaxBytesPerReadExceeded(this, this.maxBytesPerRead);
                        ProcessAttributes();
                        return;
                }
            }
        }
 
        void ReadText(XmlTextNode textNode, ValueHandleType type, int length)
        {
            int offset = BufferReader.ReadBytes(length);
            textNode.Value.SetValue(type, offset, length);
            if (this.OutsideRootElement)
                VerifyWhitespace();
        }
 
        void ReadBinaryText(XmlTextNode textNode, int length)
        {
            ReadText(textNode, ValueHandleType.Base64, length);
        }
 
        void ReadPartialUTF8Text(bool withEndElement, int length)
        {
            // The maxBytesPerRead includes the quota for the XmlBinaryNodeType.TextNode, so we need
            // to account for that.
            const int maxTextNodeLength = 5;
            int maxLength = Math.Max(this.maxBytesPerRead - maxTextNodeLength, 0);
            if (length <= maxLength)
            {
                if (withEndElement)
                    ReadText(MoveToAtomicTextWithEndElement(), ValueHandleType.UTF8, length);
                else
                    ReadText(MoveToComplexText(), ValueHandleType.UTF8, length);
            }
            else
            {
                // We also need to make sure we have enough room to insert a new XmlBinaryNodeType.TextNode
                // for the split data.
                int actual = Math.Max(maxLength - maxTextNodeLength, 0);
                int offset = BufferReader.ReadBytes(actual);
 
                // We need to make sure we don't split a utf8  character, so scan backwards for a 
                // character boundary.  We'll actually always push off at least one character since 
                // although we find the character boundary, we don't bother to figure out if we have 
                // all the bytes that comprise the character.
                int i;
                for (i = offset + actual - 1; i >= offset; i--)
                {
                    byte b = BufferReader.GetByte(i);
                    // The first byte of UTF8 character sequence has either the high bit off, or the
                    // two high bits set.
                    if ((b & 0x80) == 0 || (b & 0xC0) == 0xC0)
                        break;
                }
 
                // Move any split characters so we can insert the node
                int byteCount = (offset + actual - i);
 
                // Include the split characters in the count
                BufferReader.Offset = BufferReader.Offset - byteCount;
                actual -= byteCount;
                MoveToComplexText().Value.SetValue(ValueHandleType.UTF8, offset, actual);
                if (this.OutsideRootElement)
                    VerifyWhitespace();
 
                XmlBinaryNodeType nodeType = (withEndElement ? XmlBinaryNodeType.Chars32TextWithEndElement : XmlBinaryNodeType.Chars32Text);
                InsertNode(nodeType, length - actual);
            }
        }
 
        void ReadUnicodeText(bool withEndElement, int length)
        {
            if ((length & 1) != 0)
                XmlExceptionHelper.ThrowInvalidBinaryFormat(this);
            if (buffered)
            {
                if (withEndElement)
                {
                    ReadText(MoveToAtomicTextWithEndElement(), ValueHandleType.Unicode, length);
                }
                else
                {
                    ReadText(MoveToComplexText(), ValueHandleType.Unicode, length);
                }
            }
            else
            {
                ReadPartialUnicodeText(withEndElement, length);
            }
        }
 
        void ReadPartialUnicodeText(bool withEndElement, int length)
        {
            // The maxBytesPerRead includes the quota for the XmlBinaryNodeType.TextNode, so we need
            // to account for that.
            const int maxTextNodeLength = 5;
            int maxLength = Math.Max(this.maxBytesPerRead - maxTextNodeLength, 0);
            if (length <= maxLength)
            {
                if (withEndElement)
                    ReadText(MoveToAtomicTextWithEndElement(), ValueHandleType.Unicode, length);
                else
                    ReadText(MoveToComplexText(), ValueHandleType.Unicode, length);
            }
            else
            {
                // We also need to make sure we have enough room to insert a new XmlBinaryNodeType.TextNode
                // for the split data.
                int actual = Math.Max(maxLength - maxTextNodeLength, 0);
 
                // Make sure we break on a char boundary
                if ((actual & 1) != 0)
                    actual--;
 
                int offset = BufferReader.ReadBytes(actual);
 
                // We need to make sure we don't split a unicode surrogate character
                int byteCount = 0;
                char ch = (char)BufferReader.GetInt16(offset + actual - sizeof(char));
                // If the last char is a high surrogate char, then move back
                if (ch >= 0xD800 && ch < 0xDC00)
                    byteCount = sizeof(char);
 
                // Include the split characters in the count
                BufferReader.Offset = BufferReader.Offset - byteCount;
                actual -= byteCount;
                MoveToComplexText().Value.SetValue(ValueHandleType.Unicode, offset, actual);
                if (this.OutsideRootElement)
                    VerifyWhitespace();
 
                XmlBinaryNodeType nodeType = (withEndElement ? XmlBinaryNodeType.UnicodeChars32TextWithEndElement : XmlBinaryNodeType.UnicodeChars32Text);
                InsertNode(nodeType, length - actual);
            }
        }
 
        void ReadPartialBinaryText(bool withEndElement, int length)
        {
            const int nodeLength = 5;
            int maxBytesPerRead = Math.Max(this.maxBytesPerRead - nodeLength, 0);
            if (length <= maxBytesPerRead)
            {
                if (withEndElement)
                    ReadText(MoveToAtomicTextWithEndElement(), ValueHandleType.Base64, length);
                else
                    ReadText(MoveToComplexText(), ValueHandleType.Base64, length);
            }
            else
            {
                int actual = maxBytesPerRead;
                if (actual > 3)
                    actual -= (actual % 3);
                ReadText(MoveToComplexText(), ValueHandleType.Base64, actual);
                XmlBinaryNodeType nodeType = (withEndElement ? XmlBinaryNodeType.Bytes32TextWithEndElement : XmlBinaryNodeType.Bytes32Text);
                InsertNode(nodeType, length - actual);
            }
        }
 
        void InsertNode(XmlBinaryNodeType nodeType, int length)
        {
            byte[] buffer = new byte[5];
            buffer[0] = (byte)nodeType;
            buffer[1] = (byte)length;
            length >>= 8;
            buffer[2] = (byte)length;
            length >>= 8;
            buffer[3] = (byte)length;
            length >>= 8;
            buffer[4] = (byte)length;
            BufferReader.InsertBytes(buffer, 0, buffer.Length);
        }
 
        void ReadAttributeText(XmlAttributeTextNode textNode)
        {
            XmlBinaryNodeType nodeType = GetNodeType();
            SkipNodeType();
            BufferReader.ReadValue(nodeType, textNode.Value);
        }
 
        void ReadName(ValueHandle value)
        {
            int length = ReadMultiByteUInt31();
            int offset = BufferReader.ReadBytes(length);
            value.SetValue(ValueHandleType.UTF8, offset, length);
        }
 
        void ReadName(StringHandle handle)
        {
            int length = ReadMultiByteUInt31();
            int offset = BufferReader.ReadBytes(length);
            handle.SetValue(offset, length);
        }
 
        void ReadName(PrefixHandle prefix)
        {
            int length = ReadMultiByteUInt31();
            int offset = BufferReader.ReadBytes(length);
            prefix.SetValue(offset, length);
        }
 
        void ReadDictionaryName(StringHandle s)
        {
            int key = ReadDictionaryKey();
            s.SetValue(key);
        }
 
        XmlBinaryNodeType GetNodeType()
        {
            return BufferReader.GetNodeType();
        }
 
        void SkipNodeType()
        {
            BufferReader.SkipNodeType();
        }
 
        int ReadDictionaryKey()
        {
            return BufferReader.ReadDictionaryKey();
        }
 
        int ReadMultiByteUInt31()
        {
            return BufferReader.ReadMultiByteUInt31();
        }
 
        int ReadUInt8()
        {
            return BufferReader.ReadUInt8();
        }
 
        int ReadUInt16()
        {
            return BufferReader.ReadUInt16();
        }
 
        int ReadUInt31()
        {
            return BufferReader.ReadUInt31();
        }
 
        bool IsValidArrayType(XmlBinaryNodeType nodeType)
        {
            switch (nodeType)
            {
                case XmlBinaryNodeType.BoolTextWithEndElement:
                case XmlBinaryNodeType.Int16TextWithEndElement:
                case XmlBinaryNodeType.Int32TextWithEndElement:
                case XmlBinaryNodeType.Int64TextWithEndElement:
                case XmlBinaryNodeType.FloatTextWithEndElement:
                case XmlBinaryNodeType.DoubleTextWithEndElement:
                case XmlBinaryNodeType.DecimalTextWithEndElement:
                case XmlBinaryNodeType.DateTimeTextWithEndElement:
                case XmlBinaryNodeType.TimeSpanTextWithEndElement:
                case XmlBinaryNodeType.GuidTextWithEndElement:
                    return true;
                default:
                    return false;
            }
        }
 
        void ReadArray()
        {
            if (GetNodeType() == XmlBinaryNodeType.Array) // Prevent recursion
                XmlExceptionHelper.ThrowInvalidBinaryFormat(this);
            ReadNode(); // ReadStartElement
            if (this.Node.NodeType != XmlNodeType.Element)
                XmlExceptionHelper.ThrowInvalidBinaryFormat(this);
            if (GetNodeType() == XmlBinaryNodeType.Array) // Prevent recursion
                XmlExceptionHelper.ThrowInvalidBinaryFormat(this);
            ReadNode(); // ReadEndElement
            if (this.Node.NodeType != XmlNodeType.EndElement)
                XmlExceptionHelper.ThrowInvalidBinaryFormat(this);
            arrayState = ArrayState.Element;
            arrayNodeType = GetNodeType();
            if (!IsValidArrayType(arrayNodeType))
                XmlExceptionHelper.ThrowInvalidBinaryFormat(this);
            SkipNodeType();
            arrayCount = ReadMultiByteUInt31();
            if (arrayCount == 0)
                XmlExceptionHelper.ThrowInvalidBinaryFormat(this);
            MoveToArrayElement();
        }
 
        void MoveToArrayElement()
        {
            arrayState = ArrayState.Element;
            MoveToNode(ElementNode);
        }
 
        void SkipArrayElements(int count)
        {
            arrayCount -= count;
            if (arrayCount == 0)
            {
                arrayState = ArrayState.None;
                ExitScope();
                ReadNode();
            }
        }
 
        public override bool IsStartArray(out Type type)
        {
            type = null;
            if (arrayState != ArrayState.Element)
                return false;
            switch (arrayNodeType)
            {
                case XmlBinaryNodeType.BoolTextWithEndElement:
                    type = typeof(bool);
                    break;
                case XmlBinaryNodeType.Int16TextWithEndElement:
                    type = typeof(Int16);
                    break;
                case XmlBinaryNodeType.Int32TextWithEndElement:
                    type = typeof(Int32);
                    break;
                case XmlBinaryNodeType.Int64TextWithEndElement:
                    type = typeof(Int64);
                    break;
                case XmlBinaryNodeType.FloatTextWithEndElement:
                    type = typeof(float);
                    break;
                case XmlBinaryNodeType.DoubleTextWithEndElement:
                    type = typeof(double);
                    break;
                case XmlBinaryNodeType.DecimalTextWithEndElement:
                    type = typeof(decimal);
                    break;
                case XmlBinaryNodeType.DateTimeTextWithEndElement:
                    type = typeof(DateTime);
                    break;
                case XmlBinaryNodeType.GuidTextWithEndElement:
                    type = typeof(Guid);
                    break;
                case XmlBinaryNodeType.TimeSpanTextWithEndElement:
                    type = typeof(TimeSpan);
                    break;
                case XmlBinaryNodeType.UniqueIdTextWithEndElement:
                    type = typeof(UniqueId);
                    break;
                default:
                    return false;
            }
            return true;
        }
 
        public override bool TryGetArrayLength(out int count)
        {
            count = 0;
            if (!buffered)
                return false;
            if (arrayState != ArrayState.Element)
                return false;
            count = arrayCount;
            return true;
        }
 
        bool IsStartArray(string localName, string namespaceUri, XmlBinaryNodeType nodeType)
        {
            return IsStartElement(localName, namespaceUri) && arrayState == ArrayState.Element && arrayNodeType == nodeType && !Signing;
        }
 
        bool IsStartArray(XmlDictionaryString localName, XmlDictionaryString namespaceUri, XmlBinaryNodeType nodeType)
        {
            return IsStartElement(localName, namespaceUri) && arrayState == ArrayState.Element && arrayNodeType == nodeType && !Signing;
        }
 
        void CheckArray(Array array, int offset, int count)
        {
            if (array == null)
                throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("array"));
            if (offset < 0)
                throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("offset", SR.GetString(SR.ValueMustBeNonNegative)));
            if (offset > array.Length)
                throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("offset", SR.GetString(SR.OffsetExceedsBufferSize, array.Length)));
            if (count < 0)
                throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("count", SR.GetString(SR.ValueMustBeNonNegative)));
            if (count > array.Length - offset)
                throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("count", SR.GetString(SR.SizeExceedsRemainingBufferSpace, array.Length - offset)));
        }
 
        // bool
        [Fx.Tag.SecurityNote(Critical = "Contains unsafe code.",
            Safe = "Unsafe code is effectively encapsulated, all inputs are validated.")]
        [SecuritySafeCritical]
        unsafe int ReadArray(bool[] array, int offset, int count)
        {
            CheckArray(array, offset, count);
            int actual = Math.Min(count, arrayCount);
            fixed (bool* items = &array[offset])
            {
                BufferReader.UnsafeReadArray((byte*)items, (byte*)&items[actual]);
            }
            SkipArrayElements(actual);
            return actual;
        }
 
        public override int ReadArray(string localName, string namespaceUri, bool[] array, int offset, int count)
        {
            if (IsStartArray(localName, namespaceUri, XmlBinaryNodeType.BoolTextWithEndElement))
                return ReadArray(array, offset, count);
            return base.ReadArray(localName, namespaceUri, array, offset, count);
        }
 
        public override int ReadArray(XmlDictionaryString localName, XmlDictionaryString namespaceUri, bool[] array, int offset, int count)
        {
            if (IsStartArray(localName, namespaceUri, XmlBinaryNodeType.BoolTextWithEndElement))
                return ReadArray(array, offset, count);
            return base.ReadArray(localName, namespaceUri, array, offset, count);
        }
 
        // Int16
        [Fx.Tag.SecurityNote(Critical = "Contains unsafe code.",
            Safe = "Unsafe code is effectively encapsulated, all inputs are validated.")]
        [SecuritySafeCritical]
        unsafe int ReadArray(Int16[] array, int offset, int count)
        {
            CheckArray(array, offset, count);
            int actual = Math.Min(count, arrayCount);
            fixed (Int16* items = &array[offset])
            {
                BufferReader.UnsafeReadArray((byte*)items, (byte*)&items[actual]);
            }
            SkipArrayElements(actual);
            return actual;
        }
 
        public override int ReadArray(string localName, string namespaceUri, Int16[] array, int offset, int count)
        {
            if (IsStartArray(localName, namespaceUri, XmlBinaryNodeType.Int16TextWithEndElement) && BitConverter.IsLittleEndian)
                return ReadArray(array, offset, count);
            return base.ReadArray(localName, namespaceUri, array, offset, count);
        }
 
        public override int ReadArray(XmlDictionaryString localName, XmlDictionaryString namespaceUri, Int16[] array, int offset, int count)
        {
            if (IsStartArray(localName, namespaceUri, XmlBinaryNodeType.Int16TextWithEndElement) && BitConverter.IsLittleEndian)
                return ReadArray(array, offset, count);
            return base.ReadArray(localName, namespaceUri, array, offset, count);
        }
 
        // Int32
        [Fx.Tag.SecurityNote(Critical = "Contains unsafe code.",
            Safe = "Unsafe code is effectively encapsulated, all inputs are validated.")]
        [SecuritySafeCritical]
        unsafe int ReadArray(Int32[] array, int offset, int count)
        {
            CheckArray(array, offset, count);
            int actual = Math.Min(count, arrayCount);
            fixed (Int32* items = &array[offset])
            {
                BufferReader.UnsafeReadArray((byte*)items, (byte*)&items[actual]);
            }
            SkipArrayElements(actual);
            return actual;
        }
 
        public override int ReadArray(string localName, string namespaceUri, Int32[] array, int offset, int count)
        {
            if (IsStartArray(localName, namespaceUri, XmlBinaryNodeType.Int32TextWithEndElement) && BitConverter.IsLittleEndian)
                return ReadArray(array, offset, count);
            return base.ReadArray(localName, namespaceUri, array, offset, count);
        }
 
        public override int ReadArray(XmlDictionaryString localName, XmlDictionaryString namespaceUri, Int32[] array, int offset, int count)
        {
            if (IsStartArray(localName, namespaceUri, XmlBinaryNodeType.Int32TextWithEndElement) && BitConverter.IsLittleEndian)
                return ReadArray(array, offset, count);
            return base.ReadArray(localName, namespaceUri, array, offset, count);
        }
 
        // Int64
        [Fx.Tag.SecurityNote(Critical = "Contains unsafe code.",
            Safe = "Unsafe code is effectively encapsulated, all inputs are validated.")]
        [SecuritySafeCritical]
        unsafe int ReadArray(Int64[] array, int offset, int count)
        {
            CheckArray(array, offset, count);
            int actual = Math.Min(count, arrayCount);
            fixed (Int64* items = &array[offset])
            {
                BufferReader.UnsafeReadArray((byte*)items, (byte*)&items[actual]);
            }
            SkipArrayElements(actual);
            return actual;
        }
 
        public override int ReadArray(string localName, string namespaceUri, Int64[] array, int offset, int count)
        {
            if (IsStartArray(localName, namespaceUri, XmlBinaryNodeType.Int64TextWithEndElement) && BitConverter.IsLittleEndian)
                return ReadArray(array, offset, count);
            return base.ReadArray(localName, namespaceUri, array, offset, count);
        }
 
        public override int ReadArray(XmlDictionaryString localName, XmlDictionaryString namespaceUri, Int64[] array, int offset, int count)
        {
            if (IsStartArray(localName, namespaceUri, XmlBinaryNodeType.Int64TextWithEndElement) && BitConverter.IsLittleEndian)
                return ReadArray(array, offset, count);
            return base.ReadArray(localName, namespaceUri, array, offset, count);
        }
 
        // float
        [Fx.Tag.SecurityNote(Critical = "Contains unsafe code.",
            Safe = "Unsafe code is effectively encapsulated, all inputs are validated.")]
        [SecuritySafeCritical]
        unsafe int ReadArray(float[] array, int offset, int count)
        {
            CheckArray(array, offset, count);
            int actual = Math.Min(count, arrayCount);
            fixed (float* items = &array[offset])
            {
                BufferReader.UnsafeReadArray((byte*)items, (byte*)&items[actual]);
            }
            SkipArrayElements(actual);
            return actual;
        }
 
        public override int ReadArray(string localName, string namespaceUri, float[] array, int offset, int count)
        {
            if (IsStartArray(localName, namespaceUri, XmlBinaryNodeType.FloatTextWithEndElement))
                return ReadArray(array, offset, count);
            return base.ReadArray(localName, namespaceUri, array, offset, count);
        }
 
        public override int ReadArray(XmlDictionaryString localName, XmlDictionaryString namespaceUri, float[] array, int offset, int count)
        {
            if (IsStartArray(localName, namespaceUri, XmlBinaryNodeType.FloatTextWithEndElement))
                return ReadArray(array, offset, count);
            return base.ReadArray(localName, namespaceUri, array, offset, count);
        }
 
        // double
        [Fx.Tag.SecurityNote(Critical = "Contains unsafe code.",
            Safe = "Unsafe code is effectively encapsulated, all inputs are validated.")]
        [SecuritySafeCritical]
        unsafe int ReadArray(double[] array, int offset, int count)
        {
            CheckArray(array, offset, count);
            int actual = Math.Min(count, arrayCount);
            fixed (double* items = &array[offset])
            {
                BufferReader.UnsafeReadArray((byte*)items, (byte*)&items[actual]);
            }
            SkipArrayElements(actual);
            return actual;
        }
 
        public override int ReadArray(string localName, string namespaceUri, double[] array, int offset, int count)
        {
            if (IsStartArray(localName, namespaceUri, XmlBinaryNodeType.DoubleTextWithEndElement))
                return ReadArray(array, offset, count);
            return base.ReadArray(localName, namespaceUri, array, offset, count);
        }
 
        public override int ReadArray(XmlDictionaryString localName, XmlDictionaryString namespaceUri, double[] array, int offset, int count)
        {
            if (IsStartArray(localName, namespaceUri, XmlBinaryNodeType.DoubleTextWithEndElement))
                return ReadArray(array, offset, count);
            return base.ReadArray(localName, namespaceUri, array, offset, count);
        }
 
        // decimal
        [Fx.Tag.SecurityNote(Critical = "Contains unsafe code.",
            Safe = "Unsafe code is effectively encapsulated, all inputs are validated.")]
        [SecuritySafeCritical]
        unsafe int ReadArray(decimal[] array, int offset, int count)
        {
            CheckArray(array, offset, count);
            int actual = Math.Min(count, arrayCount);
            fixed (decimal* items = &array[offset])
            {
                BufferReader.UnsafeReadArray((byte*)items, (byte*)&items[actual]);
            }
            SkipArrayElements(actual);
            return actual;
        }
 
        public override int ReadArray(string localName, string namespaceUri, decimal[] array, int offset, int count)
        {
            if (IsStartArray(localName, namespaceUri, XmlBinaryNodeType.DecimalTextWithEndElement))
                return ReadArray(array, offset, count);
            return base.ReadArray(localName, namespaceUri, array, offset, count);
        }
 
        public override int ReadArray(XmlDictionaryString localName, XmlDictionaryString namespaceUri, decimal[] array, int offset, int count)
        {
            if (IsStartArray(localName, namespaceUri, XmlBinaryNodeType.DecimalTextWithEndElement))
                return ReadArray(array, offset, count);
            return base.ReadArray(localName, namespaceUri, array, offset, count);
        }
 
        // DateTime
        int ReadArray(DateTime[] array, int offset, int count)
        {
            CheckArray(array, offset, count);
            int actual = Math.Min(count, arrayCount);
            for (int i = 0; i < actual; i++)
            {
                array[offset + i] = BufferReader.ReadDateTime();
            }
            SkipArrayElements(actual);
            return actual;
        }
 
        public override int ReadArray(string localName, string namespaceUri, DateTime[] array, int offset, int count)
        {
            if (IsStartArray(localName, namespaceUri, XmlBinaryNodeType.DateTimeTextWithEndElement))
                return ReadArray(array, offset, count);
            return base.ReadArray(localName, namespaceUri, array, offset, count);
        }
 
        public override int ReadArray(XmlDictionaryString localName, XmlDictionaryString namespaceUri, DateTime[] array, int offset, int count)
        {
            if (IsStartArray(localName, namespaceUri, XmlBinaryNodeType.DateTimeTextWithEndElement))
                return ReadArray(array, offset, count);
            return base.ReadArray(localName, namespaceUri, array, offset, count);
        }
 
        // Guid
        int ReadArray(Guid[] array, int offset, int count)
        {
            CheckArray(array, offset, count);
            int actual = Math.Min(count, arrayCount);
            for (int i = 0; i < actual; i++)
            {
                array[offset + i] = BufferReader.ReadGuid();
            }
            SkipArrayElements(actual);
            return actual;
        }
 
        public override int ReadArray(string localName, string namespaceUri, Guid[] array, int offset, int count)
        {
            if (IsStartArray(localName, namespaceUri, XmlBinaryNodeType.GuidTextWithEndElement))
                return ReadArray(array, offset, count);
            return base.ReadArray(localName, namespaceUri, array, offset, count);
        }
 
        public override int ReadArray(XmlDictionaryString localName, XmlDictionaryString namespaceUri, Guid[] array, int offset, int count)
        {
            if (IsStartArray(localName, namespaceUri, XmlBinaryNodeType.GuidTextWithEndElement))
                return ReadArray(array, offset, count);
            return base.ReadArray(localName, namespaceUri, array, offset, count);
        }
 
        // TimeSpan
        int ReadArray(TimeSpan[] array, int offset, int count)
        {
            CheckArray(array, offset, count);
            int actual = Math.Min(count, arrayCount);
            for (int i = 0; i < actual; i++)
            {
                array[offset + i] = BufferReader.ReadTimeSpan();
            }
            SkipArrayElements(actual);
            return actual;
        }
 
        public override int ReadArray(string localName, string namespaceUri, TimeSpan[] array, int offset, int count)
        {
            if (IsStartArray(localName, namespaceUri, XmlBinaryNodeType.TimeSpanTextWithEndElement))
                return ReadArray(array, offset, count);
            return base.ReadArray(localName, namespaceUri, array, offset, count);
        }
 
        public override int ReadArray(XmlDictionaryString localName, XmlDictionaryString namespaceUri, TimeSpan[] array, int offset, int count)
        {
            if (IsStartArray(localName, namespaceUri, XmlBinaryNodeType.TimeSpanTextWithEndElement))
                return ReadArray(array, offset, count);
            return base.ReadArray(localName, namespaceUri, array, offset, count);
        }
 
        enum ArrayState
        {
            None,
            Element,
            Content
        }
 
        protected override XmlSigningNodeWriter CreateSigningNodeWriter()
        {
            return new XmlSigningNodeWriter(false);
        }
    }
}