The Labs \ Source Viewer \ SSCLI \ System.Xml \ XmlNamedNodeMap

  1. //------------------------------------------------------------------------------
  2. // <copyright file="XmlNamedNodeMap.cs" company="Microsoft">
  3. //
  4. // Copyright (c) 2006 Microsoft Corporation. All rights reserved.
  5. //
  6. // The use and distribution terms for this software are contained in the file
  7. // named license.txt, which can be found in the root of this distribution.
  8. // By using this software in any fashion, you are agreeing to be bound by the
  9. // terms of this license.
  10. //
  11. // You must not remove this notice, or any other, from this software.
  12. //
  13. // </copyright>
  14. //------------------------------------------------------------------------------
  15. namespace System.Xml
  16. {
  17.     using System.Collections;
  18.    
  19.     // Represents a collection of nodes that can be accessed by name or index.
  20.     public class XmlNamedNodeMap : IEnumerable
  21.     {
  22.         internal XmlNode parent;
  23.         internal ArrayList nodes;
  24.        
  25.         internal XmlNamedNodeMap(XmlNode parent)
  26.         {
  27.             this.parent = parent;
  28.             this.nodes = null;
  29.         }
  30.        
  31.         // Retrieves a XmlNode specified by name.
  32.         public virtual XmlNode GetNamedItem(string name)
  33.         {
  34.             int offset = FindNodeOffset(name);
  35.             if (offset >= 0)
  36.                 return (XmlNode)Nodes[offset];
  37.             return null;
  38.         }
  39.        
  40.         // Adds a XmlNode using its Name property
  41.         public virtual XmlNode SetNamedItem(XmlNode node)
  42.         {
  43.             if (node == null)
  44.                 return null;
  45.            
  46.             int offset = FindNodeOffset(node.LocalName, node.NamespaceURI);
  47.             if (offset == -1) {
  48.                 AddNode(node);
  49.                 return null;
  50.             }
  51.             else {
  52.                 return ReplaceNodeAt(offset, node);
  53.             }
  54.         }
  55.        
  56.         // Removes the node specified by name.
  57.         public virtual XmlNode RemoveNamedItem(string name)
  58.         {
  59.             int offset = FindNodeOffset(name);
  60.             if (offset >= 0) {
  61.                 return RemoveNodeAt(offset);
  62.             }
  63.             return null;
  64.         }
  65.        
  66.         // Gets the number of nodes in this XmlNamedNodeMap.
  67.         public virtual int Count {
  68.             get {
  69.                 if (nodes != null)
  70.                     return nodes.Count;
  71.                 return 0;
  72.             }
  73.         }
  74.        
  75.         // Retrieves the node at the specified index in this XmlNamedNodeMap.
  76.         public virtual XmlNode Item(int index)
  77.         {
  78.             if (index < 0 || index >= Nodes.Count)
  79.                 return null;
  80.             try {
  81.                 return (XmlNode)Nodes[index];
  82.             }
  83.             catch (ArgumentOutOfRangeException) {
  84.                 throw new IndexOutOfRangeException(Res.GetString(Res.Xdom_IndexOutOfRange));
  85.             }
  86.         }
  87.        
  88.         //
  89.         // DOM Level 2
  90.         //
  91.        
  92.         // Retrieves a node specified by LocalName and NamespaceURI.
  93.         public virtual XmlNode GetNamedItem(string localName, string namespaceURI)
  94.         {
  95.             int offset = FindNodeOffset(localName, namespaceURI);
  96.             if (offset >= 0)
  97.                 return (XmlNode)Nodes[offset];
  98.             return null;
  99.         }
  100.        
  101.         // Removes a node specified by local name and namespace URI.
  102.         public virtual XmlNode RemoveNamedItem(string localName, string namespaceURI)
  103.         {
  104.             int offset = FindNodeOffset(localName, namespaceURI);
  105.             if (offset >= 0) {
  106.                 return RemoveNodeAt(offset);
  107.             }
  108.             return null;
  109.         }
  110.        
  111.         internal ArrayList Nodes {
  112.             get {
  113.                 if (nodes == null)
  114.                     nodes = new ArrayList();
  115.                
  116.                 return nodes;
  117.             }
  118.         }
  119.        
  120.         public virtual IEnumerator GetEnumerator()
  121.         {
  122.             if (nodes == null) {
  123.                 return XmlDocument.EmptyEnumerator;
  124.             }
  125.             else {
  126.                 return Nodes.GetEnumerator();
  127.             }
  128.         }
  129.        
  130.         internal int FindNodeOffset(string name)
  131.         {
  132.             int c = this.Count;
  133.             for (int i = 0; i < c; i++) {
  134.                 XmlNode node = (XmlNode)Nodes[i];
  135.                
  136.                 if (name == node.Name)
  137.                     return i;
  138.             }
  139.            
  140.             return -1;
  141.         }
  142.        
  143.         internal int FindNodeOffset(string localName, string namespaceURI)
  144.         {
  145.             int c = this.Count;
  146.             for (int i = 0; i < c; i++) {
  147.                 XmlNode node = (XmlNode)Nodes[i];
  148.                
  149.                 if (node.LocalName == localName && node.NamespaceURI == namespaceURI)
  150.                     return i;
  151.             }
  152.            
  153.             return -1;
  154.         }
  155.        
  156.         internal virtual XmlNode AddNode(XmlNode node)
  157.         {
  158.             XmlNode oldParent;
  159.             if (node.NodeType == XmlNodeType.Attribute)
  160.                 oldParent = ((XmlAttribute)node).OwnerElement;
  161.             else
  162.                 oldParent = node.ParentNode;
  163.             string nodeValue = node.Value;
  164.             XmlNodeChangedEventArgs args = parent.GetEventArgs(node, oldParent, parent, nodeValue, nodeValue, XmlNodeChangedAction.Insert);
  165.            
  166.             if (args != null)
  167.                 parent.BeforeEvent(args);
  168.            
  169.             Nodes.Add(node);
  170.             node.SetParent(parent);
  171.            
  172.             if (args != null)
  173.                 parent.AfterEvent(args);
  174.            
  175.             return node;
  176.         }
  177.        
  178.         internal virtual XmlNode AddNodeForLoad(XmlNode node, XmlDocument doc)
  179.         {
  180.             XmlNodeChangedEventArgs args = doc.GetInsertEventArgsForLoad(node, parent);
  181.             if (args != null) {
  182.                 doc.BeforeEvent(args);
  183.             }
  184.             Nodes.Add(node);
  185.             node.SetParent(parent);
  186.             if (args != null) {
  187.                 doc.AfterEvent(args);
  188.             }
  189.             return node;
  190.         }
  191.        
  192.         internal virtual XmlNode RemoveNodeAt(int i)
  193.         {
  194.             XmlNode oldNode = (XmlNode)Nodes[i];
  195.            
  196.             string oldNodeValue = oldNode.Value;
  197.             XmlNodeChangedEventArgs args = parent.GetEventArgs(oldNode, parent, null, oldNodeValue, oldNodeValue, XmlNodeChangedAction.Remove);
  198.            
  199.             if (args != null)
  200.                 parent.BeforeEvent(args);
  201.            
  202.             Nodes.RemoveAt(i);
  203.             oldNode.SetParent(null);
  204.            
  205.             if (args != null)
  206.                 parent.AfterEvent(args);
  207.            
  208.             return oldNode;
  209.         }
  210.        
  211.         internal XmlNode ReplaceNodeAt(int i, XmlNode node)
  212.         {
  213.             XmlNode oldNode = RemoveNodeAt(i);
  214.             InsertNodeAt(i, node);
  215.             return oldNode;
  216.         }
  217.        
  218.         internal virtual XmlNode InsertNodeAt(int i, XmlNode node)
  219.         {
  220.             XmlNode oldParent;
  221.             if (node.NodeType == XmlNodeType.Attribute)
  222.                 oldParent = ((XmlAttribute)node).OwnerElement;
  223.             else
  224.                 oldParent = node.ParentNode;
  225.            
  226.             string nodeValue = node.Value;
  227.             XmlNodeChangedEventArgs args = parent.GetEventArgs(node, oldParent, parent, nodeValue, nodeValue, XmlNodeChangedAction.Insert);
  228.            
  229.             if (args != null)
  230.                 parent.BeforeEvent(args);
  231.            
  232.             Nodes.Insert(i, node);
  233.             node.SetParent(parent);
  234.            
  235.             if (args != null)
  236.                 parent.AfterEvent(args);
  237.            
  238.             return node;
  239.         }
  240.     }
  241. }

Developer Fusion