Rules implementation that uses regular expression matching for paths.
* *The regex implementation is pluggable, allowing different strategies to be used. * The basic way that this class work does not vary. * All patterns are tested to see if they match the path using the regex matcher. * All those that do are return in the order which the rules were added.
* * @author Robert Burrell Donkin * @version $Revision: 1.2 $ $Date: 2003/04/16 11:23:50 $ */ public class RegexRules extends AbstractRulesImpl { // --------------------------------------------------------- Fields /** All registeredRule's */
private ArrayList registeredRules = new ArrayList();
/** The regex strategy used by this RegexRules */
private RegexMatcher matcher;
// --------------------------------------------------------- Constructor
/**
* Construct sets the Regex matching strategy.
*
* @param matcher the regex strategy to be used, not null
* @throws IllegalArgumentException if the strategy is null
*/
public RegexRules(RegexMatcher matcher) {
setRegexMatcher(matcher);
}
// --------------------------------------------------------- Properties
/**
* Gets the current regex matching strategy.
*/
public RegexMatcher getRegexMatcher() {
return matcher;
}
/**
* Sets the current regex matching strategy.
*
* @param matcher use this RegexMatcher, not null
* @throws IllegalArgumentException if the strategy is null
*/
public void setRegexMatcher(RegexMatcher matcher) {
if (matcher == null) {
throw new IllegalArgumentException("RegexMatcher must not be null.");
}
this.matcher = matcher;
}
// --------------------------------------------------------- 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
*/
protected void registerRule(String pattern, Rule rule) {
registeredRules.add(new RegisteredRule(pattern, rule));
}
/**
* Clear all existing Rule instance registrations.
*/
public void clear() {
registeredRules.clear();
}
/**
* Finds matching rules by using current regex matching strategy.
* The rule associated with each path that matches is added to the list of matches.
* The order of matching rules is the same order that they were added.
*
* @param namespaceURI Namespace URI for which to select matching rules,
* or null to match regardless of namespace URI
* @param pattern Nesting pattern to be matched
* @return a list of matching Rule's
*/
public List match(String namespaceURI, String pattern) {
//
// not a particularly quick implementation
// regex is probably going to be slower than string equality
// so probably should have a set of strings
// and test each only once
//
// XXX FIX ME - Time And Optimize
//
ArrayList rules = new ArrayList(registeredRules.size());
Iterator it = registeredRules.iterator();
while (it.hasNext()) {
RegisteredRule next = (RegisteredRule) it.next();
if (matcher.match(pattern, next.pattern)) {
rules.add(next.rule);
}
}
return rules;
}
/**
* 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 must be returned
* in the order originally registered through the add()
* method.
*/
public List rules() {
ArrayList rules = new ArrayList(registeredRules.size());
Iterator it = registeredRules.iterator();
while (it.hasNext()) {
rules.add(((RegisteredRule) it.next()).rule);
}
return rules;
}
/** Used to associate rules with paths in the rules list */
private class RegisteredRule {
String pattern;
Rule rule;
RegisteredRule(String pattern, Rule rule) {
this.pattern = pattern;
this.rule = rule;
}
}
}