mono/mcs/class/referencesource/System.Runtime.Serialization/System/Runtime/Serialization/ExtensionDataReader.cs

//-----------------------------------------------------------------------------
// Copyright (c) Microsoft Corporation.  All rights reserved.
//-----------------------------------------------------------------------------
namespace System.Runtime.Serialization
{
    using System;
    using System.Text;
    using System.IO;
    using System.Xml;
    using System.Diagnostics;
    using System.Collections;
    using System.Collections.Generic;
    using System.Globalization;
    using System.Security;

    // NOTE: XmlReader methods that are not needed have been left un-implemented

    class ExtensionDataReader : XmlReader
    {
        enum ExtensionDataNodeType
        {
            None,
            Element,
            EndElement,
            Text,
            Xml,
            ReferencedElement,
            NullElement,
        }

        Hashtable cache = new Hashtable();

        ElementData[] elements;
        ElementData element;
        ElementData nextElement;

        ReadState readState = ReadState.Initial;
        ExtensionDataNodeType internalNodeType;
        XmlNodeType nodeType;
        int depth;
        string localName;
        string ns;
        string prefix;
        string value;
        int attributeCount;
        int attributeIndex;
        XmlNodeReader xmlNodeReader;
        Queue<IDataNode> deserializedDataNodes;
        XmlObjectSerializerReadContext context;

        [Fx.Tag.SecurityNote(Critical = "Holds static mappings from namespaces to prefixes."
            + " Static fields are marked SecurityCritical or readonly to prevent data from being modified or leaked to other components in appdomain.")]
        [SecurityCritical]
        static Dictionary<string, string> nsToPrefixTable;

        [Fx.Tag.SecurityNote(Critical = "Holds static mappings from prefixes to namespaces."
            + " Static fields are marked SecurityCritical or readonly to prevent data from being modified or leaked to other components in appdomain.")]
        [SecurityCritical]
        static Dictionary<string, string> prefixToNsTable;

        [Fx.Tag.SecurityNote(Critical = "Initializes information in critical static cache.",
            Safe = "Cache is initialized with well-known namespace, prefix mappings.")]
        [SecuritySafeCritical]
        static ExtensionDataReader()
        {
            nsToPrefixTable = new Dictionary<string, string>();
            prefixToNsTable = new Dictionary<string, string>();
            AddPrefix(Globals.XsiPrefix, Globals.SchemaInstanceNamespace);
            AddPrefix(Globals.SerPrefix, Globals.SerializationNamespace);
            AddPrefix(String.Empty, String.Empty);
        }

        internal ExtensionDataReader(XmlObjectSerializerReadContext context)
        {
            this.attributeIndex = -1;
            this.context = context;
        }

        internal void SetDeserializedValue(object obj)
        {
            IDataNode deserializedDataNode = (deserializedDataNodes == null || deserializedDataNodes.Count == 0) ? null : deserializedDataNodes.Dequeue();
            if (deserializedDataNode != null && !(obj is IDataNode))
            {
                deserializedDataNode.Value = obj;
                deserializedDataNode.IsFinalValue = true;
            }
        }

        internal IDataNode GetCurrentNode()
        {
            IDataNode retVal = element.dataNode;
            Skip();
            return retVal;
        }

        internal void SetDataNode(IDataNode dataNode, string name, string ns)
        {
            SetNextElement(dataNode, name, ns, null);
            this.element = nextElement;
            this.nextElement = null;
            SetElement();
        }

        internal void Reset()
        {
            this.localName = null;
            this.ns = null;
            this.prefix = null;
            this.value = null;
            this.attributeCount = 0;
            this.attributeIndex = -1;
            this.depth = 0;
            this.element = null;
            this.nextElement = null;
            this.elements = null;
            this.deserializedDataNodes = null;
        }

        bool IsXmlDataNode { get { return (internalNodeType == ExtensionDataNodeType.Xml); } }

