Java tutorial
/* $Id: RulesBase.java 992060 2010-09-02 19:09:47Z simonetripodi $ * * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You under the Apache License, Version 2.0 * (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.apache.commons.digester; import java.util.ArrayList; import java.util.HashMap; import java.util.List; /** * <p>Default implementation of the <code>Rules</code> interface that supports * the standard rule matching behavior. This class can also be used as a * base class for specialized <code>Rules</code> implementations.</p> * * <p>The matching policies implemented by this class support two different * types of pattern matching rules:</p> * <ul> * <li><em>Exact Match</em> - A pattern "a/b/c" exactly matches a * <code><c></code> element, nested inside a <code><b></code> * element, which is nested inside an <code><a></code> element.</li> * <li><em>Tail Match</em> - A pattern "*/a/b" matches a * <code><b></code> element, nested inside an <code><a></code> * element, no matter how deeply the pair is nested.</li> * </ul> * * <p>Note that wildcard patterns are ignored if an explicit match can be found * (and when multiple wildcard patterns match, only the longest, ie most * explicit, pattern is considered a match).</p> * * <p>See the package documentation for package org.apache.commons.digester * for more information.</p> */ public class RulesBase implements Rules { // ----------------------------------------------------- Instance Variables /** * The set of registered Rule instances, keyed by the matching pattern. * Each value is a List containing the Rules for that pattern, in the * order that they were orginally registered. */ protected HashMap<String, List<Rule>> cache = new HashMap<String, List<Rule>>(); /** * The Digester instance with which this Rules instance is associated. */ protected Digester digester = null; /** * The namespace URI for which subsequently added <code>Rule</code> * objects are relevant, or <code>null</code> for matching independent * of namespaces. */ protected String namespaceURI = null; /** * The set of registered Rule instances, in the order that they were * originally registered. */ protected ArrayList<Rule> rules = new ArrayList<Rule>(); // ------------------------------------------------------------- Properties /** * Return the Digester instance with which this Rules instance is * associated. */ public Digester getDigester() { return (this.digester); } /** * Set the Digester instance with which this Rules instance is associated. * * @param digester The newly associated Digester instance */ public void setDigester(Digester digester) { this.digester = digester; for (Rule rule : rules) { rule.setDigester(digester); } } /** * Return the namespace URI that will be applied to all subsequently * added <code>Rule</code> objects. */ public String getNamespaceURI() { return (this.namespaceURI); } /** * Set the namespace URI that will be applied to all subsequently * added <code>Rule</code> objects. * * @param namespaceURI Namespace URI that must match on all * subsequently added rules, or <code>null</code> for matching * regardless of the current namespace URI */ public void setNamespaceURI(String namespaceURI) { this.namespaceURI = namespaceURI; } // --------------------------------------------------------- Public Methods /** * Register a new Rule instance matching the specified pattern. * * @param pattern Nesting pattern to be matched for this Rule * @param rule Rule instance to be registered */ public void add(String pattern, Rule rule) { // to help users who accidently add '/' to the end of their patterns int patternLength = pattern.length(); if (patternLength > 1 && pattern.endsWith("/")) { pattern = pattern.substring(0, patternLength - 1); } List<Rule> list = cache.get(pattern); if (list == null) { list = new ArrayList<Rule>(); cache.put(pattern, list); } list.add(rule); rules.add(rule); if (this.digester != null) { rule.setDigester(this.digester); } if (this.namespaceURI != null) { rule.setNamespaceURI(this.namespaceURI); } } /** * Clear all existing Rule instance registrations. */ public void clear() { cache.clear(); rules.clear(); } /** * Return a List of all registered Rule instances that match the specified * nesting pattern, or a zero-length List if there are no matches. If more * than one Rule instance matches, they <strong>must</strong> be returned * in the order originally registered through the <code>add()</code> * method. * * @param pattern Nesting pattern to be matched * * @deprecated Call match(namespaceURI,pattern) instead. */ @Deprecated public List<Rule> match(String pattern) { return (match(null, pattern)); } /** * Return a List of all registered Rule instances that match the specified * nesting pattern, or a zero-length List if there are no matches. If more * than one Rule instance matches, they <strong>must</strong> be returned * in the order originally registered through the <code>add()</code> * method. * * @param namespaceURI Namespace URI for which to select matching rules, * or <code>null</code> to match regardless of namespace URI * @param pattern Nesting pattern to be matched */ public List<Rule> match(String namespaceURI, String pattern) { // List rulesList = (List) this.cache.get(pattern); List<Rule> rulesList = lookup(namespaceURI, pattern); if ((rulesList == null) || (rulesList.size() < 1)) { // Find the longest key, ie more discriminant String longKey = ""; for (String key : cache.keySet()) { if (key.startsWith("*/")) { if (pattern.equals(key.substring(2)) || pattern.endsWith(key.substring(1))) { if (key.length() > longKey.length()) { // rulesList = (List) this.cache.get(key); rulesList = lookup(namespaceURI, key); longKey = key; } } } } } if (rulesList == null) { rulesList = new ArrayList<Rule>(); } return (rulesList); } /** * Return a List of all registered Rule instances, or a zero-length List * if there are no registered Rule instances. If more than one Rule * instance has been registered, they <strong>must</strong> be returned * in the order originally registered through the <code>add()</code> * method. */ public List<Rule> rules() { return (this.rules); } // ------------------------------------------------------ Protected Methods /** * Return a List of Rule instances for the specified pattern that also * match the specified namespace URI (if any). If there are no such * rules, return <code>null</code>. * * @param namespaceURI Namespace URI to match, or <code>null</code> to * select matching rules regardless of namespace URI * @param pattern Pattern to be matched */ protected List<Rule> lookup(String namespaceURI, String pattern) { // Optimize when no namespace URI is specified List<Rule> list = this.cache.get(pattern); if (list == null) { return (null); } if ((namespaceURI == null) || (namespaceURI.length() == 0)) { return (list); } // Select only Rules that match on the specified namespace URI ArrayList<Rule> results = new ArrayList<Rule>(); for (Rule item : list) { if ((namespaceURI.equals(item.getNamespaceURI())) || (item.getNamespaceURI() == null)) { results.add(item); } } return (results); } }