InversionOfControl/Castle.Windsor/Configuration/Interpreters/XmlProcessor/DefaultXmlProcessorEngine.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
  16 {
  17         using System;
  18         using System.Collections;
  19         using System.Collections.Specialized;
  20         using System.Text.RegularExpressions;
  21         using System.Xml;
  22
  23         using Castle.MicroKernel.SubSystems.Resource;
  24         using Castle.Core.Resource;
  25
  26         using ElementProcessors;
  27
  28         public class DefaultXmlProcessorEngine : IXmlProcessorEngine
  29         {
  30                 private readonly Regex flagPattern = new Regex(@"^(\w|_)+$");
  31                 private readonly IDictionary properties = new HybridDictionary();
  32                 private readonly IDictionary flags = new HybridDictionary();
  33                 private readonly Stack resourceStack = new Stack();
  34                 private readonly Hashtable nodeProcessors = new Hashtable();
  35                 private readonly IXmlNodeProcessor defaultElementProcessor;
  36                 private IResourceSubSystem resourceSubSystem;
  37
  38                 /// <summary>
  39                 /// Initializes a new instance of the <see cref="DefaultXmlProcessorEngine"/> class.
  40                 /// </summary>
  41                 /// <param name="environmentName">Name of the environment.</param>
  42                 public DefaultXmlProcessorEngine(string environmentName) : this(environmentName, new DefaultResourceSubSystem())
  43                 {
  44                 }
  45
  46                 /// <summary>
  47                 /// Initializes a new instance of the <see cref="DefaultXmlProcessorEngine"/> class.
  48                 /// </summary>
  49                 /// <param name="environmentName">Name of the environment.</param>
  50                 /// <param name="resourceSubSystem">The resource sub system.</param>
  51                 public DefaultXmlProcessorEngine(string environmentName, IResourceSubSystem resourceSubSystem)
  52                 {
  53                         AddEnvNameAsFlag(environmentName);
  54                         this.resourceSubSystem = resourceSubSystem;
  55                         defaultElementProcessor = new DefaultElementProcessor();
  56                 }
  57
  58                 public void AddNodeProcessor(Type type)
  59                 {
  60                         if (typeof(IXmlNodeProcessor).IsAssignableFrom(type))
  61                         {
  62                                 IXmlNodeProcessor processor = Activator.CreateInstance(type) as IXmlNodeProcessor;
  63
  64                                 foreach(XmlNodeType nodeType in processor.AcceptNodeTypes)
  65                                 {
  66                                         RegisterProcessor(nodeType, processor);
  67                                 }
  68                         }
  69                         else
  70                         {
  71                                 throw new XmlProcessorException("{0} does not implement IElementProcessor interface", type.FullName);
  72                         }
  73                 }
  74
  75                 /// <summary>
  76                 /// Processes the element.
  77                 /// </summary>
  78                 /// <param name="nodeList">The element.</param>
  79                 /// <returns></returns>
  80                 public void DispatchProcessAll(IXmlProcessorNodeList nodeList)
  81                 {
  82                         while(nodeList.MoveNext())
  83                         {
  84                                 DispatchProcessCurrent(nodeList);
  85                         }
  86                 }
  87
  88                 /// <summary>
  89                 /// Processes the element.
  90                 /// </summary>
  91                 /// <param name="nodeList">The element.</param>
  92                 /// <returns></returns>
  93                 public void DispatchProcessCurrent(IXmlProcessorNodeList nodeList)
  94                 {
  95                         IXmlNodeProcessor processor = GetProcessor(nodeList.Current);
  96
  97                         if (processor != null)
  98                         {
  99                                 processor.Process(nodeList, this);
 100                         }
 101                 }
 102
 103                 private IXmlNodeProcessor GetProcessor(XmlNode node)
 104                 {
 105                         IXmlNodeProcessor processor = null;
 106                         IDictionary processors = nodeProcessors[node.NodeType] as IDictionary;
 107
 108                         if (processors != null)
 109                         {
 110                                 processor = processors[node.Name] as IXmlNodeProcessor;
 111
 112                                 // sometimes nodes with the same name will not accept a processor
 113                                 if (processor == null || !processor.Accept(node))
 114                                 {
 115                                         if (node.NodeType == XmlNodeType.Element)
 116                                         {
 117                                                 processor = defaultElementProcessor;
 118                                         }
 119                                 }
 120                         }
 121
 122                         return processor;
 123                 }
 124
 125                 private void RegisterProcessor(XmlNodeType type, IXmlNodeProcessor processor)
 126                 {
 127                         if (!nodeProcessors.Contains(type))
 128                         {
 129                                 nodeProcessors[type] = new Hashtable();
 130                         }
 131
 132                         IDictionary typeProcessors = nodeProcessors[type] as IDictionary;
 133
 134                         if (typeProcessors.Contains(processor.Name))
 135                         {
 136                                 throw new XmlProcessorException("There is already a processor register for {0} with name {1} ", type, processor.Name);
 137                         }
 138                         else
 139                         {
 140                                 typeProcessors.Add(processor.Name, processor);
 141                         }
 142                 }
 143
 144                 public bool HasFlag(string flag)
 145                 {
 146                         return flags.Contains(GetCanonicalFlagName(flag));
 147                 }
 148
 149                 public void AddFlag(string flag)
 150                 {
 151                         flags[GetCanonicalFlagName(flag)] = true;
 152                 }
 153
 154                 public void RemoveFlag(string flag)
 155                 {
 156                         flags.Remove(GetCanonicalFlagName(flag));
 157                 }
 158
 159                 public void PushResource(IResource resource)
 160                 {
 161                         resourceStack.Push(resource);
 162                 }
 163
 164                 public void PopResource()
 165                 {
 166                         resourceStack.Pop();
 167                 }
 168
 169                 public bool HasSpecialProcessor( XmlNode node )
 170                 {
 171                         return GetProcessor(node) != defaultElementProcessor;
 172                 }
 173
 174                 public IResource GetResource(String uri)
 175                 {
 176                         IResource resource = resourceStack.Count > 0 ? resourceStack.Peek() as IResource : null;
 177
 178                         if (uri.IndexOf(Uri.SchemeDelimiter) != -1)
 179                         {
 180                                 return resource == null ? resourceSubSystem.CreateResource(uri) :
 181                                         resourceSubSystem.CreateResource(uri, resource.FileBasePath);
 182                         }
 183                         else if (resourceStack.Count > 0)
 184                         {
 185                                 return resource.CreateRelative(uri);
 186                         }
 187                         else
 188                         {
 189                                 throw new XmlProcessorException("Cannot get relative resource '" + uri + "', resource stack is empty");
 190                         }
 191                 }
 192
 193                 public void AddProperty(XmlElement content)
 194                 {
 195                         properties[content.Name] = content;
 196                 }
 197
 198                 public bool HasProperty(String name)
 199                 {
 200                         return properties.Contains(name);
 201                 }
 202
 203                 public XmlElement GetProperty(string key)
 204                 {
 205                         XmlElement prop = properties[key] as XmlElement;
 206
 207                         return prop == null ? null : prop.CloneNode(true) as XmlElement;
 208                 }
 209
 210                 private void AddEnvNameAsFlag(string environmentName)
 211                 {
 212                         if (environmentName != null)
 213                         {
 214                                 AddFlag(environmentName);
 215                         }
 216                 }
 217
 218                 private string GetCanonicalFlagName(string flag)
 219                 {
 220                         flag = flag.Trim().ToLower();
 221
 222                         if (!flagPattern.IsMatch(flag))
 223                         {
 224                                 throw new XmlProcessorException("Invalid flag name '{0}'", flag);
 225                         }
 226
 227                         return flag;
 228                 }
 229         }
 230 }