        public override XmlNodeType NodeType { get { return IsXmlDataNode ? xmlNodeReader.NodeType : nodeType; } }
        public override string LocalName { get { return IsXmlDataNode ? xmlNodeReader.LocalName : localName; } }
        public override string NamespaceURI { get { return IsXmlDataNode ? xmlNodeReader.NamespaceURI : ns; } }
        public override string Prefix { get { return IsXmlDataNode ? xmlNodeReader.Prefix : prefix; } }
        public override string Value { get { return IsXmlDataNode ? xmlNodeReader.Value : value; } }
        public override int Depth { get { return IsXmlDataNode ? xmlNodeReader.Depth : depth; } }
        public override int AttributeCount { get { return IsXmlDataNode ? xmlNodeReader.AttributeCount : attributeCount; } }
        public override bool EOF { get { return IsXmlDataNode ? xmlNodeReader.EOF : (readState == ReadState.EndOfFile); } }
        public override ReadState ReadState { get { return IsXmlDataNode ? xmlNodeReader.ReadState : readState; } }
        public override bool IsEmptyElement { get { return IsXmlDataNode ? xmlNodeReader.IsEmptyElement : false; } }
        public override bool IsDefault { get { return IsXmlDataNode ? xmlNodeReader.IsDefault : base.IsDefault; } }
        public override char QuoteChar { get { return IsXmlDataNode ? xmlNodeReader.QuoteChar : base.QuoteChar; } }
        public override XmlSpace XmlSpace { get { return IsXmlDataNode ? xmlNodeReader.XmlSpace : base.XmlSpace; } }
        public override string XmlLang { get { return IsXmlDataNode ? xmlNodeReader.XmlLang : base.XmlLang; } }
        public override string this[int i] { get { return IsXmlDataNode ? xmlNodeReader[i] : GetAttribute(i); } }
        public override string this[string name] { get { return IsXmlDataNode ? xmlNodeReader[name] : GetAttribute(name); } }
        public override string this[string name, string namespaceURI] { get { return IsXmlDataNode ? xmlNodeReader[name, namespaceURI] : GetAttribute(name, namespaceURI); } }

        public override bool MoveToFirstAttribute()
        {
            if (IsXmlDataNode)
                return xmlNodeReader.MoveToFirstAttribute();

            if (attributeCount == 0)
                return false;
            MoveToAttribute(0);
            return true;
        }

        public override bool MoveToNextAttribute()
        {
            if (IsXmlDataNode)
                return xmlNodeReader.MoveToNextAttribute();

            if (attributeIndex + 1 >= attributeCount)
                return false;
            MoveToAttribute(attributeIndex + 1);
            return true;
        }

        public override void MoveToAttribute(int index)
        {
            if (IsXmlDataNode)
                xmlNodeReader.MoveToAttribute(index);
            else
            {
                if (index < 0 || index >= attributeCount)
                    throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(SR.GetString(SR.InvalidXmlDeserializingExtensionData)));

                this.nodeType = XmlNodeType.Attribute;
                AttributeData attribute = element.attributes[index];
                this.localName = attribute.localName;
                this.ns = attribute.ns;
                this.prefix = attribute.prefix;
                this.value = attribute.value;
                this.attributeIndex = index;
            }
        }

        public override string GetAttribute(string name, string namespaceURI)
        {
            if (IsXmlDataNode)
                return xmlNodeReader.GetAttribute(name, namespaceURI);

            for (int i = 0; i < element.attributeCount; i++)
            {
                AttributeData attribute = element.attributes[i];
                if (attribute.localName == name && attribute.ns == namespaceURI)
                    return attribute.value;
            }

            return null;
        }

        public override bool MoveToAttribute(string name, string namespaceURI)
        {
            if (IsXmlDataNode)
                return xmlNodeReader.MoveToAttribute(name, ns);

            for (int i = 0; i < element.attributeCount; i++)
            {
                AttributeData attribute = element.attributes[i];
                if (attribute.localName == name && attribute.ns == namespaceURI)
                {
                    MoveToAttribute(i);
                    return true;
                }
            }

            return false;
        }

        public override bool MoveToElement()
        {
            if (IsXmlDataNode)
                return xmlNodeReader.MoveToElement();

            if (this.nodeType != XmlNodeType.Attribute)
                return false;

            SetElement();
            return true;
        }

        void SetElement()
        {
            this.nodeType = XmlNodeType.Element;
            this.localName = element.localName;
            this.ns = element.ns;
            this.prefix = element.prefix;
            this.value = String.Empty;
            this.attributeCount = element.attributeCount;
            this.attributeIndex = -1;
        }

