| 1 |  |  | 
| 2 |  |  | 
| 3 |  |  | 
| 4 |  |  | 
| 5 |  |  | 
| 6 |  |  | 
| 7 |  |  | 
| 8 |  | package org.dom4j.rule; | 
| 9 |  |  | 
| 10 |  | import java.util.HashMap; | 
| 11 |  | import java.util.Map; | 
| 12 |  |  | 
| 13 |  | import org.dom4j.Attribute; | 
| 14 |  | import org.dom4j.Document; | 
| 15 |  | import org.dom4j.Element; | 
| 16 |  | import org.dom4j.Node; | 
| 17 |  |  | 
| 18 |  |  | 
| 19 |  |  | 
| 20 |  |  | 
| 21 |  |  | 
| 22 |  |  | 
| 23 |  |  | 
| 24 |  |  | 
| 25 |  |  | 
| 26 |  |  | 
| 27 |  |  | 
| 28 |  |  | 
| 29 |  | public class Mode { | 
| 30 |  | private RuleSet[] ruleSets = new RuleSet[Pattern.NUMBER_OF_TYPES]; | 
| 31 |  |  | 
| 32 |  |  | 
| 33 |  | private Map elementNameRuleSets; | 
| 34 |  |  | 
| 35 |  |  | 
| 36 |  | private Map attributeNameRuleSets; | 
| 37 |  |  | 
| 38 | 4 | public Mode() { | 
| 39 |  | } | 
| 40 |  |  | 
| 41 |  |  | 
| 42 |  |  | 
| 43 |  |  | 
| 44 |  |  | 
| 45 |  |  | 
| 46 |  |  | 
| 47 |  |  | 
| 48 |  |  | 
| 49 |  |  | 
| 50 | 30 | public void fireRule(Node node) throws Exception { | 
| 51 | 30 | if (node != null) { | 
| 52 | 30 | Rule rule = getMatchingRule(node); | 
| 53 |  |  | 
| 54 | 30 | if (rule != null) { | 
| 55 | 28 | Action action = rule.getAction(); | 
| 56 |  |  | 
| 57 | 28 | if (action != null) { | 
| 58 | 28 | action.run(node); | 
| 59 |  | } | 
| 60 |  | } | 
| 61 |  | } | 
| 62 |  | } | 
| 63 |  |  | 
| 64 | 5 | public void applyTemplates(Element element) throws Exception { | 
| 65 | 5 | for (int i = 0, size = element.attributeCount(); i < size; i++) { | 
| 66 | 1 | Attribute attribute = element.attribute(i); | 
| 67 | 1 | fireRule(attribute); | 
| 68 |  | } | 
| 69 |  |  | 
| 70 | 5 | for (int i = 0, size = element.nodeCount(); i < size; i++) { | 
| 71 | 13 | Node node = element.node(i); | 
| 72 | 13 | fireRule(node); | 
| 73 |  | } | 
| 74 |  | } | 
| 75 |  |  | 
| 76 | 1 | public void applyTemplates(Document document) throws Exception { | 
| 77 | 1 | for (int i = 0, size = document.nodeCount(); i < size; i++) { | 
| 78 | 1 | Node node = document.node(i); | 
| 79 | 1 | fireRule(node); | 
| 80 |  | } | 
| 81 |  | } | 
| 82 |  |  | 
| 83 | 28 | public void addRule(Rule rule) { | 
| 84 | 28 | int matchType = rule.getMatchType(); | 
| 85 | 28 | String name = rule.getMatchesNodeName(); | 
| 86 |  |  | 
| 87 | 28 | if (name != null) { | 
| 88 | 0 | if (matchType == Node.ELEMENT_NODE) { | 
| 89 | 0 | elementNameRuleSets = addToNameMap(elementNameRuleSets, name, | 
| 90 |  | rule); | 
| 91 | 0 | } else if (matchType == Node.ATTRIBUTE_NODE) { | 
| 92 | 0 | attributeNameRuleSets = addToNameMap(attributeNameRuleSets, | 
| 93 |  | name, rule); | 
| 94 |  | } | 
| 95 |  | } | 
| 96 |  |  | 
| 97 | 28 | if (matchType >= Pattern.NUMBER_OF_TYPES) { | 
| 98 | 0 | matchType = Pattern.ANY_NODE; | 
| 99 |  | } | 
| 100 |  |  | 
| 101 | 28 | if (matchType == Pattern.ANY_NODE) { | 
| 102 |  |  | 
| 103 | 0 | for (int i = 1, size = ruleSets.length; i < size; i++) { | 
| 104 | 0 | RuleSet ruleSet = ruleSets[i]; | 
| 105 |  |  | 
| 106 | 0 | if (ruleSet != null) { | 
| 107 | 0 | ruleSet.addRule(rule); | 
| 108 |  | } | 
| 109 |  | } | 
| 110 |  | } | 
| 111 |  |  | 
| 112 | 28 | getRuleSet(matchType).addRule(rule); | 
| 113 |  | } | 
| 114 |  |  | 
| 115 | 0 | public void removeRule(Rule rule) { | 
| 116 | 0 | int matchType = rule.getMatchType(); | 
| 117 | 0 | String name = rule.getMatchesNodeName(); | 
| 118 |  |  | 
| 119 | 0 | if (name != null) { | 
| 120 | 0 | if (matchType == Node.ELEMENT_NODE) { | 
| 121 | 0 | removeFromNameMap(elementNameRuleSets, name, rule); | 
| 122 | 0 | } else if (matchType == Node.ATTRIBUTE_NODE) { | 
| 123 | 0 | removeFromNameMap(attributeNameRuleSets, name, rule); | 
| 124 |  | } | 
| 125 |  | } | 
| 126 |  |  | 
| 127 | 0 | if (matchType >= Pattern.NUMBER_OF_TYPES) { | 
| 128 | 0 | matchType = Pattern.ANY_NODE; | 
| 129 |  | } | 
| 130 |  |  | 
| 131 | 0 | getRuleSet(matchType).removeRule(rule); | 
| 132 |  |  | 
| 133 | 0 | if (matchType != Pattern.ANY_NODE) { | 
| 134 | 0 | getRuleSet(Pattern.ANY_NODE).removeRule(rule); | 
| 135 |  | } | 
| 136 |  | } | 
| 137 |  |  | 
| 138 |  |  | 
| 139 |  |  | 
| 140 |  |  | 
| 141 |  |  | 
| 142 |  |  | 
| 143 |  |  | 
| 144 |  |  | 
| 145 |  |  | 
| 146 |  |  | 
| 147 | 30 | public Rule getMatchingRule(Node node) { | 
| 148 | 30 | int matchType = node.getNodeType(); | 
| 149 |  |  | 
| 150 | 30 | if (matchType == Node.ELEMENT_NODE) { | 
| 151 | 12 | if (elementNameRuleSets != null) { | 
| 152 | 0 | String name = node.getName(); | 
| 153 | 0 | RuleSet ruleSet = (RuleSet) elementNameRuleSets.get(name); | 
| 154 |  |  | 
| 155 | 0 | if (ruleSet != null) { | 
| 156 | 0 | Rule answer = ruleSet.getMatchingRule(node); | 
| 157 |  |  | 
| 158 | 0 | if (answer != null) { | 
| 159 | 0 | return answer; | 
| 160 |  | } | 
| 161 |  | } | 
| 162 |  | } | 
| 163 | 18 | } else if (matchType == Node.ATTRIBUTE_NODE) { | 
| 164 | 1 | if (attributeNameRuleSets != null) { | 
| 165 | 0 | String name = node.getName(); | 
| 166 | 0 | RuleSet ruleSet = (RuleSet) attributeNameRuleSets.get(name); | 
| 167 |  |  | 
| 168 | 0 | if (ruleSet != null) { | 
| 169 | 0 | Rule answer = ruleSet.getMatchingRule(node); | 
| 170 |  |  | 
| 171 | 0 | if (answer != null) { | 
| 172 | 0 | return answer; | 
| 173 |  | } | 
| 174 |  | } | 
| 175 |  | } | 
| 176 |  | } | 
| 177 |  |  | 
| 178 | 30 | if ((matchType < 0) || (matchType >= ruleSets.length)) { | 
| 179 | 0 | matchType = Pattern.ANY_NODE; | 
| 180 |  | } | 
| 181 |  |  | 
| 182 | 30 | Rule answer = null; | 
| 183 | 30 | RuleSet ruleSet = ruleSets[matchType]; | 
| 184 |  |  | 
| 185 | 30 | if (ruleSet != null) { | 
| 186 |  |  | 
| 187 | 28 | answer = ruleSet.getMatchingRule(node); | 
| 188 |  | } | 
| 189 |  |  | 
| 190 | 30 | if ((answer == null) && (matchType != Pattern.ANY_NODE)) { | 
| 191 |  |  | 
| 192 | 2 | ruleSet = ruleSets[Pattern.ANY_NODE]; | 
| 193 |  |  | 
| 194 | 2 | if (ruleSet != null) { | 
| 195 | 0 | answer = ruleSet.getMatchingRule(node); | 
| 196 |  | } | 
| 197 |  | } | 
| 198 |  |  | 
| 199 | 30 | return answer; | 
| 200 |  | } | 
| 201 |  |  | 
| 202 |  |  | 
| 203 |  |  | 
| 204 |  |  | 
| 205 |  |  | 
| 206 |  |  | 
| 207 |  |  | 
| 208 |  |  | 
| 209 |  |  | 
| 210 |  |  | 
| 211 | 28 | protected RuleSet getRuleSet(int matchType) { | 
| 212 | 28 | RuleSet ruleSet = ruleSets[matchType]; | 
| 213 |  |  | 
| 214 | 28 | if (ruleSet == null) { | 
| 215 | 14 | ruleSet = new RuleSet(); | 
| 216 | 14 | ruleSets[matchType] = ruleSet; | 
| 217 |  |  | 
| 218 |  |  | 
| 219 | 14 | if (matchType != Pattern.ANY_NODE) { | 
| 220 | 14 | RuleSet allRules = ruleSets[Pattern.ANY_NODE]; | 
| 221 |  |  | 
| 222 | 14 | if (allRules != null) { | 
| 223 | 0 | ruleSet.addAll(allRules); | 
| 224 |  | } | 
| 225 |  | } | 
| 226 |  | } | 
| 227 |  |  | 
| 228 | 28 | return ruleSet; | 
| 229 |  | } | 
| 230 |  |  | 
| 231 |  |  | 
| 232 |  |  | 
| 233 |  |  | 
| 234 |  |  | 
| 235 |  |  | 
| 236 |  |  | 
| 237 |  |  | 
| 238 |  |  | 
| 239 |  |  | 
| 240 |  |  | 
| 241 |  |  | 
| 242 |  |  | 
| 243 | 0 | protected Map addToNameMap(Map map, String name, Rule rule) { | 
| 244 | 0 | if (map == null) { | 
| 245 | 0 | map = new HashMap(); | 
| 246 |  | } | 
| 247 |  |  | 
| 248 | 0 | RuleSet ruleSet = (RuleSet) map.get(name); | 
| 249 |  |  | 
| 250 | 0 | if (ruleSet == null) { | 
| 251 | 0 | ruleSet = new RuleSet(); | 
| 252 | 0 | map.put(name, ruleSet); | 
| 253 |  | } | 
| 254 |  |  | 
| 255 | 0 | ruleSet.addRule(rule); | 
| 256 |  |  | 
| 257 | 0 | return map; | 
| 258 |  | } | 
| 259 |  |  | 
| 260 | 0 | protected void removeFromNameMap(Map map, String name, Rule rule) { | 
| 261 | 0 | if (map != null) { | 
| 262 | 0 | RuleSet ruleSet = (RuleSet) map.get(name); | 
| 263 |  |  | 
| 264 | 0 | if (ruleSet != null) { | 
| 265 | 0 | ruleSet.removeRule(rule); | 
| 266 |  | } | 
| 267 |  | } | 
| 268 |  | } | 
| 269 |  | } | 
| 270 |  |  | 
| 271 |  |  | 
| 272 |  |  | 
| 273 |  |  | 
| 274 |  |  | 
| 275 |  |  | 
| 276 |  |  | 
| 277 |  |  | 
| 278 |  |  | 
| 279 |  |  | 
| 280 |  |  | 
| 281 |  |  | 
| 282 |  |  | 
| 283 |  |  | 
| 284 |  |  | 
| 285 |  |  | 
| 286 |  |  | 
| 287 |  |  | 
| 288 |  |  | 
| 289 |  |  | 
| 290 |  |  | 
| 291 |  |  | 
| 292 |  |  | 
| 293 |  |  | 
| 294 |  |  | 
| 295 |  |  | 
| 296 |  |  | 
| 297 |  |  | 
| 298 |  |  | 
| 299 |  |  | 
| 300 |  |  | 
| 301 |  |  | 
| 302 |  |  | 
| 303 |  |  | 
| 304 |  |  | 
| 305 |  |  | 
| 306 |  |  |