InversionOfControl/Castle.Windsor/Configuration/Interpreters/XmlProcessor/ElementProcessors/AbstractXmlNodeProcessor.cs

   1 // Copyright 2004-2008 Castle Project - http://www.castleproject.org/
   2 //
   3 // Licensed under the Apache License, Version 2.0 (the "License");
   4 // you may not use this file except in compliance with the License.
   5 // You may obtain a copy of the License at
   6 //
   7 //     http://www.apache.org/licenses/LICENSE-2.0
   8 //
   9 // Unless required by applicable law or agreed to in writing, software
  10 // distributed under the License is distributed on an "AS IS" BASIS,
  11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 // See the License for the specific language governing permissions and
  13 // limitations under the License.
  14
  15 namespace Castle.Windsor.Configuration.Interpreters.XmlProcessor.ElementProcessors
  16 {
  17         using System;
  18         using System.Xml;
  19
  20         public abstract class AbstractXmlNodeProcessor : IXmlNodeProcessor
  21         {
  22                 private static readonly XmlNodeType[] acceptNodes = new XmlNodeType[] {XmlNodeType.Element};
  23
  24                 public AbstractXmlNodeProcessor()
  25                 {
  26                 }
  27
  28                 public abstract String Name { get; }
  29
  30                 public virtual XmlNodeType[] AcceptNodeTypes
  31                 {
  32                         get { return acceptNodes; }
  33                 }
  34
  35                 /// <summary>
  36                 /// Accepts the specified node.
  37                 /// Check if node has the same name as the processor and the node.NodeType
  38                 /// is in the AcceptNodeTypes List
  39                 /// </summary>
  40                 /// <param name="node">The node.</param>
  41                 /// <returns></returns>
  42                 public virtual bool Accept(XmlNode node)
  43                 {
  44                         return node.Name == Name && Array.IndexOf(AcceptNodeTypes, node.NodeType) != -1;
  45                 }
  46
  47                 public abstract void Process(IXmlProcessorNodeList nodeList, IXmlProcessorEngine engine);
  48
  49                 protected virtual bool IgnoreNode(XmlNode node)
  50                 {
  51                         return node.NodeType == XmlNodeType.Comment ||
  52                                 node.NodeType == XmlNodeType.Entity ||
  53                                 node.NodeType == XmlNodeType.EntityReference;
  54                 }
  55
  56                 /// <summary>
  57                 /// Convert and return child parameter into an XmlElement
  58                 /// An exception will be throw in case the child node cannot be converted
  59                 /// </summary>
  60                 /// <param name="element">Parent node</param>
  61                 /// <param name="child">Node to be converted</param>
  62                 /// <returns>child node as XmlElement</returns>
  63                 protected XmlElement GetNodeAsElement(XmlElement element, XmlNode child)
  64                 {
  65                         XmlElement result = child as XmlElement;
  66
  67                         if (result == null)
  68                         {
  69                                 throw new XmlProcessorException("{0} expects XmlElement found {1}", element.Name, child.NodeType);
  70                         }
  71
  72                         return result;
  73                 }
  74
  75                 protected String GetRequiredAttribute(XmlElement element, String attribute)
  76                 {
  77                         String attValue = element.GetAttribute(attribute).Trim();
  78
  79                         if (attValue == "")
  80                         {
  81                                 throw new XmlProcessorException("'{0}' requires a non empty '{1}' attribute", element.Name, attribute);
  82                         }
  83
  84                         return attValue;
  85                 }
  86
  87                 protected XmlNode ImportNode(XmlNode targetElement, XmlNode node)
  88                 {
  89                         return targetElement.OwnerDocument == node.OwnerDocument ?
  90                                 node : targetElement.OwnerDocument.ImportNode(node, true);
  91                 }
  92
  93                 protected void AppendChild(XmlNode element, XmlNodeList nodes)
  94                 {
  95                         DefaultXmlProcessorNodeList childNodes = new DefaultXmlProcessorNodeList(nodes);
  96
  97                         while(childNodes.MoveNext())
  98                         {
  99                                 AppendChild(element, childNodes.Current);
 100                         }
 101                 }
 102
 103                 protected void AppendChild(XmlNode element, string text)
 104                 {
 105                         AppendChild(element, CreateText(element, text));
 106                 }
 107
 108                 protected void AppendChild(XmlNode element, XmlNode child)
 109                 {
 110                         element.AppendChild(ImportNode(element, child));
 111                 }
 112
 113                 protected void ReplaceNode(XmlNode element, XmlNode newNode, XmlNode oldNode)
 114                 {
 115                         if (newNode == oldNode) return;
 116
 117                         XmlNode importedNode = ImportNode(element, newNode);
 118
 119                         element.ReplaceChild(importedNode, oldNode);
 120                 }
 121
 122                 protected XmlText CreateText(XmlNode node, string content)
 123                 {
 124                         return node.OwnerDocument.CreateTextNode(content);
 125                 }
 126
 127                 protected XmlDocumentFragment CreateFragment(XmlNode parentNode)
 128                 {
 129                         return parentNode.OwnerDocument.CreateDocumentFragment();
 130                 }
 131
 132                 protected bool IsTextNode(XmlNode node)
 133                 {
 134                         return node.NodeType == XmlNodeType.Text || node.NodeType == XmlNodeType.CDATA;
 135                 }
 136
 137                 protected void ReplaceItself(XmlNode newNode, XmlNode oldNode)
 138                 {
 139                         ReplaceNode(oldNode.ParentNode, newNode, oldNode);
 140                 }
 141
 142                 protected void RemoveItSelf(XmlNode node)
 143                 {
 144                         node.ParentNode.RemoveChild(node);
 145                 }
 146
 147                 protected void MoveChildNodes(XmlDocumentFragment fragment, XmlElement element)
 148                 {
 149                         while(element.ChildNodes.Count > 0)
 150                         {
 151                                 fragment.AppendChild(element.ChildNodes[0]);
 152                         }
 153                 }
 154         }
 155 }