Handles all wildcard pattern matching.

The compiled patterns and their associated target objects

 public AbstractMatcher(PatternMatcher<?> helper) 
{
        this.wildcard = (PatternMatcher< Object >) helper;
}

 public  void addPattern(String name,
    E target,
    boolean looseMatch) 
{
        Object pattern;
        if (!wildcard.isLiteral(name)) {
            if (looseMatch && (name.length()  > 0) && (name.charAt(0) == '/')) {
                name = name.substring(1);
            }
            if (log.isDebugEnabled()) {
                log.debug("Compiling pattern '" + name + "'");
            }
            pattern = wildcard.compilePattern(name);
            compiledPatterns.add(new Mapping< E >(name, pattern, target));
            if (looseMatch) {
                int lastStar = name.lastIndexOf('*');
                if (lastStar  > 1 && lastStar == name.length() - 1) {
                    if (name.charAt(lastStar - 1) != '*') {
                        pattern = wildcard.compilePattern(name.substring(0, lastStar - 1));
                        compiledPatterns.add(new Mapping< E >(name, pattern, target));
                    }
                }
            }
        }
}

Finds and precompiles the wildcard patterns. Patterns will be evaluated in the order they were added. Only patterns that actually contain a wildcard will be compiled.

Patterns can optionally be matched "loosely". When the end of the pattern matches \*[^*]\*$ (wildcard, no wildcard, wildcard), if the pattern fails, it is also matched as if the last two characters didn't exist. The goal is to support the legacy "*!*" syntax, where the "!*" is optional.

 abstract protected E convert(String path,
    E orig,
    Map<String, String> vars)
 Clones the target object and its children, replacing various
properties with the values of the wildcard-matched strings. 

 protected String convertParam(String val,
    Map<String, String> vars) 
{
        if (val == null) {
            return null;
        } 
        int len = val.length();
        StringBuilder ret = new StringBuilder();
        char c;
        String varVal;
        for (int x=0; x< len; x++) {
            c = val.charAt(x);
            if (x <  len - 2 && 
                    c == '{' && '}' == val.charAt(x+2)) {
                varVal = (String)vars.get(String.valueOf(val.charAt(x + 1)));
                if (varVal != null) {
                    ret.append(varVal);
                } 
                x += 2;
            } else {
                ret.append(c);
            }
        }
        return ret.toString();
}

Inserts into a value wildcard-matched strings where specified with the {x} syntax. If a wildcard-matched value isn't found, the replacement token is turned into an empty string.

 public  void freeze() 
{
        compiledPatterns = Collections.unmodifiableList(new ArrayList< Mapping< E > >());
}

 public E match(String potentialMatch) 
{
        E config = null;
        if (compiledPatterns.size()  > 0) {
            if (log.isDebugEnabled()) {
                log.debug("Attempting to match '" + potentialMatch
                    + "' to a wildcard pattern, "+ compiledPatterns.size()
                    + " available");
            }
            Map< String,String > vars = new LinkedHashMap< String,String >();
            for (Mapping< E > m : compiledPatterns) {
                if (wildcard.match(vars, potentialMatch, m.getPattern())) {
                    if (log.isDebugEnabled()) {
                        log.debug("Value matches pattern '"
                            + m.getOriginalPattern() + "'");
                    }
                    config =
                        convert(potentialMatch, m.getTarget(), vars);
                    break;
                }
            }
        }
        return config;
}

Matches the path against the compiled wildcard patterns.

 protected Map<String, String> replaceParameters(Map<String, String> orig,
    Map<String, String> vars) 
{
        Map< String,String > map = new LinkedHashMap< String,String >();
        for (String key : orig.keySet()) {
            map.put(key, convertParam(orig.get(key), vars));
        }
        return map;
}

Replaces parameter values