Package org.grails.io.support

Class AntPathMatcher

  • public class AntPathMatcher
extends java.lang.Object
    PathMatcher implementation for Ant-style path patterns. Examples are provided below.

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

    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
    Since:
    16.07.2003

    • Field Summary

      Fields 
      Modifier and Type Field Description
      static java.lang.String DEFAULT_PATH_SEPARATOR
      Default path separator: "/"

    • Constructor Summary

      Constructors 
      Constructor Description
      AntPathMatcher()  

    • Method Summary

      All Methods Static Methods Instance Methods Concrete Methods 
      Modifier and Type Method Description
      java.lang.String combine​(java.lang.String pattern1, java.lang.String pattern2)
      Combines two patterns into a new pattern that is returned.
      static int countOccurrencesOf​(java.lang.String str, java.lang.String sub)
      Count the occurrences of the substring in string s.
      protected boolean doMatch​(java.lang.String pattern, java.lang.String path, boolean fullMatch, java.util.Map<java.lang.String,​java.lang.String> uriTemplateVariables)
      Actually match the given path against the given pattern.
      java.lang.String extractPathWithinPattern​(java.lang.String pattern, java.lang.String path)
      Given a pattern and a full path, determine the pattern-mapped part.
      java.util.Map<java.lang.String,​java.lang.String> extractUriTemplateVariables​(java.lang.String pattern, java.lang.String path)  
      java.util.Comparator<java.lang.String> getPatternComparator​(java.lang.String path)
      Given a full path, returns a Comparator suitable for sorting patterns in order of explicitness.
      boolean isPattern​(java.lang.String path)  
      boolean match​(java.lang.String pattern, java.lang.String path)  
      boolean matchStart​(java.lang.String pattern, java.lang.String path)  
      void setPathSeparator​(java.lang.String pathSeparator)
      Set the path separator to use for pattern parsing.

      • Methods inherited from class java.lang.Object

        clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

    • Field Detail

      • DEFAULT_PATH_SEPARATOR

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

    • Constructor Detail

      • AntPathMatcher

        public AntPathMatcher()

    • Method Detail

      • setPathSeparator

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

      • isPattern

        public boolean isPattern​(java.lang.String path)

      • match

        public boolean match​(java.lang.String pattern,
                     java.lang.String path)

      • matchStart

        public boolean matchStart​(java.lang.String pattern,
                          java.lang.String path)

      • doMatch

        protected boolean doMatch​(java.lang.String pattern,
                          java.lang.String path,
                          boolean fullMatch,
                          java.util.Map<java.lang.String,​java.lang.String> uriTemplateVariables)
        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)
        Returns:
        true if the supplied path matched, false if it didn't

      • extractPathWithinPattern

        public java.lang.String extractPathWithinPattern​(java.lang.String pattern,
                                                 java.lang.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.

      • extractUriTemplateVariables

        public java.util.Map<java.lang.String,​java.lang.String> extractUriTemplateVariables​(java.lang.String pattern,
                                                                                          java.lang.String path)

      • combine

        public java.lang.String combine​(java.lang.String pattern1,
                                java.lang.String pattern2)
        Combines two patterns into a new pattern that is returned.

        This implementation simply concatenates the two patterns, unless the first pattern contains a file extension match (such as *.html. In that case, the second pattern should be included in the first, or an IllegalArgumentException is thrown.

        For example:

        Pattern 1Pattern 2Result
        /hotels null/hotels
        null/hotels/hotels
        /hotels/bookings/hotels/bookings
        /hotelsbookings/hotels/bookings
        /hotels/*/bookings/hotels/bookings
        /hotels/**/bookings/hotels/**/bookings
        /hotels{hotel}/hotels/{hotel}
        /hotels/*{hotel}/hotels/{hotel}
        /hotels/**{hotel}/hotels/**/{hotel}
        /*.html/hotels.html/hotels.html
        /*.html/hotels/hotels.html
        /*.html/*.txtIllegalArgumentException
        Parameters:
        pattern1 - the first pattern
        pattern2 - the second pattern
        Returns:
        the combination of the two patterns
        Throws:
        java.lang.IllegalArgumentException - when the two patterns cannot be combined

      • getPatternComparator

        public java.util.Comparator<java.lang.String> getPatternComparator​(java.lang.String path)
        Given a full path, returns a Comparator suitable for sorting patterns in order of explicitness.

        The returned Comparator will sort a list so that more specific patterns (without uri templates or wild cards) come before generic patterns. So given a list with the following patterns:

        1. /hotels/new
        2. /hotels/{hotel}
        3. /hotels/*
        the returned comparator will sort this list so that the order will be as indicated.

        The full path given as parameter is used to test for exact matches. So when the given path is /hotels/2, the pattern /hotels/2 will be sorted before /hotels/1.

        Parameters:
        path - the full path to use for comparison
        Returns:
        a comparator capable of sorting patterns in order of explicitness

      • countOccurrencesOf

        public static int countOccurrencesOf​(java.lang.String str,
                                     java.lang.String sub)
        Count the occurrences of the substring in string s.
        Parameters:
        str - string to search in. Return 0 if this is null.
        sub - string to search for. Return 0 if this is null.