        [Fx.Tag.SecurityNote(Critical = "Accesses SecurityCritical static cache to look up namespace given a prefix.",
            Safe = "Read only access.")]
        [SecuritySafeCritical]
        public override string LookupNamespace(string prefix)
        {
            if (IsXmlDataNode)
                return xmlNodeReader.LookupNamespace(prefix);

            string ns;
            if (!prefixToNsTable.TryGetValue(prefix, out ns))
                return null;
            return ns;
        }

        public override void Skip()
        {
            if (IsXmlDataNode)
                xmlNodeReader.Skip();
            else
            {
                if (ReadState != ReadState.Interactive)
                    return;
                MoveToElement();
                if (IsElementNode(this.internalNodeType))
                {
                    int depth = 1;
                    while (depth != 0)
                    {
                        if (!Read())
                            throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(SR.GetString(SR.InvalidXmlDeserializingExtensionData)));

                        if (IsElementNode(this.internalNodeType))
                            depth++;
                        else if (this.internalNodeType == ExtensionDataNodeType.EndElement)
                        {
                            ReadEndElement();
                            depth--;
                        }
                    }
                }
                else
                    Read();
            }
        }

        bool IsElementNode(ExtensionDataNodeType nodeType)
        {
            return (nodeType == ExtensionDataNodeType.Element ||
                nodeType == ExtensionDataNodeType.ReferencedElement ||
                nodeType == ExtensionDataNodeType.NullElement);
        }

        public override void Close()
        {
            if (IsXmlDataNode)
                xmlNodeReader.Close();
            else
            {
                Reset();
                this.readState = ReadState.Closed;
            }
        }

        public override bool Read()
        {
            if (nodeType == XmlNodeType.Attribute && MoveToNextAttribute())
                return true;

            MoveNext(element.dataNode);

            switch (internalNodeType)
            {
                case ExtensionDataNodeType.Element:
                case ExtensionDataNodeType.ReferencedElement:
                case ExtensionDataNodeType.NullElement:
                    PushElement();
                    SetElement();
                    break;

                case ExtensionDataNodeType.Text:
                    this.nodeType = XmlNodeType.Text;
                    this.prefix = String.Empty;
                    this.ns = String.Empty;
                    this.localName = String.Empty;
                    this.attributeCount = 0;
                    this.attributeIndex = -1;
                    break;

                case ExtensionDataNodeType.EndElement:
                    this.nodeType = XmlNodeType.EndElement;
                    this.prefix = String.Empty;
                    this.ns = String.Empty;
                    this.localName = String.Empty;
                    this.value = String.Empty;
                    this.attributeCount = 0;
                    this.attributeIndex = -1;
                    PopElement();
                    break;

                case ExtensionDataNodeType.None:
                    if (depth != 0)
                        throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(SR.GetString(SR.InvalidXmlDeserializingExtensionData)));
                    this.nodeType = XmlNodeType.None;
                    this.prefix = String.Empty;
                    this.ns = String.Empty;
                    this.localName = String.Empty;
                    this.value = String.Empty;
                    this.attributeCount = 0;
                    readState = ReadState.EndOfFile;
                    return false;

                case ExtensionDataNodeType.Xml:
                    // do nothing
                    break;

                default:
                    Fx.Assert("ExtensionDataReader in invalid state");
                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new SerializationException(SR.GetString(SR.InvalidStateInExtensionDataReader)));
            }
            readState = ReadState.Interactive;
            return true;
        }

        public override string Name
        {
            get
            {
                if (IsXmlDataNode)
                {
                    return xmlNodeReader.Name;
                }
                Fx.Assert("ExtensionDataReader Name property should only be called for IXmlSerializable");
                return string.Empty;
            }
        }

        public override bool HasValue
        {
            get
            {
                if (IsXmlDataNode)
                {
                    return xmlNodeReader.HasValue;
                }
                Fx.Assert("ExtensionDataReader HasValue property should only be called for IXmlSerializable");
                return false;
            }
        }

        public override string BaseURI
        {
            get
            {
                if (IsXmlDataNode)
                {
                    return xmlNodeReader.BaseURI;
                }
                Fx.Assert("ExtensionDataReader BaseURI property should only be called for IXmlSerializable");
                return string.Empty;
            }
        }

        public override XmlNameTable NameTable
        {
            get
            {
                if (IsXmlDataNode)
                {
                    return xmlNodeReader.NameTable;
                }
                Fx.Assert("ExtensionDataReader NameTable property should only be called for IXmlSerializable");
                return null;
            }
        }

        public override string GetAttribute(string name)
        {
            if (IsXmlDataNode)
            {
                return xmlNodeReader.GetAttribute(name);
            }
            Fx.Assert("ExtensionDataReader GetAttribute method should only be called for IXmlSerializable");
            return null;
        }

        public override string GetAttribute(int i)
        {
            if (IsXmlDataNode)
            {
                return xmlNodeReader.GetAttribute(i);
            }
            Fx.Assert("ExtensionDataReader GetAttribute method should only be called for IXmlSerializable");
            return null;
        }

        public override bool MoveToAttribute(string name)
        {
            if (IsXmlDataNode)
            {
                return xmlNodeReader.MoveToAttribute(name);
            }
            Fx.Assert("ExtensionDataReader MoveToAttribute method should only be called for IXmlSerializable");
            return false;
        }

        public override void ResolveEntity()
        {
            if (IsXmlDataNode)
            {
                xmlNodeReader.ResolveEntity();
            }
            else
            {
                Fx.Assert("ExtensionDataReader ResolveEntity method should only be called for IXmlSerializable");
            }
        }

        public override bool ReadAttributeValue()
        {
            if (IsXmlDataNode)
            {
                return xmlNodeReader.ReadAttributeValue();
            }
            Fx.Assert("ExtensionDataReader ReadAttributeValue method should only be called for IXmlSerializable");
            return false;
        }

        void MoveNext(IDataNode dataNode)
        {
            switch (this.internalNodeType)
            {
                case ExtensionDataNodeType.Text:
                case ExtensionDataNodeType.ReferencedElement:
                case ExtensionDataNodeType.NullElement:
                    this.internalNodeType = ExtensionDataNodeType.EndElement;
                    return;
                default:
                    Type dataNodeType = dataNode.DataType;
                    if (dataNodeType == Globals.TypeOfClassDataNode)
                        MoveNextInClass((ClassDataNode)dataNode);
                    else if (dataNodeType == Globals.TypeOfCollectionDataNode)
                        MoveNextInCollection((CollectionDataNode)dataNode);
                    else if (dataNodeType == Globals.TypeOfISerializableDataNode)
                        MoveNextInISerializable((ISerializableDataNode)dataNode);
                    else if (dataNodeType == Globals.TypeOfXmlDataNode)
                        MoveNextInXml((XmlDataNode)dataNode);
                    else if (dataNode.Value != null)
                        MoveToDeserializedObject(dataNode);
                    else
                    {
                        Fx.Assert("Encountered invalid data node when deserializing unknown data");
                        throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new SerializationException(SR.GetString(SR.InvalidStateInExtensionDataReader)));
                    }
                    break;
            }
        }

        void SetNextElement(IDataNode node, string name, string ns, string prefix)
        {
            this.internalNodeType = ExtensionDataNodeType.Element;
            nextElement = GetNextElement();
            nextElement.localName = name;
            nextElement.ns = ns;
            nextElement.prefix = prefix;
            if (node == null)
            {
                nextElement.attributeCount = 0;
                nextElement.AddAttribute(Globals.XsiPrefix, Globals.SchemaInstanceNamespace, Globals.XsiNilLocalName, Globals.True);
                this.internalNodeType = ExtensionDataNodeType.NullElement;
            }
            else if (!CheckIfNodeHandled(node))
            {
                AddDeserializedDataNode(node);
                node.GetData(nextElement);
                if (node is XmlDataNode)
                    MoveNextInXml((XmlDataNode)node);
            }
        }

        void AddDeserializedDataNode(IDataNode node)
        {
            if (node.Id != Globals.NewObjectId && (node.Value == null || !node.IsFinalValue))
            {
                if (deserializedDataNodes == null)
                    deserializedDataNodes = new Queue<IDataNode>();
                deserializedDataNodes.Enqueue(node);
            }
        }

        bool CheckIfNodeHandled(IDataNode node)
        {
            bool handled = false;
            if (node.Id != Globals.NewObjectId)
            {
                handled = (cache[node] != null);
                if (handled)
                {
                    if (nextElement == null)
                        nextElement = GetNextElement();
                    nextElement.attributeCount = 0;
                    nextElement.AddAttribute(Globals.SerPrefix, Globals.SerializationNamespace, Globals.RefLocalName, node.Id.ToString(NumberFormatInfo.InvariantInfo));
                    nextElement.AddAttribute(Globals.XsiPrefix, Globals.SchemaInstanceNamespace, Globals.XsiNilLocalName, Globals.True);
                    this.internalNodeType = ExtensionDataNodeType.ReferencedElement;
                }
                else
                {
                    cache.Add(node, node);
                }
            }
            return handled;
        }

        void MoveNextInClass(ClassDataNode dataNode)
        {
            if (dataNode.Members != null && element.childElementIndex < dataNode.Members.Count)
            {
                if (element.childElementIndex == 0)
                    this.context.IncrementItemCount(-dataNode.Members.Count);

                ExtensionDataMember member = dataNode.Members[element.childElementIndex++];
                SetNextElement(member.Value, member.Name, member.Namespace, GetPrefix(member.Namespace));
            }
            else
            {
                this.internalNodeType = ExtensionDataNodeType.EndElement;
                element.childElementIndex = 0;
            }
        }

        void MoveNextInCollection(CollectionDataNode dataNode)
        {
            if (dataNode.Items != null && element.childElementIndex < dataNode.Items.Count)
            {
                if (element.childElementIndex == 0)
                    this.context.IncrementItemCount(-dataNode.Items.Count);

                IDataNode item = dataNode.Items[element.childElementIndex++];
                SetNextElement(item, dataNode.ItemName, dataNode.ItemNamespace, GetPrefix(dataNode.ItemNamespace));
            }
            else
            {
                this.internalNodeType = ExtensionDataNodeType.EndElement;
                element.childElementIndex = 0;
            }
        }

        void MoveNextInISerializable(ISerializableDataNode dataNode)
        {
            if (dataNode.Members != null && element.childElementIndex < dataNode.Members.Count)
            {
                if (element.childElementIndex == 0)
                    this.context.IncrementItemCount(-dataNode.Members.Count);

                ISerializableDataMember member = dataNode.Members[element.childElementIndex++];
                SetNextElement(member.Value, member.Name, String.Empty, String.Empty);
            }
            else
            {
                this.internalNodeType = ExtensionDataNodeType.EndElement;
                element.childElementIndex = 0;
            }
        }

        void MoveNextInXml(XmlDataNode dataNode)
        {
            if (IsXmlDataNode)
            {
                xmlNodeReader.Read();
                if (xmlNodeReader.Depth == 0)
                {
                    this.internalNodeType = ExtensionDataNodeType.EndElement;
                    xmlNodeReader = null;
                }
            }
            else
            {
                internalNodeType = ExtensionDataNodeType.Xml;
                if (element == null)
                    element = nextElement;
                else
                    PushElement();

                XmlNode wrapperElement = XmlObjectSerializerReadContext.CreateWrapperXmlElement(dataNode.OwnerDocument,
                    dataNode.XmlAttributes, dataNode.XmlChildNodes, element.prefix, element.localName, element.ns);
                for (int i = 0; i < element.attributeCount; i++)
                {
                    AttributeData a = element.attributes[i];
                    XmlAttribute xmlAttr = dataNode.OwnerDocument.CreateAttribute(a.prefix, a.localName, a.ns);
                    xmlAttr.Value = a.value;
                    wrapperElement.Attributes.Append(xmlAttr);
                }
                xmlNodeReader = new XmlNodeReader(wrapperElement);
                xmlNodeReader.Read();
            }
        }

        void MoveToDeserializedObject(IDataNode dataNode)
        {
            Type type = dataNode.DataType;
            bool isTypedNode = true;
            if (type == Globals.TypeOfObject)
            {
                type = dataNode.Value.GetType();
                if (type == Globals.TypeOfObject)
                {
                    this.internalNodeType = ExtensionDataNodeType.EndElement;
                    return;
                }
                isTypedNode = false;
            }

            if (!MoveToText(type, dataNode, isTypedNode))
            {
                if (dataNode.IsFinalValue)
                {
                    this.internalNodeType = ExtensionDataNodeType.EndElement;
                }
                else
                {
                    throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(SR.GetString(SR.InvalidDataNode, DataContract.GetClrTypeFullName(type))));
                }
            }
        }

        bool MoveToText(Type type, IDataNode dataNode, bool isTypedNode)
        {
            bool handled = true;
            switch (Type.GetTypeCode(type))
            {
                case TypeCode.Boolean:
                    this.value = XmlConvert.ToString(isTypedNode ? ((DataNode<bool>)dataNode).GetValue() : (bool)dataNode.Value);
                    break;
                case TypeCode.Char:
                    this.value = XmlConvert.ToString((int)(isTypedNode ? ((DataNode<char>)dataNode).GetValue() : (char)dataNode.Value));
                    break;
                case TypeCode.Byte:
                    this.value = XmlConvert.ToString(isTypedNode ? ((DataNode<byte>)dataNode).GetValue() : (byte)dataNode.Value);
                    break;
                case TypeCode.Int16:
                    this.value = XmlConvert.ToString(isTypedNode ? ((DataNode<short>)dataNode).GetValue() : (short)dataNode.Value);
                    break;
                case TypeCode.Int32:
                    this.value = XmlConvert.ToString(isTypedNode ? ((DataNode<int>)dataNode).GetValue() : (int)dataNode.Value);
                    break;
                case TypeCode.Int64:
                    this.value = XmlConvert.ToString(isTypedNode ? ((DataNode<long>)dataNode).GetValue() : (long)dataNode.Value);
                    break;
                case TypeCode.Single:
                    this.value = XmlConvert.ToString(isTypedNode ? ((DataNode<float>)dataNode).GetValue() : (float)dataNode.Value);
                    break;
                case TypeCode.Double:
                    this.value = XmlConvert.ToString(isTypedNode ? ((DataNode<double>)dataNode).GetValue() : (double)dataNode.Value);
                    break;
                case TypeCode.Decimal:
                    this.value = XmlConvert.ToString(isTypedNode ? ((DataNode<decimal>)dataNode).GetValue() : (decimal)dataNode.Value);
                    break;
                case TypeCode.DateTime:
                    DateTime dateTime = isTypedNode ? ((DataNode<DateTime>)dataNode).GetValue() : (DateTime)dataNode.Value;
                    this.value = dateTime.ToString("yyyy-MM-ddTHH:mm:ss.fffffffK", DateTimeFormatInfo.InvariantInfo);
                    break;
                case TypeCode.String:
                    this.value = isTypedNode ? ((DataNode<string>)dataNode).GetValue() : (string)dataNode.Value;
                    break;
                case TypeCode.SByte:
                    this.value = XmlConvert.ToString(isTypedNode ? ((DataNode<sbyte>)dataNode).GetValue() : (sbyte)dataNode.Value);
                    break;
                case TypeCode.UInt16:
                    this.value = XmlConvert.ToString(isTypedNode ? ((DataNode<ushort>)dataNode).GetValue() : (ushort)dataNode.Value);
                    break;
                case TypeCode.UInt32:
                    this.value = XmlConvert.ToString(isTypedNode ? ((DataNode<uint>)dataNode).GetValue() : (uint)dataNode.Value);
                    break;
                case TypeCode.UInt64:
                    this.value = XmlConvert.ToString(isTypedNode ? ((DataNode<ulong>)dataNode).GetValue() : (ulong)dataNode.Value);
                    break;
                case TypeCode.Object:
                default:
                    if (type == Globals.TypeOfByteArray)
                    {
                        byte[] bytes = isTypedNode ? ((DataNode<byte[]>)dataNode).GetValue() : (byte[])dataNode.Value;
                        this.value = (bytes == null) ? String.Empty : Convert.ToBase64String(bytes);
                    }
                    else if (type == Globals.TypeOfTimeSpan)
                        this.value = XmlConvert.ToString(isTypedNode ? ((DataNode<TimeSpan>)dataNode).GetValue() : (TimeSpan)dataNode.Value);
                    else if (type == Globals.TypeOfGuid)
                    {
                        Guid guid = isTypedNode ? ((DataNode<Guid>)dataNode).GetValue() : (Guid)dataNode.Value;
                        this.value = guid.ToString();
                    }
                    else if (type == Globals.TypeOfUri)
                    {
                        Uri uri = isTypedNode ? ((DataNode<Uri>)dataNode).GetValue() : (Uri)dataNode.Value;
                        this.value = uri.GetComponents(UriComponents.SerializationInfoString, UriFormat.UriEscaped);
                    }
                    else
                        handled = false;
                    break;
            }

            if (handled)
                this.internalNodeType = ExtensionDataNodeType.Text;
            return handled;
        }

        void PushElement()
        {
            GrowElementsIfNeeded();
            elements[depth++] = this.element;
            if (nextElement == null)
                element = GetNextElement();
            else
            {
                element = nextElement;
                nextElement = null;
            }
        }

        void PopElement()
        {
            this.prefix = element.prefix;
            this.localName = element.localName;
            this.ns = element.ns;

            if (depth == 0)
                return;

            this.depth--;

            if (elements != null)
            {
                this.element = elements[depth];
            }
        }

        void GrowElementsIfNeeded()
        {
            if (elements == null)
                elements = new ElementData[8];
            else if (elements.Length == depth)
            {
                ElementData[] newElements = new ElementData[elements.Length * 2];
                Array.Copy(elements, 0, newElements, 0, elements.Length);
                elements = newElements;
            }
        }

        ElementData GetNextElement()
        {
            int nextDepth = depth + 1;
            return (elements == null || elements.Length <= nextDepth || elements[nextDepth] == null)
                ? new ElementData() : elements[nextDepth];
        }

        [Fx.Tag.SecurityNote(Critical = "Accesses SecurityCritical static cache to look up prefix given a namespace .",
            Safe = "Read only access.")]
        [SecuritySafeCritical]
        internal static string GetPrefix(string ns)
        {
            string prefix;
            ns = ns ?? String.Empty;
            if (!nsToPrefixTable.TryGetValue(ns, out prefix))
            {
                lock (nsToPrefixTable)
                {
                    if (!nsToPrefixTable.TryGetValue(ns, out prefix))
                    {
                        prefix = (ns == null || ns.Length == 0) ? String.Empty : "p" + nsToPrefixTable.Count;
                        AddPrefix(prefix, ns);
                    }
                }
            }
            return prefix;
        }

        [Fx.Tag.SecurityNote(Critical = "Accesses SecurityCritical static cache to look up prefix given a namespace .",
            Safe = "Read only access.")]
        [SecuritySafeCritical]
        static void AddPrefix(string prefix, string ns)
        {
            nsToPrefixTable.Add(ns, prefix);
            prefixToNsTable.Add(prefix, ns);
        }
    }

#if USE_REFEMIT
    public class AttributeData
#else
    internal class AttributeData
#endif
    {
        public string prefix;
        public string ns;
        public string localName;
        public string value;
    }

#if USE_REFEMIT
    public class ElementData
#else
    internal class ElementData
#endif
    {
        public string localName;
        public string ns;
        public string prefix;
        public int attributeCount;
        public AttributeData[] attributes;
        public IDataNode dataNode;
        public int childElementIndex;

        public void AddAttribute(string prefix, string ns, string name, string value)
        {
            GrowAttributesIfNeeded();
            AttributeData attribute = attributes[attributeCount];
            if (attribute == null)
                attributes[attributeCount] = attribute = new AttributeData();
            attribute.prefix = prefix;
            attribute.ns = ns;
            attribute.localName = name;
            attribute.value = value;
            attributeCount++;
        }

        void GrowAttributesIfNeeded()
        {
            if (attributes == null)
                attributes = new AttributeData[4];
            else if (attributes.Length == attributeCount)
            {
                AttributeData[] newAttributes = new AttributeData[attributes.Length * 2];
                Array.Copy(attributes, 0, newAttributes, 0, attributes.Length);
                attributes = newAttributes;
            }
        }
    }

}