InversionOfControl/Castle.Windsor/Configuration/Interpreters/XmlProcessor/ElementProcessors/IfProcessingInstructionProcessor.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.Collections;
  19         using System.Xml;
  20
  21         enum StatementState
  22         {
  23                 Init,
  24                 Collect,
  25                 Finished
  26         }
  27
  28         public class IfProcessingInstructionProcessor : AbstractXmlNodeProcessor
  29         {
  30                 private static readonly XmlNodeType[] acceptNodes = new XmlNodeType[] {XmlNodeType.ProcessingInstruction};
  31
  32                 private static readonly String IfPiName = "if";
  33                 private static readonly String EndPiName = "end";
  34                 private static readonly String ElsePiName = "else";
  35                 private static readonly String ElsifPiName = "elsif";
  36
  37                 public IfProcessingInstructionProcessor()
  38                 {
  39                 }
  40
  41                 public override String Name
  42                 {
  43                         get { return IfPiName; }
  44                 }
  45
  46                 public override XmlNodeType[] AcceptNodeTypes
  47                 {
  48                         get { return acceptNodes; }
  49                 }
  50
  51                 public override void Process(IXmlProcessorNodeList nodeList, IXmlProcessorEngine engine)
  52                 {
  53                         XmlProcessingInstruction node = nodeList.Current as XmlProcessingInstruction;
  54
  55                         AssertData(node, true);
  56
  57                         StatementState state = engine.HasFlag(node.Data) ? StatementState.Collect : StatementState.Init;
  58
  59                         ArrayList nodesToProcess = new ArrayList();
  60                         int nestedLevels = 0;
  61
  62                         RemoveItSelf(nodeList.Current);
  63
  64                         while(nodeList.MoveNext())
  65                         {
  66                                 if (nodeList.Current.NodeType == XmlNodeType.ProcessingInstruction)
  67                                 {
  68                                         XmlProcessingInstruction pi = nodeList.Current as XmlProcessingInstruction;
  69
  70                                         if (pi.Name == EndPiName)
  71                                         {
  72                                                 nestedLevels--;
  73
  74                                                 if (nestedLevels < 0)
  75                                                 {
  76                                                         RemoveItSelf(nodeList.Current);
  77                                                         break;
  78                                                 }
  79                                         }
  80                                         else if (pi.Name == IfPiName)
  81                                         {
  82                                                 nestedLevels++;
  83                                         }
  84                                         else if (nestedLevels == 0)
  85                                         {
  86                                                 if (pi.Name == ElsePiName || pi.Name == ElsifPiName)
  87                                                 {
  88                                                         ProcessElseElement(pi, engine, ref state);
  89                                                         continue;
  90                                                 }
  91                                         }
  92                                 }
  93
  94                                 if (state == StatementState.Collect)
  95                                 {
  96                                         nodesToProcess.Add(nodeList.Current);
  97                                 }
  98                                 else
  99                                 {
 100                                         RemoveItSelf(nodeList.Current);
 101                                 }
 102                         }
 103
 104                         if (nestedLevels != -1)
 105                         {
 106                                 throw new XmlProcessorException("Unbalanced pi if element");
 107                         }
 108
 109                         if (nodesToProcess.Count > 0)
 110                         {
 111                                 engine.DispatchProcessAll(new DefaultXmlProcessorNodeList(nodesToProcess));
 112                         }
 113                 }
 114
 115                 private void ProcessElseElement(XmlProcessingInstruction pi, IXmlProcessorEngine engine, ref StatementState state)
 116                 {
 117                         AssertData(pi, pi.Name == ElsifPiName);
 118
 119                         if (state == StatementState.Collect)
 120                         {
 121                                 state = StatementState.Finished;
 122                         }
 123                         else if (pi.Name == ElsePiName || engine.HasFlag(pi.Data))
 124                         {
 125                                 if (state == StatementState.Init)
 126                                 {
 127                                         state = StatementState.Collect;
 128                                 }
 129                         }
 130
 131                         RemoveItSelf(pi);
 132                         return;
 133                 }
 134
 135                 private void AssertData(XmlProcessingInstruction pi, bool requireData)
 136                 {
 137                         String data = pi.Data.Trim();
 138
 139                         if (data == "" && requireData)
 140                         {
 141                                 throw new XmlProcessorException("Element '{0}' must have a flag attribute", pi.Name);
 142                         }
 143                         else if (data != "")
 144                         {
 145                                 if (!requireData)
 146                                 {
 147                                         throw new XmlProcessorException("Element '{0}' cannot have any attributes", pi.Name);
 148                                 }
 149                         }
 150                 }
 151         }
 152 }