Package org.onehippo.forge.content.exim.core.util

Class AntPathMatcher

  • public class AntPathMatcher
extends Object
    Note: Copied from the source of org.apache.camel.util.AntPathMatcher.

    PathMatcher implementation for Ant-style path patterns. Examples are provided below.

    Part of this mapping code has been kindly borrowed from Apache Ant and Spring Framework.

    The mapping matches URLs using the following rules:

    • ? matches one character
    • * matches zero or more characters
    • ** matches zero or more 'directories' in a path

    Some examples:

    • com/t?st.jsp - matches com/test.jsp but also com/tast.jsp or com/txst.jsp
    • com/*.jsp - matches all .jsp files in the com directory
    • com/**/test.jsp - matches all test.jsp files underneath the com path
    • org/springframework/**/*.jsp - matches all .jsp files underneath the org/springframework path
    • org/**/servlet/bla.jsp - matches org/springframework/servlet/bla.jsp but also org/springframework/testing/servlet/bla.jsp and org/servlet/bla.jsp

    • Field Detail

      • DEFAULT_PATH_SEPARATOR

        public static final String DEFAULT_PATH_SEPARATOR
        Default path separator: "/"
        See Also:
        Constant Field Values

    • Constructor Detail

      • AntPathMatcher

        public AntPathMatcher()

    • Method Detail

      • setPathSeparator

        public void setPathSeparator​(String pathSeparator)
        Set the path separator to use for pattern parsing. Default is "/", as in Ant.
        Parameters:
        pathSeparator - path separator

      • isPattern

        public boolean isPattern​(String path)
        Check if path is an ANT style pattern string.
        Parameters:
        path - path pattern
        Returns:
        true if path is an ANT style pattern string

      • match

        public boolean match​(String pattern,
                     String path)
        Matches.
        Parameters:
        pattern - pattern
        path - path
        Returns:
        true if matched

      • matchStart

        public boolean matchStart​(String pattern,
                          String path)
        Match starts.
        Parameters:
        pattern - pattern
        path - path
        Returns:
        true if match starts

      • match

        public boolean match​(String pattern,
                     String path,
                     boolean isCaseSensitive)
        Match.
        Parameters:
        pattern - pattern
        path - path
        isCaseSensitive - case sensitiveness
        Returns:
        true if matches

      • matchStart

        public boolean matchStart​(String pattern,
                          String path,
                          boolean isCaseSensitive)
        Match starts.
        Parameters:
        pattern - pattern
        path - path
        isCaseSensitive - case sensitiveness
        Returns:
        true if match starts

      • doMatch

        protected boolean doMatch​(String pattern,
                          String path,
                          boolean fullMatch,
                          boolean isCaseSensitive)
        Actually match the given path against the given pattern.
        Parameters:
        pattern - the pattern to match against
        path - the path String to test
        fullMatch - whether a full pattern match is required (else a pattern match as far as the given base path goes is sufficient)
        isCaseSensitive - Whether or not matching should be performed case sensitively.
        Returns:
        true if the supplied path matched, false if it didn't

      • extractPathWithinPattern

        public String extractPathWithinPattern​(String pattern,
                                       String path)
        Given a pattern and a full path, determine the pattern-mapped part.

        For example:

        • '/docs/cvs/commit.html' and ' /docs/cvs/commit.html -> ''
        • '/docs/*' and '/docs/cvs/commit -> ' cvs/commit'
        • '/docs/cvs/*.html' and ' /docs/cvs/commit.html -> 'commit.html'
        • '/docs/**' and '/docs/cvs/commit -> ' cvs/commit'
        • '/docs/**\/*.html' and ' /docs/cvs/commit.html -> 'cvs/commit.html'
        • '/*.html' and '/docs/cvs/commit.html -> ' docs/cvs/commit.html'
        • '*.html' and '/docs/cvs/commit.html -> ' /docs/cvs/commit.html'
        • '*' and '/docs/cvs/commit.html -> ' /docs/cvs/commit.html'

        Assumes that match(java.lang.String, java.lang.String) returns true for ' pattern' and 'path', but does not enforce this.

        Parameters:
        pattern - pattern
        path - path
        Returns:
        extracted path within the pattern

      • tokenizeToStringArray

        public static String[] tokenizeToStringArray​(String str,
                                             String delimiters)
        Tokenize the given String into a String array via a StringTokenizer. Trims tokens and omits empty tokens.

        The given delimiters string is supposed to consist of any number of delimiter characters. Each of those characters can be used to separate tokens. A delimiter is always a single character; for multi-character delimiters, consider using delimitedListToStringArray

        Parameters:
        str - the String to tokenize
        delimiters - the delimiter characters, assembled as String (each of those characters is individually considered as delimiter).
        Returns:
        an array of the tokens
        See Also:
        StringTokenizer, String.trim()