Imported Upstream version 4.6.0.125

Former-commit-id: a2155e9bd80020e49e72e86c44da02a8ac0e57a4

mcs/class/referencesource/System.Web/UI/WebControls/XmlHierarchyData.cs

@@ -0,0 +1,262 @@
+//------------------------------------------------------------------------------
+// <copyright file="XmlHierarchyData.cs" company="Microsoft">
+//     Copyright (c) Microsoft Corporation.  All rights reserved.
+// </copyright>
+//------------------------------------------------------------------------------
+
+namespace System.Web.UI.WebControls {
+
+    using System;
+    using System.Collections;
+    using System.ComponentModel;
+    using System.Data;
+    using System.Drawing.Design;
+    using System.Globalization;
+    using System.Text;
+    using System.Web;
+    using System.Web.UI;
+    using System.Xml;
+
+    using AttributeCollection = System.ComponentModel.AttributeCollection;
+
+
+    /// <devdoc>
+    /// Represents the data associated with a single hierarchy item - in this case an XmlNode.
+    /// </devdoc>
+    internal sealed class XmlHierarchyData : IHierarchyData, ICustomTypeDescriptor {
+
+        private XmlNode _item;
+        private XmlHierarchicalEnumerable _parent;
+        private string _path;
+
+        /// <devdoc>
+        /// Create a new instance of XmlHierarchyData.
+        /// </devdoc>
+        internal XmlHierarchyData(XmlHierarchicalEnumerable parent, XmlNode item) {
+            _parent = parent;
+            _item = item;
+        }
+
+
+        /// <devdoc>
+        /// Creates a path to a given XmlNode from the root using XPath.
+        /// </devdoc>
+        private string CreateRecursivePath(XmlNode node) {
+            if (node.ParentNode == null)
+                return String.Empty;
+
+            return CreateRecursivePath(node.ParentNode) + FindNodePosition(node);
+        }
+
+        /// <devdoc>
+        /// Finds a node's position relative to its parent.
+        /// </devdoc>
+        private string FindNodePosition(XmlNode node) {
+            XmlNodeList nodeList = node.ParentNode.ChildNodes;
+
+            int index = 0;
+
+            for (int i = 0; i < nodeList.Count; i++) {
+                // Position only considers elements, not other node types
+                if (nodeList[i].NodeType == XmlNodeType.Element)
+                    index++;
+
+                if (nodeList[i] == node)
+                    return "/*[position()=" + Convert.ToString(index, CultureInfo.InvariantCulture) + "]";
+            }
+
+            throw new ArgumentException(SR.GetString(SR.XmlHierarchyData_CouldNotFindNode));
+        }
+
+        public override string ToString() {
+            return _item.Name;
+        }
+
+
+        bool IHierarchyData.HasChildren {
+            get {
+                return _item.HasChildNodes;
+            }
+        }
+
+        object IHierarchyData.Item {
+            get {
+                return _item;
+            }
+        }
+
+        string IHierarchyData.Path {
+            get {
+                if (_path == null) {
+                    // If we don't yet have a path, create one and cache it
+                    if (_parent != null) {
+                        // If we have a parent enumerable, then our path is the parent's
+                        // path plus our position within that parent.
+                        if (_parent.Path == null) {
+                            _parent.Path = CreateRecursivePath(_item.ParentNode);
+                        }
+                        _path = _parent.Path + FindNodePosition(_item);
+                    }
+                    else {
+                        // If we are not associated with a parent enumerable, we
+                        // have to build up our entire path from scratch.
+                        _path = CreateRecursivePath(_item);
+                    }
+                }
+                return _path;
+            }
+        }
+
+        string IHierarchyData.Type {
+            get {
+                return _item.Name;
+            }
+        }
+
+        IHierarchicalEnumerable IHierarchyData.GetChildren() {
+            return new XmlHierarchicalEnumerable(_item.ChildNodes);
+        }
+
+        IHierarchyData IHierarchyData.GetParent() {
+            XmlNode parentNode = _item.ParentNode;
+            if (parentNode == null)
+                return null;
+
+            return new XmlHierarchyData(null, parentNode);
+        }
+
+        AttributeCollection ICustomTypeDescriptor.GetAttributes() {
+            return AttributeCollection.Empty;
+        }
+
+        string ICustomTypeDescriptor.GetClassName() {
+            return GetType().Name;
+        }
+
+        string ICustomTypeDescriptor.GetComponentName() {
+            return null;
+
+        }
+
+        TypeConverter ICustomTypeDescriptor.GetConverter() {
+            return null;
+        }
+
+        EventDescriptor ICustomTypeDescriptor.GetDefaultEvent() {
+            return null;
+        }
+
+        PropertyDescriptor ICustomTypeDescriptor.GetDefaultProperty() {
+            return new XmlHierarchyDataPropertyDescriptor("#Name");
+        }
+
+        object ICustomTypeDescriptor.GetEditor(Type editorBaseType) {
+            return null;
+        }
+
+        EventDescriptorCollection ICustomTypeDescriptor.GetEvents() {
+            return null;
+        }
+
+        EventDescriptorCollection ICustomTypeDescriptor.GetEvents(Attribute[] attrs) {
+            return null;
+        }
+
+        PropertyDescriptorCollection ICustomTypeDescriptor.GetProperties() {
+            return ((ICustomTypeDescriptor)this).GetProperties(null);
+        }
+
+        PropertyDescriptorCollection ICustomTypeDescriptor.GetProperties(Attribute[] attrFilter) {
+            System.Collections.Generic.List<PropertyDescriptor> list = new System.Collections.Generic.List<PropertyDescriptor>();
+            list.Add(new XmlHierarchyDataPropertyDescriptor("#Name"));
+            list.Add(new XmlHierarchyDataPropertyDescriptor("#Value"));
+            list.Add(new XmlHierarchyDataPropertyDescriptor("#InnerText"));
+
+            XmlAttributeCollection attrs = _item.Attributes;
+            if (attrs != null) {
+                for (int i = 0; i < attrs.Count; i++) {
+                    list.Add(new XmlHierarchyDataPropertyDescriptor(attrs[i].Name));
+                }
+            }
+
+            return new PropertyDescriptorCollection(list.ToArray());
+        }
+
+        object ICustomTypeDescriptor.GetPropertyOwner(PropertyDescriptor pd) {
+            if (pd is XmlHierarchyDataPropertyDescriptor) {
+                return this;
+            }
+
+            return null;
+        }
+
+        private class XmlHierarchyDataPropertyDescriptor : PropertyDescriptor {
+            private string _name;
+
+            public XmlHierarchyDataPropertyDescriptor(string name) : base(name, null) {
+                _name = name;
+            }
+
+
+            public override Type ComponentType {
+                get {
+                    return typeof(XmlHierarchyData);
+                }
+            }
+
+            public override bool IsReadOnly {
+                get {
+                    return true;
+                }
+            }
+
+            public override Type PropertyType {
+                get {
+                    return typeof(string);
+                }
+            }
+
+            public override bool CanResetValue(object o) {
+                return false;
+            }
+
+            public override object GetValue(object o) {
+                XmlHierarchyData data = o as XmlHierarchyData;
+                if (data != null) {
+                    switch (_name) {
+                        case "#Name":
+                            return data._item.Name;
+                        case "#Value":
+                            return data._item.Value;
+                        case "#InnerText":
+                            return data._item.InnerText;
+                        default:
+                            XmlAttributeCollection attrs = data._item.Attributes;
+
+                            if (attrs != null) {
+                                XmlAttribute attr = attrs[_name];
+                                if (attr != null) {
+                                    return attr.Value;
+                                }
+                            }
+                            break;
+                    }
+                }
+
+                return String.Empty;
+            }
+
+            public override void ResetValue(object o) {
+                return;
+            }
+
+            public override void SetValue(object o, object value) {
+            }
+
+            public override bool ShouldSerializeValue(object o) {
+                return true;
+            }
+        }
+    }
+}
+