public RegexRules(RegexMatcher matcher) 
{
    // --------------------------------------------------------- Constructor
        setRegexMatcher(matcher);
}

Construct sets the Regex matching strategy.

Parameters:

matcher - the regex strategy to be used, not null

Throws:

IllegalArgumentException - if the strategy is null

 public  void clear() 
{
        registeredRules.clear();
}

Clear all existing Rule instance registrations.

 public RegexMatcher getRegexMatcher() 
{
        return matcher;
}

Gets the current regex matching strategy.

 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;
}

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.

 protected  void registerRule(String pattern,
    Rule rule) 
{
        registeredRules.add(new RegisteredRule(pattern, rule));
}

Register a new Rule instance matching the specified pattern.

 public List rules() 
{
        ArrayList rules = new ArrayList(registeredRules.size());
        Iterator it = registeredRules.iterator();
        while (it.hasNext()) {
            rules.add(((RegisteredRule) it.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  void setRegexMatcher(RegexMatcher matcher) 
{
        if (matcher == null) {
            throw new IllegalArgumentException("RegexMatcher must not be null.");
        }
        this.matcher = matcher;
}

Sets the current regex matching strategy.