public WithDefaultsRulesWrapper(Rules wrappedRules) 
{
    
    // --------------------------------------------------------- Constructor
        if (wrappedRules == null) {
            throw new IllegalArgumentException("Wrapped rules must not be null");
        }
        this.wrappedRules = wrappedRules;
}

Base constructor.

Parameters:

wrappedRules - the wrapped Rules implementation, not null

Throws:

IllegalArgumentException - when wrappedRules is null

 public  void add(String pattern,
    Rule rule) 
{
        wrappedRules.add(pattern, rule);
        allRules.add(rule);
}

Adds a Rule to be fired on given pattern. Pattern matching is delegated to wrapped implementation.

 public  void addDefault(Rule rule) 
{
        // set up rule
        if (wrappedRules.getDigester() != null) {
            rule.setDigester(wrappedRules.getDigester());
        }
        if (wrappedRules.getNamespaceURI() != null) {
            rule.setNamespaceURI(wrappedRules.getNamespaceURI());
        }
        defaultRules.add(rule);
        allRules.add(rule);
}

Adds a rule to be fired when wrapped implementation returns no matches

 public  void clear() 
{
        wrappedRules.clear();
        allRules.clear();
        defaultRules.clear();
}

Clears all Rule's

 public List getDefaults() 
{
        return defaultRules;
}

Gets Rule's which will be fired when the wrapped implementation returns no matches

 public Digester getDigester() 
{
        return wrappedRules.getDigester();
}

Gets digester using these Rules

 public String getNamespaceURI() 
{
        return wrappedRules.getNamespaceURI();
}

Gets namespace to apply to Rule's added

 public List match(String pattern) 
{
        return match("", pattern);
}

 public List match(String namespaceURI,
    String pattern) 
{
        List matches = wrappedRules.match(namespaceURI, pattern);
        if (matches ==  null || matches.isEmpty()) {
            // a little bit of defensive programming
            return new ArrayList(defaultRules);
        }
        // otherwise
        return matches;
}

Return list of rules matching given pattern. If wrapped implementation returns any matches return those. Otherwise, return default matches.

 public List rules() 
{
        return allRules;
}

Gets all rules

 public  void setDigester(Digester digester) 
{
        wrappedRules.setDigester(digester);
        Iterator it = defaultRules.iterator();
        while (it.hasNext()) {
            Rule rule = (Rule) it.next();
            rule.setDigester(digester);
        }
}

Sets digeseter using these Rules

 public  void setNamespaceURI(String namespaceURI) 
{
        wrappedRules.setNamespaceURI(namespaceURI);
}

Sets namespace to apply to Rule's added subsequently