http://git-wip-us.apache.org/repos/asf/incubator-tamaya/blob/95885781/core/src/main/java/org/apache/tamaya/core/internal/resource/AntPathMatcher.java ---------------------------------------------------------------------- diff --git a/core/src/main/java/org/apache/tamaya/core/internal/resource/AntPathMatcher.java b/core/src/main/java/org/apache/tamaya/core/internal/resource/AntPathMatcher.java index bfb8182..ae44377 100644 --- a/core/src/main/java/org/apache/tamaya/core/internal/resource/AntPathMatcher.java +++ b/core/src/main/java/org/apache/tamaya/core/internal/resource/AntPathMatcher.java @@ -24,12 +24,12 @@ import java.util.regex.Pattern; /** * PathMatcher implementation for Ant-style path patterns. Examples are provided below. - * + * <p> * <p>Part current this annotation code has been kindly borrowed from <a href="http://ant.apache.org";>Apache Ant</a>. - * + * <p> * <p>The annotation matches URLs using the following rules:<br> <ul> <li>? matches one character</li> <li>* matches zero * or more characters</li> <li>** matches zero or more 'directories' in a path</li> </ul> - * + * <p> * <p>Some examples:<br> <ul> <li>{@code com/t?st.jsp} - matches {@code com/testdata.jsp} but also * {@code com/tast.jsp} or {@code com/txst.jsp}</li> <li>{@code com/*.jsp} - matches all * {@code .jsp} files in the {@code com} directory</li> <li>{@code com/**/testdata.jsp} - matches all @@ -47,733 +47,729 @@ import java.util.regex.Pattern; */ class AntPathMatcher { - /** Default path separator: "/" */ - public static final String DEFAULT_PATH_SEPARATOR = "/"; - - private static final int CACHE_TURNOFF_THRESHOLD = 65536; - - private static final Pattern VARIABLE_PATTERN = Pattern.compile("\\{[^/]+?\\}"); - - - private String pathSeparator; - - private PathSeparatorPatternCache pathSeparatorPatternCache; - - private boolean trimTokens = true; - - private volatile Boolean cachePatterns; - - private final Map<String, String[]> tokenizedPatternCache = new ConcurrentHashMap<>(256); - - final Map<String, AntPathStringMatcher> stringMatcherCache = new ConcurrentHashMap<>(256); - - - /** - * Create a new instance with the {@link #DEFAULT_PATH_SEPARATOR}. - */ - public AntPathMatcher() { - this.pathSeparator = DEFAULT_PATH_SEPARATOR; - this.pathSeparatorPatternCache = new PathSeparatorPatternCache(DEFAULT_PATH_SEPARATOR); - } - - /** - * A convenience alternative constructor to use with a custom path separator. - * @param pathSeparator the path separator to use, must not be {@code null}. - * @since 4.1 - */ - public AntPathMatcher(String pathSeparator) { - Objects.requireNonNull(pathSeparator, "'pathSeparator' is required"); - this.pathSeparator = pathSeparator; - this.pathSeparatorPatternCache = new PathSeparatorPatternCache(pathSeparator); - } - - - /** - * Set the path separator to use for pattern parsing. - * Default is "/", as in Ant. - */ - public void setPathSeparator(String pathSeparator) { - this.pathSeparator = (pathSeparator != null ? pathSeparator : DEFAULT_PATH_SEPARATOR); - this.pathSeparatorPatternCache = new PathSeparatorPatternCache(this.pathSeparator); - } - - /** - * Specify whether to trim tokenized paths and patterns. - * Default is {@code true}. - */ - public void setTrimTokens(boolean trimTokens) { - this.trimTokens = trimTokens; - } - - /** - * Specify whether to cache parsed pattern metadata for patterns passed - * into this matcher's {@link #match} method. A keys current {@code true} - * activates an unlimited pattern cache; a keys current {@code false} turns - * the pattern cache off completely. - * <p>Default is for the cache to be on, but with the variant to automatically - * turn it off when encountering too many patterns to cache at runtime - * (the threshold is 65536), assuming that arbitrary permutations current patterns - * are coming in, with little chance for encountering a reoccurring pattern. - * @see #getStringMatcher(String) - */ - public void setCachePatterns(boolean cachePatterns) { - this.cachePatterns = cachePatterns; - } - - private void deactivatePatternCache() { - this.cachePatterns = false; - this.tokenizedPatternCache.clear(); - this.stringMatcherCache.clear(); - } - - - public boolean isPattern(String path) { - return (path.indexOf('*') != -1 || path.indexOf('?') != -1); - } - - public boolean match(String pattern, String path) { - return doMatch(pattern, path, true, null); - } - - public boolean matchStart(String pattern, String path) { - return doMatch(pattern, path, false, null); - } - - /** - * Actually match the given {@code path} against the given {@code pattern}. - * @param pattern the pattern to match against - * @param path the path String to testdata - * @param fullMatch whether a full pattern match is required (else a pattern match - * as far as the given base path goes is sufficient) - * @return {@code true} if the supplied {@code path} matched, {@code false} if it didn't - */ - protected boolean doMatch(String pattern, String path, boolean fullMatch, Map<String, String> uriTemplateVariables) { - if (path.startsWith(this.pathSeparator) != pattern.startsWith(this.pathSeparator)) { - return false; - } - - String[] pattDirs = tokenizePattern(pattern); - String[] pathDirs = tokenizePath(path); - - int pattIdxStart = 0; - int pattIdxEnd = pattDirs.length - 1; - int pathIdxStart = 0; - int pathIdxEnd = pathDirs.length - 1; - - // Match all elements up to the first ** - while (pattIdxStart <= pattIdxEnd && pathIdxStart <= pathIdxEnd) { - String pattDir = pattDirs[pattIdxStart]; - if ("**".equals(pattDir)) { - break; - } - if (!matchStrings(pattDir, pathDirs[pathIdxStart], uriTemplateVariables)) { - return false; - } - pattIdxStart++; - pathIdxStart++; - } - - if (pathIdxStart > pathIdxEnd) { - // Path is exhausted, only match if rest current pattern is * or **'s - if (pattIdxStart > pattIdxEnd) { - return (pattern.endsWith(this.pathSeparator) ? path.endsWith(this.pathSeparator) : - !path.endsWith(this.pathSeparator)); - } - if (!fullMatch) { - return true; - } - if (pattIdxStart == pattIdxEnd && pattDirs[pattIdxStart].equals("*") && path.endsWith(this.pathSeparator)) { - return true; - } - for (int i = pattIdxStart; i <= pattIdxEnd; i++) { - if (!pattDirs[i].equals("**")) { - return false; - } - } - return true; - } - else if (pattIdxStart > pattIdxEnd) { - // String not exhausted, but pattern is. Failure. - return false; - } - else if (!fullMatch && "**".equals(pattDirs[pattIdxStart])) { - // Path start definitely matches due to "**" part in pattern. - return true; - } - - // up to last '**' - while (pattIdxStart <= pattIdxEnd && pathIdxStart <= pathIdxEnd) { - String pattDir = pattDirs[pattIdxEnd]; - if (pattDir.equals("**")) { - break; - } - if (!matchStrings(pattDir, pathDirs[pathIdxEnd], uriTemplateVariables)) { - return false; - } - pattIdxEnd--; - pathIdxEnd--; - } - if (pathIdxStart > pathIdxEnd) { - // String is exhausted - for (int i = pattIdxStart; i <= pattIdxEnd; i++) { - if (!pattDirs[i].equals("**")) { - return false; - } - } - return true; - } - - while (pattIdxStart != pattIdxEnd && pathIdxStart <= pathIdxEnd) { - int patIdxTmp = -1; - for (int i = pattIdxStart + 1; i <= pattIdxEnd; i++) { - if (pattDirs[i].equals("**")) { - patIdxTmp = i; - break; - } - } - if (patIdxTmp == pattIdxStart + 1) { - // '**/**' situation, so skip one - pattIdxStart++; - continue; - } - // Find the pattern between padIdxStart & padIdxTmp in str between - // strIdxStart & strIdxEnd - int patLength = (patIdxTmp - pattIdxStart - 1); - int strLength = (pathIdxEnd - pathIdxStart + 1); - int foundIdx = -1; - - strLoop: - for (int i = 0; i <= strLength - patLength; i++) { - for (int j = 0; j < patLength; j++) { - String subPat = pattDirs[pattIdxStart + j + 1]; - String subStr = pathDirs[pathIdxStart + i + j]; - if (!matchStrings(subPat, subStr, uriTemplateVariables)) { - continue strLoop; - } - } - foundIdx = pathIdxStart + i; - break; - } - - if (foundIdx == -1) { - return false; - } - - pattIdxStart = patIdxTmp; - pathIdxStart = foundIdx + patLength; - } - - for (int i = pattIdxStart; i <= pattIdxEnd; i++) { - if (!pattDirs[i].equals("**")) { - return false; - } - } - - return true; - } - - /** - * Tokenize the given path pattern into parts, based on this matcher's settings. - * <p>Performs caching based on {@link #setCachePatterns}, delegating to - * {@link #tokenizePath(String)} for the actual tokenization algorithm. - * @param pattern the pattern to tokenize - * @return the tokenized pattern parts - */ - protected String[] tokenizePattern(String pattern) { - String[] tokenized = null; - Boolean cachePatterns = this.cachePatterns; - if (cachePatterns == null || cachePatterns) { - tokenized = this.tokenizedPatternCache.get(pattern); - } - if (tokenized == null) { - tokenized = tokenizePath(pattern); - if (cachePatterns == null && this.tokenizedPatternCache.size() >= CACHE_TURNOFF_THRESHOLD) { - // Try to adapt to the runtime situation that we're encountering: - // There are obviously too many different patterns coming in here... - // So let's turn off the cache since the patterns are unlikely to be reoccurring. - deactivatePatternCache(); - return tokenized; - } - if (cachePatterns == null || cachePatterns) { - this.tokenizedPatternCache.put(pattern, tokenized); - } - } - return tokenized; - } - - /** - * Tokenize the given path String into parts, based on this matcher's settings. - * @param path the path to tokenize - * @return the tokenized path parts - */ - protected String[] tokenizePath(String path) { - return StringUtils.tokenizeToStringArray(path, this.pathSeparator, this.trimTokens, true); - } - - /** - * Tests whether or not a string matches against a pattern. - * @param pattern the pattern to match against (never {@code null}) - * @param str the String which must be matched against the pattern (never {@code null}) - * @return {@code true} if the string matches against the pattern, or {@code false} otherwise - */ - private boolean matchStrings(String pattern, String str, Map<String, String> uriTemplateVariables) { - return getStringMatcher(pattern).matchStrings(str, uriTemplateVariables); - } - - /** - * Build or retrieve an {@link AntPathStringMatcher} for the given pattern. - * <p>The default implementation checks this AntPathMatcher's internal cache - * (see {@link #setCachePatterns}), creating a new AntPathStringMatcher instance - * if no cached copy is found. - * When encountering too many patterns to cache at runtime (the threshold is 65536), - * it turns the default cache off, assuming that arbitrary permutations current patterns - * are coming in, with little chance for encountering a reoccurring pattern. - * <p>This method may get overridden to implement a custom cache strategy. - * @param pattern the pattern to match against (never {@code null}) - * @return a corresponding AntPathStringMatcher (never {@code null}) - * @see #setCachePatterns - */ - protected AntPathStringMatcher getStringMatcher(String pattern) { - AntPathStringMatcher matcher = null; - Boolean cachePatterns = this.cachePatterns; - if (cachePatterns == null || cachePatterns) { - matcher = this.stringMatcherCache.get(pattern); - } - if (matcher == null) { - matcher = new AntPathStringMatcher(pattern); - if (cachePatterns == null && this.stringMatcherCache.size() >= CACHE_TURNOFF_THRESHOLD) { - // Try to adapt to the runtime situation that we're encountering: - // There are obviously too many different patterns coming in here... - // So let's turn off the cache since the patterns are unlikely to be reoccurring. - deactivatePatternCache(); - return matcher; - } - if (cachePatterns == null || cachePatterns) { - this.stringMatcherCache.put(pattern, matcher); - } - } - return matcher; - } - - /** - * Given a pattern and a full path, determine the pattern-mapped part. <p>For example: <ul> - * <li>'{@code /docs/cvs/commit.html}' and '{@code /docs/cvs/commit.html} -> ''</li> - * <li>'{@code /docs/*}' and '{@code /docs/cvs/commit} -> '{@code cvs/commit}'</li> - * <li>'{@code /docs/cvs/*.html}' and '{@code /docs/cvs/commit.html} -> '{@code commit.html}'</li> - * <li>'{@code /docs/**}' and '{@code /docs/cvs/commit} -> '{@code cvs/commit}'</li> - * <li>'{@code /docs/**\/*.html}' and '{@code /docs/cvs/commit.html} -> '{@code cvs/commit.html}'</li> - * <li>'{@code /*.html}' and '{@code /docs/cvs/commit.html} -> '{@code docs/cvs/commit.html}'</li> - * <li>'{@code *.html}' and '{@code /docs/cvs/commit.html} -> '{@code /docs/cvs/commit.html}'</li> - * <li>'{@code *}' and '{@code /docs/cvs/commit.html} -> '{@code /docs/cvs/commit.html}'</li> </ul> - * <p>Assumes that {@link #match} returns {@code true} for '{@code pattern}' and '{@code path}', but - * does <strong>not</strong> enforce this. - */ - public String extractPathWithinPattern(String pattern, String path) { - String[] patternParts = StringUtils.tokenizeToStringArray(pattern, this.pathSeparator, this.trimTokens, true); - String[] pathParts = StringUtils.tokenizeToStringArray(path, this.pathSeparator, this.trimTokens, true); - StringBuilder builder = new StringBuilder(); - boolean pathStarted = false; - - for (int segment = 0; segment < patternParts.length; segment++) { - String patternPart = patternParts[segment]; - if (patternPart.indexOf('*') > -1 || patternPart.indexOf('?') > -1) { - for (; segment < pathParts.length; segment++) { - if (pathStarted || (segment == 0 && !pattern.startsWith(this.pathSeparator))) { - builder.append(this.pathSeparator); - } - builder.append(pathParts[segment]); - pathStarted = true; - } - } - } - - return builder.toString(); - } - - public Map<String, String> extractUriTemplateVariables(String pattern, String path) { - Map<String, String> variables = new LinkedHashMap<>(); - boolean result = doMatch(pattern, path, true, variables); - if(!result){ + /** + * Default path separator: "/" + */ + public static final String DEFAULT_PATH_SEPARATOR = "/"; + + private static final int CACHE_TURNOFF_THRESHOLD = 65536; + + private static final Pattern VARIABLE_PATTERN = Pattern.compile("\\{[^/]+?\\}"); + + + private String pathSeparator; + + private PathSeparatorPatternCache pathSeparatorPatternCache; + + private boolean trimTokens = true; + + private volatile Boolean cachePatterns; + + private final Map<String, String[]> tokenizedPatternCache = new ConcurrentHashMap<>(256); + + final Map<String, AntPathStringMatcher> stringMatcherCache = new ConcurrentHashMap<>(256); + + + /** + * Create a new instance with the {@link #DEFAULT_PATH_SEPARATOR}. + */ + public AntPathMatcher() { + this.pathSeparator = DEFAULT_PATH_SEPARATOR; + this.pathSeparatorPatternCache = new PathSeparatorPatternCache(DEFAULT_PATH_SEPARATOR); + } + + /** + * A convenience alternative constructor to use with a custom path separator. + * + * @param pathSeparator the path separator to use, must not be {@code null}. + * @since 4.1 + */ + public AntPathMatcher(String pathSeparator) { + Objects.requireNonNull(pathSeparator, "'pathSeparator' is required"); + this.pathSeparator = pathSeparator; + this.pathSeparatorPatternCache = new PathSeparatorPatternCache(pathSeparator); + } + + + /** + * Set the path separator to use for pattern parsing. + * Default is "/", as in Ant. + */ + public void setPathSeparator(String pathSeparator) { + this.pathSeparator = (pathSeparator != null ? pathSeparator : DEFAULT_PATH_SEPARATOR); + this.pathSeparatorPatternCache = new PathSeparatorPatternCache(this.pathSeparator); + } + + /** + * Specify whether to trim tokenized paths and patterns. + * Default is {@code true}. + */ + public void setTrimTokens(boolean trimTokens) { + this.trimTokens = trimTokens; + } + + /** + * Specify whether to cache parsed pattern metadata for patterns passed + * into this matcher's {@link #match} method. A keys current {@code true} + * activates an unlimited pattern cache; a keys current {@code false} turns + * the pattern cache off completely. + * <p>Default is for the cache to be on, but with the variant to automatically + * turn it off when encountering too many patterns to cache at runtime + * (the threshold is 65536), assuming that arbitrary permutations current patterns + * are coming in, with little chance for encountering a reoccurring pattern. + * + * @see #getStringMatcher(String) + */ + public void setCachePatterns(boolean cachePatterns) { + this.cachePatterns = cachePatterns; + } + + private void deactivatePatternCache() { + this.cachePatterns = false; + this.tokenizedPatternCache.clear(); + this.stringMatcherCache.clear(); + } + + + public boolean isPattern(String path) { + return (path.indexOf('*') != -1 || path.indexOf('?') != -1); + } + + public boolean match(String pattern, String path) { + return doMatch(pattern, path, true, null); + } + + public boolean matchStart(String pattern, String path) { + return doMatch(pattern, path, false, null); + } + + /** + * Actually match the given {@code path} against the given {@code pattern}. + * + * @param pattern the pattern to match against + * @param path the path String to testdata + * @param fullMatch whether a full pattern match is required (else a pattern match + * as far as the given base path goes is sufficient) + * @return {@code true} if the supplied {@code path} matched, {@code false} if it didn't + */ + protected boolean doMatch(String pattern, String path, boolean fullMatch, Map<String, String> uriTemplateVariables) { + if (path.startsWith(this.pathSeparator) != pattern.startsWith(this.pathSeparator)) { + return false; + } + + String[] pattDirs = tokenizePattern(pattern); + String[] pathDirs = tokenizePath(path); + + int pattIdxStart = 0; + int pattIdxEnd = pattDirs.length - 1; + int pathIdxStart = 0; + int pathIdxEnd = pathDirs.length - 1; + + // Match all elements up to the first ** + while (pattIdxStart <= pattIdxEnd && pathIdxStart <= pathIdxEnd) { + String pattDir = pattDirs[pattIdxStart]; + if ("**".equals(pattDir)) { + break; + } + if (!matchStrings(pattDir, pathDirs[pathIdxStart], uriTemplateVariables)) { + return false; + } + pattIdxStart++; + pathIdxStart++; + } + + if (pathIdxStart > pathIdxEnd) { + // Path is exhausted, only match if rest current pattern is * or **'s + if (pattIdxStart > pattIdxEnd) { + return (pattern.endsWith(this.pathSeparator) ? path.endsWith(this.pathSeparator) : + !path.endsWith(this.pathSeparator)); + } + if (!fullMatch) { + return true; + } + if (pattIdxStart == pattIdxEnd && pattDirs[pattIdxStart].equals("*") && path.endsWith(this.pathSeparator)) { + return true; + } + for (int i = pattIdxStart; i <= pattIdxEnd; i++) { + if (!pattDirs[i].equals("**")) { + return false; + } + } + return true; + } else if (pattIdxStart > pattIdxEnd) { + // String not exhausted, but pattern is. Failure. + return false; + } else if (!fullMatch && "**".equals(pattDirs[pattIdxStart])) { + // Path start definitely matches due to "**" part in pattern. + return true; + } + + // up to last '**' + while (pattIdxStart <= pattIdxEnd && pathIdxStart <= pathIdxEnd) { + String pattDir = pattDirs[pattIdxEnd]; + if (pattDir.equals("**")) { + break; + } + if (!matchStrings(pattDir, pathDirs[pathIdxEnd], uriTemplateVariables)) { + return false; + } + pattIdxEnd--; + pathIdxEnd--; + } + if (pathIdxStart > pathIdxEnd) { + // String is exhausted + for (int i = pattIdxStart; i <= pattIdxEnd; i++) { + if (!pattDirs[i].equals("**")) { + return false; + } + } + return true; + } + + while (pattIdxStart != pattIdxEnd && pathIdxStart <= pathIdxEnd) { + int patIdxTmp = -1; + for (int i = pattIdxStart + 1; i <= pattIdxEnd; i++) { + if (pattDirs[i].equals("**")) { + patIdxTmp = i; + break; + } + } + if (patIdxTmp == pattIdxStart + 1) { + // '**/**' situation, so skip one + pattIdxStart++; + continue; + } + // Find the pattern between padIdxStart & padIdxTmp in str between + // strIdxStart & strIdxEnd + int patLength = (patIdxTmp - pattIdxStart - 1); + int strLength = (pathIdxEnd - pathIdxStart + 1); + int foundIdx = -1; + + strLoop: + for (int i = 0; i <= strLength - patLength; i++) { + for (int j = 0; j < patLength; j++) { + String subPat = pattDirs[pattIdxStart + j + 1]; + String subStr = pathDirs[pathIdxStart + i + j]; + if (!matchStrings(subPat, subStr, uriTemplateVariables)) { + continue strLoop; + } + } + foundIdx = pathIdxStart + i; + break; + } + + if (foundIdx == -1) { + return false; + } + + pattIdxStart = patIdxTmp; + pathIdxStart = foundIdx + patLength; + } + + for (int i = pattIdxStart; i <= pattIdxEnd; i++) { + if (!pattDirs[i].equals("**")) { + return false; + } + } + + return true; + } + + /** + * Tokenize the given path pattern into parts, based on this matcher's settings. + * <p>Performs caching based on {@link #setCachePatterns}, delegating to + * {@link #tokenizePath(String)} for the actual tokenization algorithm. + * + * @param pattern the pattern to tokenize + * @return the tokenized pattern parts + */ + protected String[] tokenizePattern(String pattern) { + String[] tokenized = null; + Boolean cachePatterns = this.cachePatterns; + if (cachePatterns == null || cachePatterns) { + tokenized = this.tokenizedPatternCache.get(pattern); + } + if (tokenized == null) { + tokenized = tokenizePath(pattern); + if (cachePatterns == null && this.tokenizedPatternCache.size() >= CACHE_TURNOFF_THRESHOLD) { + // Try to adapt to the runtime situation that we're encountering: + // There are obviously too many different patterns coming in here... + // So let's turn off the cache since the patterns are unlikely to be reoccurring. + deactivatePatternCache(); + return tokenized; + } + if (cachePatterns == null || cachePatterns) { + this.tokenizedPatternCache.put(pattern, tokenized); + } + } + return tokenized; + } + + /** + * Tokenize the given path String into parts, based on this matcher's settings. + * + * @param path the path to tokenize + * @return the tokenized path parts + */ + protected String[] tokenizePath(String path) { + return StringUtils.tokenizeToStringArray(path, this.pathSeparator, this.trimTokens, true); + } + + /** + * Tests whether or not a string matches against a pattern. + * + * @param pattern the pattern to match against (never {@code null}) + * @param str the String which must be matched against the pattern (never {@code null}) + * @return {@code true} if the string matches against the pattern, or {@code false} otherwise + */ + private boolean matchStrings(String pattern, String str, Map<String, String> uriTemplateVariables) { + return getStringMatcher(pattern).matchStrings(str, uriTemplateVariables); + } + + /** + * Build or retrieve an {@link AntPathStringMatcher} for the given pattern. + * <p>The default implementation checks this AntPathMatcher's internal cache + * (see {@link #setCachePatterns}), creating a new AntPathStringMatcher instance + * if no cached copy is found. + * When encountering too many patterns to cache at runtime (the threshold is 65536), + * it turns the default cache off, assuming that arbitrary permutations current patterns + * are coming in, with little chance for encountering a reoccurring pattern. + * <p>This method may get overridden to implement a custom cache strategy. + * + * @param pattern the pattern to match against (never {@code null}) + * @return a corresponding AntPathStringMatcher (never {@code null}) + * @see #setCachePatterns + */ + protected AntPathStringMatcher getStringMatcher(String pattern) { + AntPathStringMatcher matcher = null; + Boolean cachePatterns = this.cachePatterns; + if (cachePatterns == null || cachePatterns) { + matcher = this.stringMatcherCache.get(pattern); + } + if (matcher == null) { + matcher = new AntPathStringMatcher(pattern); + if (cachePatterns == null && this.stringMatcherCache.size() >= CACHE_TURNOFF_THRESHOLD) { + // Try to adapt to the runtime situation that we're encountering: + // There are obviously too many different patterns coming in here... + // So let's turn off the cache since the patterns are unlikely to be reoccurring. + deactivatePatternCache(); + return matcher; + } + if (cachePatterns == null || cachePatterns) { + this.stringMatcherCache.put(pattern, matcher); + } + } + return matcher; + } + + /** + * Given a pattern and a full path, determine the pattern-mapped part. <p>For example: <ul> + * <li>'{@code /docs/cvs/commit.html}' and '{@code /docs/cvs/commit.html} -> ''</li> + * <li>'{@code /docs/*}' and '{@code /docs/cvs/commit} -> '{@code cvs/commit}'</li> + * <li>'{@code /docs/cvs/*.html}' and '{@code /docs/cvs/commit.html} -> '{@code commit.html}'</li> + * <li>'{@code /docs/**}' and '{@code /docs/cvs/commit} -> '{@code cvs/commit}'</li> + * <li>'{@code /docs/**\/*.html}' and '{@code /docs/cvs/commit.html} -> '{@code cvs/commit.html}'</li> + * <li>'{@code /*.html}' and '{@code /docs/cvs/commit.html} -> '{@code docs/cvs/commit.html}'</li> + * <li>'{@code *.html}' and '{@code /docs/cvs/commit.html} -> '{@code /docs/cvs/commit.html}'</li> + * <li>'{@code *}' and '{@code /docs/cvs/commit.html} -> '{@code /docs/cvs/commit.html}'</li> </ul> + * <p>Assumes that {@link #match} returns {@code true} for '{@code pattern}' and '{@code path}', but + * does <strong>not</strong> enforce this. + */ + public String extractPathWithinPattern(String pattern, String path) { + String[] patternParts = StringUtils.tokenizeToStringArray(pattern, this.pathSeparator, this.trimTokens, true); + String[] pathParts = StringUtils.tokenizeToStringArray(path, this.pathSeparator, this.trimTokens, true); + StringBuilder builder = new StringBuilder(); + boolean pathStarted = false; + + for (int segment = 0; segment < patternParts.length; segment++) { + String patternPart = patternParts[segment]; + if (patternPart.indexOf('*') > -1 || patternPart.indexOf('?') > -1) { + for (; segment < pathParts.length; segment++) { + if (pathStarted || (segment == 0 && !pattern.startsWith(this.pathSeparator))) { + builder.append(this.pathSeparator); + } + builder.append(pathParts[segment]); + pathStarted = true; + } + } + } + + return builder.toString(); + } + + public Map<String, String> extractUriTemplateVariables(String pattern, String path) { + Map<String, String> variables = new LinkedHashMap<>(); + boolean result = doMatch(pattern, path, true, variables); + if (!result) { throw new IllegalArgumentException("Pattern \"" + pattern + "\" is not a match for \"" + path + "\""); } - return variables; - } - - /** - * Combines two patterns into a new pattern that is returned. - * <p>This implementation simply concatenates the two patterns, unless the first pattern - * contains a file extension match (such as {@code *.html}. In that case, the second pattern - * should be included in the first, or an {@code IllegalArgumentException} is thrown. - * <p>For example: <table> - * <tr><th>Pattern 1</th><th>Pattern 2</th><th>Result</th></tr> <tr><td>/hotels</td><td>{@code - * null}</td><td>/hotels</td></tr> <tr><td>{@code null}</td><td>/hotels</td><td>/hotels</td></tr> - * <tr><td>/hotels</td><td>/bookings</td><td>/hotels/bookings</td></tr> <tr><td>/hotels</td><td>bookings</td><td>/hotels/bookings</td></tr> - * <tr><td>/hotels/*</td><td>/bookings</td><td>/hotels/bookings</td></tr> <tr><td>/hotels/**</td><td>/bookings</td><td>/hotels/**/bookings</td></tr> - * <tr><td>/hotels</td><td>{hotel}</td><td>/hotels/{hotel}</td></tr> <tr><td>/hotels/*</td><td>{hotel}</td><td>/hotels/{hotel}</td></tr> - * <tr><td>/hotels/**</td><td>{hotel}</td><td>/hotels/**/{hotel}</td></tr> - * <tr><td>/*.html</td><td>/hotels.html</td><td>/hotels.html</td></tr> <tr><td>/*.html</td><td>/hotels</td><td>/hotels.html</td></tr> - * <tr><td>/*.html</td><td>/*.txt</td><td>IllegalArgumentException</td></tr> </table> - * @param pattern1 the first pattern - * @param pattern2 the second pattern - * @return the combination current the two patterns - * @throws IllegalArgumentException when the two patterns cannot be combined - */ - public String combine(String pattern1, String pattern2) { - if (!StringUtils.hasText(pattern1) && !StringUtils.hasText(pattern2)) { - return ""; - } - if (!StringUtils.hasText(pattern1)) { - return pattern2; - } - if (!StringUtils.hasText(pattern2)) { - return pattern1; - } - - boolean pattern1ContainsUriVar = pattern1.indexOf('{') != -1; - if (!pattern1.equals(pattern2) && !pattern1ContainsUriVar && match(pattern1, pattern2)) { - // /* + /hotel -> /hotel ; "/*.*" + "/*.html" -> /*.html - // However /user + /user -> /usr/user ; /{foo} + /bar -> /{foo}/bar - return pattern2; - } - - // /hotels/* + /booking -> /hotels/booking - // /hotels/* + booking -> /hotels/booking - if (pattern1.endsWith(this.pathSeparatorPatternCache.getEndsOnWildCard())) { - return concat(pattern1.substring(0, pattern1.length() - 2), pattern2); - } - - // /hotels/** + /booking -> /hotels/**/booking - // /hotels/** + booking -> /hotels/**/booking - if (pattern1.endsWith(this.pathSeparatorPatternCache.getEndsOnDoubleWildCard())) { - return concat(pattern1, pattern2); - } - - int starDotPos1 = pattern1.indexOf("*."); - if (pattern1ContainsUriVar || starDotPos1 == -1 || this.pathSeparator.equals(".")) { - // simply concatenate the two patterns - return concat(pattern1, pattern2); - } - String extension1 = pattern1.substring(starDotPos1 + 1); - int dotPos2 = pattern2.indexOf('.'); - String fileName2 = (dotPos2 == -1 ? pattern2 : pattern2.substring(0, dotPos2)); - String extension2 = (dotPos2 == -1 ? "" : pattern2.substring(dotPos2)); - String extension = extension1.startsWith("*") ? extension2 : extension1; - return fileName2 + extension; - } - - private String concat(String path1, String path2) { - if (path1.endsWith(this.pathSeparator) || path2.startsWith(this.pathSeparator)) { - return path1 + path2; - } - return path1 + this.pathSeparator + path2; - } - - /** - * Given a full path, returns a {@link Comparator} suitable for sorting patterns in order current explicitness. - * <p>The returned {@code Comparator} will {@linkplain java.util.Collections#sort(java.util.List, - * java.util.Comparator) 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: <ol> <li>{@code /hotels/new}</li> - * <li>{@code /hotels/{hotel}}</li> <li>{@code /hotels/*}</li> </ol> the returned comparator will sort this - * list so that the order will be as indicated. - * <p>The full path given as parameter is used to testdata for exact matches. So when the given path is {@code /hotels/2}, - * the pattern {@code /hotels/2} will be sorted before {@code /hotels/1}. - * @param path the full path to use for comparison - * @return a comparator capable current sorting patterns in order current explicitness - */ - public Comparator<String> getPatternComparator(String path) { - return new AntPatternComparator(path); - } - - - /** - * Tests whether or not a string matches against a pattern via a {@link Pattern}. - * <p>The pattern may contain special characters: '*' means zero or more characters; '?' means one and - * only one character; '{' and '}' indicate a URI template pattern. For example <tt>/users/{user}</tt>. - */ - protected static class AntPathStringMatcher { - - private static final Pattern GLOB_PATTERN = Pattern.compile("\\?|\\*|\\{((?:\\{[^/]+?\\}|[^/{}]|\\\\[{}])+?)\\}"); - - private static final String DEFAULT_VARIABLE_PATTERN = "(.*)"; - - private final Pattern pattern; - - private final List<String> variableNames = new LinkedList<>(); - - public AntPathStringMatcher(String pattern) { - StringBuilder patternBuilder = new StringBuilder(); - Matcher m = GLOB_PATTERN.matcher(pattern); - int end = 0; - while (m.find()) { - patternBuilder.append(quote(pattern, end, m.start())); - String match = m.group(); - if ("?".equals(match)) { - patternBuilder.append('.'); - } - else if ("*".equals(match)) { - patternBuilder.append(".*"); - } - else if (match.startsWith("{") && match.endsWith("}")) { - int colonIdx = match.indexOf(':'); - if (colonIdx == -1) { - patternBuilder.append(DEFAULT_VARIABLE_PATTERN); - this.variableNames.add(m.group(1)); - } - else { - String variablePattern = match.substring(colonIdx + 1, match.length() - 1); - patternBuilder.append('('); - patternBuilder.append(variablePattern); - patternBuilder.append(')'); - String variableName = match.substring(1, colonIdx); - this.variableNames.add(variableName); - } - } - end = m.end(); - } - patternBuilder.append(quote(pattern, end, pattern.length())); - this.pattern = Pattern.compile(patternBuilder.toString()); - } - - private String quote(String s, int start, int end) { - if (start == end) { - return ""; - } - return Pattern.quote(s.substring(start, end)); - } - - /** - * Main entry point. - * @return {@code true} if the string matches against the pattern, or {@code false} otherwise. - */ - public boolean matchStrings(String str, Map<String, String> uriTemplateVariables) { - Matcher matcher = this.pattern.matcher(str); - if (matcher.matches()) { - if (uriTemplateVariables != null) { - // SPR-8455 - if(!(this.variableNames.size() == matcher.groupCount())) { + return variables; + } + + /** + * Combines two patterns into a new pattern that is returned. + * <p>This implementation simply concatenates the two patterns, unless the first pattern + * contains a file extension match (such as {@code *.html}. In that case, the second pattern + * should be included in the first, or an {@code IllegalArgumentException} is thrown. + * <p>For example: <table> + * <tr><th>Pattern 1</th><th>Pattern 2</th><th>Result</th></tr> <tr><td>/hotels</td><td>{@code + * null}</td><td>/hotels</td></tr> <tr><td>{@code null}</td><td>/hotels</td><td>/hotels</td></tr> + * <tr><td>/hotels</td><td>/bookings</td><td>/hotels/bookings</td></tr> <tr><td>/hotels</td><td>bookings</td><td>/hotels/bookings</td></tr> + * <tr><td>/hotels/*</td><td>/bookings</td><td>/hotels/bookings</td></tr> <tr><td>/hotels/**</td><td>/bookings</td><td>/hotels/**/bookings</td></tr> + * <tr><td>/hotels</td><td>{hotel}</td><td>/hotels/{hotel}</td></tr> <tr><td>/hotels/*</td><td>{hotel}</td><td>/hotels/{hotel}</td></tr> + * <tr><td>/hotels/**</td><td>{hotel}</td><td>/hotels/**/{hotel}</td></tr> + * <tr><td>/*.html</td><td>/hotels.html</td><td>/hotels.html</td></tr> <tr><td>/*.html</td><td>/hotels</td><td>/hotels.html</td></tr> + * <tr><td>/*.html</td><td>/*.txt</td><td>IllegalArgumentException</td></tr> </table> + * + * @param pattern1 the first pattern + * @param pattern2 the second pattern + * @return the combination current the two patterns + * @throws IllegalArgumentException when the two patterns cannot be combined + */ + public String combine(String pattern1, String pattern2) { + if (!StringUtils.hasText(pattern1) && !StringUtils.hasText(pattern2)) { + return ""; + } + if (!StringUtils.hasText(pattern1)) { + return pattern2; + } + if (!StringUtils.hasText(pattern2)) { + return pattern1; + } + + boolean pattern1ContainsUriVar = pattern1.indexOf('{') != -1; + if (!pattern1.equals(pattern2) && !pattern1ContainsUriVar && match(pattern1, pattern2)) { + // /* + /hotel -> /hotel ; "/*.*" + "/*.html" -> /*.html + // However /user + /user -> /usr/user ; /{foo} + /bar -> /{foo}/bar + return pattern2; + } + + // /hotels/* + /booking -> /hotels/booking + // /hotels/* + booking -> /hotels/booking + if (pattern1.endsWith(this.pathSeparatorPatternCache.getEndsOnWildCard())) { + return concat(pattern1.substring(0, pattern1.length() - 2), pattern2); + } + + // /hotels/** + /booking -> /hotels/**/booking + // /hotels/** + booking -> /hotels/**/booking + if (pattern1.endsWith(this.pathSeparatorPatternCache.getEndsOnDoubleWildCard())) { + return concat(pattern1, pattern2); + } + + int starDotPos1 = pattern1.indexOf("*."); + if (pattern1ContainsUriVar || starDotPos1 == -1 || this.pathSeparator.equals(".")) { + // simply concatenate the two patterns + return concat(pattern1, pattern2); + } + String extension1 = pattern1.substring(starDotPos1 + 1); + int dotPos2 = pattern2.indexOf('.'); + String fileName2 = (dotPos2 == -1 ? pattern2 : pattern2.substring(0, dotPos2)); + String extension2 = (dotPos2 == -1 ? "" : pattern2.substring(dotPos2)); + String extension = extension1.startsWith("*") ? extension2 : extension1; + return fileName2 + extension; + } + + private String concat(String path1, String path2) { + if (path1.endsWith(this.pathSeparator) || path2.startsWith(this.pathSeparator)) { + return path1 + path2; + } + return path1 + this.pathSeparator + path2; + } + + /** + * Given a full path, returns a {@link Comparator} suitable for sorting patterns in order current explicitness. + * <p>The returned {@code Comparator} will {@linkplain java.util.Collections#sort(java.util.List, + * java.util.Comparator) 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: <ol> <li>{@code /hotels/new}</li> + * <li>{@code /hotels/{hotel}}</li> <li>{@code /hotels/*}</li> </ol> the returned comparator will sort this + * list so that the order will be as indicated. + * <p>The full path given as parameter is used to testdata for exact matches. So when the given path is {@code /hotels/2}, + * the pattern {@code /hotels/2} will be sorted before {@code /hotels/1}. + * + * @param path the full path to use for comparison + * @return a comparator capable current sorting patterns in order current explicitness + */ + public Comparator<String> getPatternComparator(String path) { + return new AntPatternComparator(path); + } + + + /** + * Tests whether or not a string matches against a pattern via a {@link Pattern}. + * <p>The pattern may contain special characters: '*' means zero or more characters; '?' means one and + * only one character; '{' and '}' indicate a URI template pattern. For example <tt>/users/{user}</tt>. + */ + protected static class AntPathStringMatcher { + + private static final Pattern GLOB_PATTERN = Pattern.compile("\\?|\\*|\\{((?:\\{[^/]+?\\}|[^/{}]|\\\\[{}])+?)\\}"); + + private static final String DEFAULT_VARIABLE_PATTERN = "(.*)"; + + private final Pattern pattern; + + private final List<String> variableNames = new LinkedList<>(); + + public AntPathStringMatcher(String pattern) { + StringBuilder patternBuilder = new StringBuilder(); + Matcher m = GLOB_PATTERN.matcher(pattern); + int end = 0; + while (m.find()) { + patternBuilder.append(quote(pattern, end, m.start())); + String match = m.group(); + if ("?".equals(match)) { + patternBuilder.append('.'); + } else if ("*".equals(match)) { + patternBuilder.append(".*"); + } else if (match.startsWith("{") && match.endsWith("}")) { + int colonIdx = match.indexOf(':'); + if (colonIdx == -1) { + patternBuilder.append(DEFAULT_VARIABLE_PATTERN); + this.variableNames.add(m.group(1)); + } else { + String variablePattern = match.substring(colonIdx + 1, match.length() - 1); + patternBuilder.append('('); + patternBuilder.append(variablePattern); + patternBuilder.append(')'); + String variableName = match.substring(1, colonIdx); + this.variableNames.add(variableName); + } + } + end = m.end(); + } + patternBuilder.append(quote(pattern, end, pattern.length())); + this.pattern = Pattern.compile(patternBuilder.toString()); + } + + private String quote(String s, int start, int end) { + if (start == end) { + return ""; + } + return Pattern.quote(s.substring(start, end)); + } + + /** + * Main entry point. + * + * @return {@code true} if the string matches against the pattern, or {@code false} otherwise. + */ + public boolean matchStrings(String str, Map<String, String> uriTemplateVariables) { + Matcher matcher = this.pattern.matcher(str); + if (matcher.matches()) { + if (uriTemplateVariables != null) { + // SPR-8455 + if (!(this.variableNames.size() == matcher.groupCount())) { throw new IllegalStateException( "The number current capturing groups in the pattern segment " + this.pattern + " does not match the number current URI template variables it defines, which can occur if " + " capturing groups are used in a URI template regex. Use non-capturing groups instead."); } - for (int i = 1; i <= matcher.groupCount(); i++) { - String name = this.variableNames.get(i - 1); - String value = matcher.group(i); - uriTemplateVariables.put(name, value); - } - } - return true; - } - else { - return false; - } - } - } - - - /** - * The default {@link Comparator} implementation returned by - * {@link #getPatternComparator(String)}. - * <p>In order, the most "generic" pattern is determined by the following: - * <ul> - * <li>if it's null or a capture all pattern (i.e. it is equal to "/**")</li> - * <li>if the other pattern is an actual match</li> - * <li>if it's a catch-all pattern (i.e. it ends with "**"</li> - * <li>if it's got more "*" than the other pattern</li> - * <li>if it's got more "{foo}" than the other pattern</li> - * <li>if it's shorter than the other pattern</li> - * </ul> - */ - protected static class AntPatternComparator implements Comparator<String> { - - private final String path; - - public AntPatternComparator(String path) { - this.path = path; - } - - /** - * Compare two patterns to determine which should match first, i.e. which - * is the most specific regarding the current path. - * @return a negative integer, zero, or a positive integer as pattern1 is - * more specific, equally specific, or less specific than pattern2. - */ - @Override - public int compare(String pattern1, String pattern2) { - PatternInfo info1 = new PatternInfo(pattern1); - PatternInfo info2 = new PatternInfo(pattern2); - - if (info1.isLeastSpecific() && info2.isLeastSpecific()) { - return 0; - } - else if (info1.isLeastSpecific()) { - return 1; - } - else if (info2.isLeastSpecific()) { - return -1; - } - - boolean pattern1EqualsPath = pattern1.equals(path); - boolean pattern2EqualsPath = pattern2.equals(path); - if (pattern1EqualsPath && pattern2EqualsPath) { - return 0; - } - else if (pattern1EqualsPath) { - return -1; - } - else if (pattern2EqualsPath) { - return 1; - } - - if (info1.isPrefixPattern() && info2.getDoubleWildcards() == 0) { - return 1; - } - else if (info2.isPrefixPattern() && info1.getDoubleWildcards() == 0) { - return -1; - } - - if (info1.getTotalCount() != info2.getTotalCount()) { - return info1.getTotalCount() - info2.getTotalCount(); - } - - if (info1.getLength() != info2.getLength()) { - return info2.getLength() - info1.getLength(); - } - - if (info1.getSingleWildcards() < info2.getSingleWildcards()) { - return -1; - } - else if (info2.getSingleWildcards() < info1.getSingleWildcards()) { - return 1; - } - - if (info1.getUriVars() < info2.getUriVars()) { - return -1; - } - else if (info2.getUriVars() < info1.getUriVars()) { - return 1; - } - - return 0; - } - - - /** - * Value class that holds information about the pattern, e.g. number current - * occurrences current "*", "**", and "{" pattern elements. - */ - private static class PatternInfo { - - private final String pattern; - - private int uriVars; - - private int singleWildcards; - - private int doubleWildcards; - - private boolean catchAllPattern; - - private boolean prefixPattern; - - private Integer length; - - public PatternInfo(String pattern) { - this.pattern = pattern; - if (this.pattern != null) { - initCounters(); - this.catchAllPattern = this.pattern.equals("/**"); - this.prefixPattern = !this.catchAllPattern && this.pattern.endsWith("/**"); - } - if (this.uriVars == 0) { - this.length = (this.pattern != null ? this.pattern.length() : 0); - } - } - - protected void initCounters() { - int pos = 0; - while (pos < this.pattern.length()) { - if (this.pattern.charAt(pos) == '{') { - this.uriVars++; - pos++; - } - else if (this.pattern.charAt(pos) == '*') { - if (pos + 1 < this.pattern.length() && this.pattern.charAt(pos + 1) == '*') { - this.doubleWildcards++; - pos += 2; - } - else if (!this.pattern.substring(pos - 1).equals(".*")) { - this.singleWildcards++; - pos++; - } - else { - pos++; - } - } - else { - pos++; - } - } - } - - public int getUriVars() { - return this.uriVars; - } - - public int getSingleWildcards() { - return this.singleWildcards; - } - - public int getDoubleWildcards() { - return this.doubleWildcards; - } - - public boolean isLeastSpecific() { - return (this.pattern == null || this.catchAllPattern); - } - - public boolean isPrefixPattern() { - return this.prefixPattern; - } - - public int getTotalCount() { - return this.uriVars + this.singleWildcards + (2 * this.doubleWildcards); - } - - /** - * Returns the length current the given pattern, where template variables are considered to be 1 long. - */ - public int getLength() { - if (this.length == null) { - this.length = VARIABLE_PATTERN.matcher(this.pattern).replaceAll("#").length(); - } - return this.length; - } - } - } - - - /** - * A simple cache for patterns that depend on the configured path separator. - */ - private static class PathSeparatorPatternCache { - - private final String endsOnWildCard; - - private final String endsOnDoubleWildCard; - - public PathSeparatorPatternCache(String pathSeparator) { - this.endsOnWildCard = pathSeparator + "*"; - this.endsOnDoubleWildCard = pathSeparator + "**"; - } - - public String getEndsOnWildCard() { - return this.endsOnWildCard; - } - - public String getEndsOnDoubleWildCard() { - return this.endsOnDoubleWildCard; - } - } + for (int i = 1; i <= matcher.groupCount(); i++) { + String name = this.variableNames.get(i - 1); + String value = matcher.group(i); + uriTemplateVariables.put(name, value); + } + } + return true; + } else { + return false; + } + } + } + + + /** + * The default {@link Comparator} implementation returned by + * {@link #getPatternComparator(String)}. + * <p>In order, the most "generic" pattern is determined by the following: + * <ul> + * <li>if it's null or a capture all pattern (i.e. it is equal to "/**")</li> + * <li>if the other pattern is an actual match</li> + * <li>if it's a catch-all pattern (i.e. it ends with "**"</li> + * <li>if it's got more "*" than the other pattern</li> + * <li>if it's got more "{foo}" than the other pattern</li> + * <li>if it's shorter than the other pattern</li> + * </ul> + */ + protected static class AntPatternComparator implements Comparator<String> { + + private final String path; + + public AntPatternComparator(String path) { + this.path = path; + } + + /** + * Compare two patterns to determine which should match first, i.e. which + * is the most specific regarding the current path. + * + * @return a negative integer, zero, or a positive integer as pattern1 is + * more specific, equally specific, or less specific than pattern2. + */ + @Override + public int compare(String pattern1, String pattern2) { + PatternInfo info1 = new PatternInfo(pattern1); + PatternInfo info2 = new PatternInfo(pattern2); + + if (info1.isLeastSpecific() && info2.isLeastSpecific()) { + return 0; + } else if (info1.isLeastSpecific()) { + return 1; + } else if (info2.isLeastSpecific()) { + return -1; + } + + boolean pattern1EqualsPath = pattern1.equals(path); + boolean pattern2EqualsPath = pattern2.equals(path); + if (pattern1EqualsPath && pattern2EqualsPath) { + return 0; + } else if (pattern1EqualsPath) { + return -1; + } else if (pattern2EqualsPath) { + return 1; + } + + if (info1.isPrefixPattern() && info2.getDoubleWildcards() == 0) { + return 1; + } else if (info2.isPrefixPattern() && info1.getDoubleWildcards() == 0) { + return -1; + } + + if (info1.getTotalCount() != info2.getTotalCount()) { + return info1.getTotalCount() - info2.getTotalCount(); + } + + if (info1.getLength() != info2.getLength()) { + return info2.getLength() - info1.getLength(); + } + + if (info1.getSingleWildcards() < info2.getSingleWildcards()) { + return -1; + } else if (info2.getSingleWildcards() < info1.getSingleWildcards()) { + return 1; + } + + if (info1.getUriVars() < info2.getUriVars()) { + return -1; + } else if (info2.getUriVars() < info1.getUriVars()) { + return 1; + } + + return 0; + } + + + /** + * Value class that holds information about the pattern, e.g. number current + * occurrences current "*", "**", and "{" pattern elements. + */ + private static class PatternInfo { + + private final String pattern; + + private int uriVars; + + private int singleWildcards; + + private int doubleWildcards; + + private boolean catchAllPattern; + + private boolean prefixPattern; + + private Integer length; + + public PatternInfo(String pattern) { + this.pattern = pattern; + if (this.pattern != null) { + initCounters(); + this.catchAllPattern = this.pattern.equals("/**"); + this.prefixPattern = !this.catchAllPattern && this.pattern.endsWith("/**"); + } + if (this.uriVars == 0) { + this.length = (this.pattern != null ? this.pattern.length() : 0); + } + } + + protected void initCounters() { + int pos = 0; + while (pos < this.pattern.length()) { + if (this.pattern.charAt(pos) == '{') { + this.uriVars++; + pos++; + } else if (this.pattern.charAt(pos) == '*') { + if (pos + 1 < this.pattern.length() && this.pattern.charAt(pos + 1) == '*') { + this.doubleWildcards++; + pos += 2; + } else if (!this.pattern.substring(pos - 1).equals(".*")) { + this.singleWildcards++; + pos++; + } else { + pos++; + } + } else { + pos++; + } + } + } + + public int getUriVars() { + return this.uriVars; + } + + public int getSingleWildcards() { + return this.singleWildcards; + } + + public int getDoubleWildcards() { + return this.doubleWildcards; + } + + public boolean isLeastSpecific() { + return (this.pattern == null || this.catchAllPattern); + } + + public boolean isPrefixPattern() { + return this.prefixPattern; + } + + public int getTotalCount() { + return this.uriVars + this.singleWildcards + (2 * this.doubleWildcards); + } + + /** + * Returns the length current the given pattern, where template variables are considered to be 1 long. + */ + public int getLength() { + if (this.length == null) { + this.length = VARIABLE_PATTERN.matcher(this.pattern).replaceAll("#").length(); + } + return this.length; + } + } + } + + + /** + * A simple cache for patterns that depend on the configured path separator. + */ + private static class PathSeparatorPatternCache { + + private final String endsOnWildCard; + + private final String endsOnDoubleWildCard; + + public PathSeparatorPatternCache(String pathSeparator) { + this.endsOnWildCard = pathSeparator + "*"; + this.endsOnDoubleWildCard = pathSeparator + "**"; + } + + public String getEndsOnWildCard() { + return this.endsOnWildCard; + } + + public String getEndsOnDoubleWildCard() { + return this.endsOnDoubleWildCard; + } + } }
http://git-wip-us.apache.org/repos/asf/incubator-tamaya/blob/95885781/core/src/main/java/org/apache/tamaya/core/internal/resource/ClassPathResource.java ---------------------------------------------------------------------- diff --git a/core/src/main/java/org/apache/tamaya/core/internal/resource/ClassPathResource.java b/core/src/main/java/org/apache/tamaya/core/internal/resource/ClassPathResource.java index 6b10e8b..15d04d6 100644 --- a/core/src/main/java/org/apache/tamaya/core/internal/resource/ClassPathResource.java +++ b/core/src/main/java/org/apache/tamaya/core/internal/resource/ClassPathResource.java @@ -28,227 +28,231 @@ import java.util.Objects; /** * {@link Resource} implementation for class path resources. * Uses either a given ClassLoader or a given Class for loading resources. - * + * <p> * <p>Supports resolution as {@code java.io.File} if the class path * resource resides in the file system, but not for resources in a JAR. * Always supports resolution as URL. * * @author Juergen Hoeller * @author Sam Brannen - * @since 28.12.2003 * @see ClassLoader#getResourceAsStream(String) * @see Class#getResourceAsStream(String) + * @since 28.12.2003 */ public class ClassPathResource extends AbstractFileResolvingResource { - private final String path; - - private ClassLoader classLoader; - - private Class<?> clazz; - - - /** - * Create a new {@code ClassPathResource} for {@code ClassLoader} usage. - * A leading slash will be removed, as the ClassLoader resource access - * methods will not accept it. - * <p>The thread context class loader will be used for - * loading the resource. - * @param path the absolute path within the class path - * @see java.lang.ClassLoader#getResourceAsStream(String) - */ - public ClassPathResource(String path) { - this(path, (ClassLoader) null); - } - - /** - * Create a new {@code ClassPathResource} for {@code ClassLoader} usage. - * A leading slash will be removed, as the ClassLoader resource access - * methods will not accept it. - * @param path the absolute path within the classpath - * @param classLoader the class loader to load the resource with, - * or {@code null} for the thread context class loader - * @see ClassLoader#getResourceAsStream(String) - */ - public ClassPathResource(String path, ClassLoader classLoader) { - Objects.requireNonNull(path, "Path must not be null"); - String pathToUse = StringUtils.cleanPath(path); - if (pathToUse.startsWith("/")) { - pathToUse = pathToUse.substring(1); - } - this.path = pathToUse; - this.classLoader = (classLoader != null ? classLoader : ClassUtils.getDefaultClassLoader()); - } - - /** - * Create a new {@code ClassPathResource} for {@code Class} usage. - * The path can be relative to the given class, or absolute within - * the classpath via a leading slash. - * @param path relative or absolute path within the class path - * @param clazz the class to load resources with - * @see java.lang.Class#getResourceAsStream - */ - public ClassPathResource(String path, Class<?> clazz) { - Objects.requireNonNull(path, "Path must not be null"); - this.path = StringUtils.cleanPath(path); - this.clazz = clazz; - } - - /** - * Create a new {@code ClassPathResource} with optional {@code ClassLoader} - * and {@code Class}. Only for internal usage. - * @param path relative or absolute path within the classpath - * @param classLoader the class loader to load the resource with, if any - * @param clazz the class to load resources with, if any - */ - protected ClassPathResource(String path, ClassLoader classLoader, Class<?> clazz) { - this.path = StringUtils.cleanPath(path); - this.classLoader = classLoader; - this.clazz = clazz; - } - - - /** - * Return the path for this resource (as resource path within the class path). - */ - public final String getPath() { - return this.path; - } - - /** - * Return the ClassLoader that this resource will be obtained from. - */ - public final ClassLoader getClassLoader() { - return (this.clazz != null ? this.clazz.getClassLoader() : this.classLoader); - } - - - /** - * This implementation checks for the resolution current a resource URL. - * @see java.lang.ClassLoader#getResource(String) - * @see java.lang.Class#getResource(String) - */ - @Override - public boolean exists() { - return (resolveURL() != null); - } - - /** - * Resolves a URL for the underlying class path resource. - * @return the resolved URL, or {@code null} if not resolvable - */ - protected URL resolveURL() { - if (this.clazz != null) { - return this.clazz.getResource(this.path); - } - else if (this.classLoader != null) { - return this.classLoader.getResource(this.path); - } - else { - return ClassLoader.getSystemResource(this.path); - } - } - - /** - * This implementation opens an InputStream for the given class path resource. - * @see java.lang.ClassLoader#getResourceAsStream(String) - * @see java.lang.Class#getResourceAsStream(String) - */ - @Override - public InputStream getInputStream()throws IOException { - InputStream is; - if (this.clazz != null) { - is = this.clazz.getResourceAsStream(this.path); - } - else if (this.classLoader != null) { - is = this.classLoader.getResourceAsStream(this.path); - } - else { - is = ClassLoader.getSystemResourceAsStream(this.path); - } - if (is == null) { - throw new IOException(getDisplayName() + " cannot be opened because it does not exist"); - } - return is; - } - - /** - * This implementation returns a URL for the underlying class path resource, - * if available. - * @see java.lang.ClassLoader#getResource(String) - * @see java.lang.Class#getResource(String) - */ - @Override - public URL toURL() throws IOException { - URL url = resolveURL(); - if (url == null) { - throw new FileNotFoundException(getDisplayName() + " cannot be resolved to URL because it does not exist"); - } - return url; - } - - /** - * This implementation creates a ClassPathResource, applying the given path - * relative to the path current the underlying resource current this descriptor. - */ - @Override - public Resource createRelative(String relativePath) { - String pathToUse = StringUtils.applyRelativePath(this.path, relativePath); - return new ClassPathResource(pathToUse, this.classLoader, this.clazz); - } - - /** - * This implementation returns the name current the file that this class path - * resource refers to. - */ - @Override - public String getDisplayName() { - return StringUtils.getFilename(this.path); - } - - /** - * This implementation returns a description that includes the class path location. - */ + private final String path; + + private ClassLoader classLoader; + + private Class<?> clazz; + + + /** + * Create a new {@code ClassPathResource} for {@code ClassLoader} usage. + * A leading slash will be removed, as the ClassLoader resource access + * methods will not accept it. + * <p>The thread context class loader will be used for + * loading the resource. + * + * @param path the absolute path within the class path + * @see java.lang.ClassLoader#getResourceAsStream(String) + */ + public ClassPathResource(String path) { + this(path, (ClassLoader) null); + } + + /** + * Create a new {@code ClassPathResource} for {@code ClassLoader} usage. + * A leading slash will be removed, as the ClassLoader resource access + * methods will not accept it. + * + * @param path the absolute path within the classpath + * @param classLoader the class loader to load the resource with, + * or {@code null} for the thread context class loader + * @see ClassLoader#getResourceAsStream(String) + */ + public ClassPathResource(String path, ClassLoader classLoader) { + Objects.requireNonNull(path, "Path must not be null"); + String pathToUse = StringUtils.cleanPath(path); + if (pathToUse.startsWith("/")) { + pathToUse = pathToUse.substring(1); + } + this.path = pathToUse; + this.classLoader = (classLoader != null ? classLoader : ClassUtils.getDefaultClassLoader()); + } + + /** + * Create a new {@code ClassPathResource} for {@code Class} usage. + * The path can be relative to the given class, or absolute within + * the classpath via a leading slash. + * + * @param path relative or absolute path within the class path + * @param clazz the class to load resources with + * @see java.lang.Class#getResourceAsStream + */ + public ClassPathResource(String path, Class<?> clazz) { + Objects.requireNonNull(path, "Path must not be null"); + this.path = StringUtils.cleanPath(path); + this.clazz = clazz; + } + + /** + * Create a new {@code ClassPathResource} with optional {@code ClassLoader} + * and {@code Class}. Only for internal usage. + * + * @param path relative or absolute path within the classpath + * @param classLoader the class loader to load the resource with, if any + * @param clazz the class to load resources with, if any + */ + protected ClassPathResource(String path, ClassLoader classLoader, Class<?> clazz) { + this.path = StringUtils.cleanPath(path); + this.classLoader = classLoader; + this.clazz = clazz; + } + + + /** + * Return the path for this resource (as resource path within the class path). + */ + public final String getPath() { + return this.path; + } + + /** + * Return the ClassLoader that this resource will be obtained from. + */ + public final ClassLoader getClassLoader() { + return (this.clazz != null ? this.clazz.getClassLoader() : this.classLoader); + } + + + /** + * This implementation checks for the resolution current a resource URL. + * + * @see java.lang.ClassLoader#getResource(String) + * @see java.lang.Class#getResource(String) + */ @Override - public String toString() { - StringBuilder builder = new StringBuilder("ClassPathResource ["); - String pathToUse = path; - if (this.clazz != null && !pathToUse.startsWith("/")) { - builder.append(ClassUtils.classPackageAsResourcePath(this.clazz)); - builder.append('/'); - } - if (pathToUse.startsWith("/")) { - pathToUse = pathToUse.substring(1); - } - builder.append(pathToUse); - builder.append(']'); - return builder.toString(); - } - - /** - * This implementation compares the underlying class path locations. - */ - @Override - public boolean equals(Object obj) { - if (obj == this) { - return true; - } - if (obj instanceof ClassPathResource) { - ClassPathResource otherRes = (ClassPathResource) obj; - return (this.path.equals(otherRes.path) && - Objects.equals(this.classLoader, otherRes.classLoader) && + public boolean exists() { + return (resolveURL() != null); + } + + /** + * Resolves a URL for the underlying class path resource. + * + * @return the resolved URL, or {@code null} if not resolvable + */ + protected URL resolveURL() { + if (this.clazz != null) { + return this.clazz.getResource(this.path); + } else if (this.classLoader != null) { + return this.classLoader.getResource(this.path); + } else { + return ClassLoader.getSystemResource(this.path); + } + } + + /** + * This implementation opens an InputStream for the given class path resource. + * + * @see java.lang.ClassLoader#getResourceAsStream(String) + * @see java.lang.Class#getResourceAsStream(String) + */ + @Override + public InputStream getInputStream() throws IOException { + InputStream is; + if (this.clazz != null) { + is = this.clazz.getResourceAsStream(this.path); + } else if (this.classLoader != null) { + is = this.classLoader.getResourceAsStream(this.path); + } else { + is = ClassLoader.getSystemResourceAsStream(this.path); + } + if (is == null) { + throw new IOException(getDisplayName() + " cannot be opened because it does not exist"); + } + return is; + } + + /** + * This implementation returns a URL for the underlying class path resource, + * if available. + * + * @see java.lang.ClassLoader#getResource(String) + * @see java.lang.Class#getResource(String) + */ + @Override + public URL toURL() throws IOException { + URL url = resolveURL(); + if (url == null) { + throw new FileNotFoundException(getDisplayName() + " cannot be resolved to URL because it does not exist"); + } + return url; + } + + /** + * This implementation creates a ClassPathResource, applying the given path + * relative to the path current the underlying resource current this descriptor. + */ + @Override + public Resource createRelative(String relativePath) { + String pathToUse = StringUtils.applyRelativePath(this.path, relativePath); + return new ClassPathResource(pathToUse, this.classLoader, this.clazz); + } + + /** + * This implementation returns the name current the file that this class path + * resource refers to. + */ + @Override + public String getDisplayName() { + return StringUtils.getFilename(this.path); + } + + /** + * This implementation returns a description that includes the class path location. + */ + @Override + public String toString() { + StringBuilder builder = new StringBuilder("ClassPathResource ["); + String pathToUse = path; + if (this.clazz != null && !pathToUse.startsWith("/")) { + builder.append(ClassUtils.classPackageAsResourcePath(this.clazz)); + builder.append('/'); + } + if (pathToUse.startsWith("/")) { + pathToUse = pathToUse.substring(1); + } + builder.append(pathToUse); + builder.append(']'); + return builder.toString(); + } + + /** + * This implementation compares the underlying class path locations. + */ + @Override + public boolean equals(Object obj) { + if (obj == this) { + return true; + } + if (obj instanceof ClassPathResource) { + ClassPathResource otherRes = (ClassPathResource) obj; + return (this.path.equals(otherRes.path) && + Objects.equals(this.classLoader, otherRes.classLoader) && Objects.equals(this.clazz, otherRes.clazz)); - } - return false; - } - - /** - * This implementation returns the hash code current the underlying - * class path location. - */ - @Override - public int hashCode() { - return this.path.hashCode(); - } + } + return false; + } + + /** + * This implementation returns the hash code current the underlying + * class path location. + */ + @Override + public int hashCode() { + return this.path.hashCode(); + } } http://git-wip-us.apache.org/repos/asf/incubator-tamaya/blob/95885781/core/src/main/java/org/apache/tamaya/core/internal/resource/DefaultResourceLoader.java ---------------------------------------------------------------------- diff --git a/core/src/main/java/org/apache/tamaya/core/internal/resource/DefaultResourceLoader.java b/core/src/main/java/org/apache/tamaya/core/internal/resource/DefaultResourceLoader.java index c65be65..c19ac62 100644 --- a/core/src/main/java/org/apache/tamaya/core/internal/resource/DefaultResourceLoader.java +++ b/core/src/main/java/org/apache/tamaya/core/internal/resource/DefaultResourceLoader.java @@ -1,3 +1,18 @@ +/* + * Copyright 2002-2014 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ package org.apache.tamaya.core.internal.resource; import org.apache.tamaya.core.resources.Resource; @@ -18,7 +33,7 @@ import java.util.logging.Logger; * Simple default implementation of the resource loader. */ @Priority(0) -public class DefaultResourceLoader implements ResourceLoader{ +public class DefaultResourceLoader implements ResourceLoader { private static final Logger LOG = Logger.getLogger(DefaultResourceLoader.class.getName()); @@ -27,9 +42,9 @@ public class DefaultResourceLoader implements ResourceLoader{ @Override public List<Resource> getResources(ClassLoader classLoader, Collection<String> expressions) { List<Resource> resources = new ArrayList<>(); - for(String expression:expressions){ - if(tryClassPath(classLoader, expression, resources) || tryFile(expression, resources) || tryURL(expression, resources) - || tryAntPath(classLoader, expression, resources)){ + for (String expression : expressions) { + if (tryClassPath(classLoader, expression, resources) || tryFile(expression, resources) || tryURL(expression, resources) + || tryAntPath(classLoader, expression, resources)) { continue; } LOG.warning("Failed to resolve resource: " + expression); @@ -38,41 +53,38 @@ public class DefaultResourceLoader implements ResourceLoader{ } private boolean tryClassPath(ClassLoader classLoader, String expression, List<Resource> resources) { - try{ + try { Enumeration<URL> urls = classLoader.getResources(expression); - while(urls.hasMoreElements()){ + while (urls.hasMoreElements()) { URL url = urls.nextElement(); resources.add(new UrlResource(url)); } return !resources.isEmpty(); - } - catch(Exception e){ + } catch (Exception e) { LOG.finest(() -> "Failed to load resource from CP: " + expression); } return false; } private boolean tryFile(String expression, List<Resource> resources) { - try{ + try { File file = new File(expression); - if(file.exists()) { + if (file.exists()) { resources.add(new FileSystemResource(file)); return true; } - } - catch(Exception e){ + } catch (Exception e) { LOG.finest(() -> "Failed to load resource from file: " + expression); } return false; } private boolean tryURL(String expression, List<Resource> resources) { - try{ + try { URL url = new URL(expression); resources.add(new UrlResource(url)); return true; - } - catch(Exception e){ + } catch (Exception e) { LOG.finest(() -> "Failed to load resource from file: " + expression); } return false; @@ -81,11 +93,10 @@ public class DefaultResourceLoader implements ResourceLoader{ private boolean tryAntPath(ClassLoader classLoader, String expression, List<Resource> resources) { PathMatchingResourcePatternResolver loader = resourceLoaders.computeIfAbsent(classLoader, cl -> new PathMatchingResourcePatternResolver(cl)); - try{ + try { resources.addAll(Arrays.asList(loader.getResources(expression))); return !resources.isEmpty(); - } - catch(Exception e){ + } catch (Exception e) { LOG.finest(() -> "Failed to load resources from pattern: " + expression); } return false; http://git-wip-us.apache.org/repos/asf/incubator-tamaya/blob/95885781/core/src/main/java/org/apache/tamaya/core/internal/resource/FileSystemResource.java ---------------------------------------------------------------------- diff --git a/core/src/main/java/org/apache/tamaya/core/internal/resource/FileSystemResource.java b/core/src/main/java/org/apache/tamaya/core/internal/resource/FileSystemResource.java index efeecef..c5fa68e 100644 --- a/core/src/main/java/org/apache/tamaya/core/internal/resource/FileSystemResource.java +++ b/core/src/main/java/org/apache/tamaya/core/internal/resource/FileSystemResource.java @@ -33,188 +33,200 @@ import java.util.Objects; * Obviously supports resolution as File, and also as URL. * * @author Juergen Hoeller - * @since 28.12.2003 * @see java.io.File + * @since 28.12.2003 */ public class FileSystemResource implements Resource { - private final File file; - - private final String path; - - - /** - * Create a new {@code FileSystemResource} from a {@link File} handle. - * <p>Note: When building relative resources via {@link #createRelative}, - * the relative path will applyChanges <i>at the same directory level</i>: - * e.g. new File("C:/dir1"), relative path "dir2" -> "C:/dir2"! - * If you prefer to have relative paths built underneath the given root - * directory, use the {@link #FileSystemResource(String) constructor with a file path} - * to append a trailing slash to the root path: "C:/dir1/", which - * indicates this directory as root for all relative paths. - * @param file a File handle - */ - public FileSystemResource(File file) { - Objects.requireNonNull(file, "File must not be null"); - this.file = file; - this.path = StringUtils.cleanPath(file.getPath()); - } - - /** - * Create a new {@code FileSystemResource} from a file path. - * <p>Note: When building relative resources via {@link #createRelative}, - * it makes a difference whether the specified resource base path here - * ends with a slash or not. In the case current "C:/dir1/", relative paths - * will be built underneath that root: e.g. relative path "dir2" -> - * "C:/dir1/dir2". In the case current "C:/dir1", relative paths will applyChanges - * at the same directory level: relative path "dir2" -> "C:/dir2". - * @param path a file path - */ - public FileSystemResource(String path) { - Objects.requireNonNull(path, "Path must not be null"); - this.file = new File(path); - this.path = StringUtils.cleanPath(path); - } - - - /** - * Return the file path for this resource. - */ - public final String getPath() { - return this.path; - } - - - /** - * This implementation returns whether the underlying file exists. - * @see java.io.File#exists() - */ - @Override - public boolean exists() { - return this.file.exists(); - } - - /** - * This implementation checks whether the underlying file is marked as readable - * (and corresponds to an actual file with content, not to a directory). - * @see java.io.File#canRead() - * @see java.io.File#isDirectory() - */ - @Override - public boolean isReadable() { - return (this.file.canRead() && !this.file.isDirectory()); - } - - /** - * This implementation opens a FileInputStream for the underlying file. - * @see java.io.FileInputStream - */ - @Override - public InputStream getInputStream() throws IOException { - return new FileInputStream(this.file); - } - - /** - * This implementation returns a URL for the underlying file. - * @see java.io.File#toURI() - */ - @Override - public URL toURL() throws IOException { - return this.file.toURI().toURL(); - } - - /** - * This implementation returns a URI for the underlying file. - * @see java.io.File#toURI() - */ - @Override - public URI getURI() throws IOException { - return this.file.toURI(); - } - - /** - * This implementation returns the underlying File reference. - */ - @Override - public File toFile() { - return this.file; - } - - /** - * This implementation returns the underlying File's length. - */ - @Override - public long contentLength() throws IOException { - return this.file.length(); - } - - /** - * This implementation creates a FileSystemResource, applying the given path - * relative to the path current the underlying file current this resource descriptor. - * @see StringUtils#applyRelativePath(String, String) - */ - @Override - public Resource createRelative(String relativePath) { - String pathToUse = StringUtils.applyRelativePath(this.path, relativePath); - return new FileSystemResource(pathToUse); - } - - /** - * This implementation returns the name current the file. - * @see java.io.File#getName() - */ - @Override - public String getDisplayName() { - return this.file.getName(); - } - - /** - * This implementation returns a description that includes the absolute - * path current the file. - * @see java.io.File#getAbsolutePath() - */ - @Override - public String toString() { - return "file [" + this.file.getAbsolutePath() + "]"; - } - - - // implementation current WritableResource - - /** - * This implementation checks whether the underlying file is marked as writable - * (and corresponds to an actual file with content, not to a directory). - * @see java.io.File#canWrite() - * @see java.io.File#isDirectory() - */ - public boolean isWritable() { - return (this.file.canWrite() && !this.file.isDirectory()); - } - - /** - * This implementation opens a FileOutputStream for the underlying file. - * @see java.io.FileOutputStream - */ - public OutputStream getOutputStream() throws IOException { - return new FileOutputStream(this.file); - } - - - /** - * This implementation compares the underlying File references. - */ - @Override - public boolean equals(Object obj) { - return (obj == this || - (obj instanceof FileSystemResource && this.path.equals(((FileSystemResource) obj).path))); - } - - /** - * This implementation returns the hash code current the underlying File reference. - */ - @Override - public int hashCode() { - return this.path.hashCode(); - } + private final File file; + + private final String path; + + + /** + * Create a new {@code FileSystemResource} from a {@link File} handle. + * <p>Note: When building relative resources via {@link #createRelative}, + * the relative path will applyChanges <i>at the same directory level</i>: + * e.g. new File("C:/dir1"), relative path "dir2" -> "C:/dir2"! + * If you prefer to have relative paths built underneath the given root + * directory, use the {@link #FileSystemResource(String) constructor with a file path} + * to append a trailing slash to the root path: "C:/dir1/", which + * indicates this directory as root for all relative paths. + * + * @param file a File handle + */ + public FileSystemResource(File file) { + Objects.requireNonNull(file, "File must not be null"); + this.file = file; + this.path = StringUtils.cleanPath(file.getPath()); + } + + /** + * Create a new {@code FileSystemResource} from a file path. + * <p>Note: When building relative resources via {@link #createRelative}, + * it makes a difference whether the specified resource base path here + * ends with a slash or not. In the case current "C:/dir1/", relative paths + * will be built underneath that root: e.g. relative path "dir2" -> + * "C:/dir1/dir2". In the case current "C:/dir1", relative paths will applyChanges + * at the same directory level: relative path "dir2" -> "C:/dir2". + * + * @param path a file path + */ + public FileSystemResource(String path) { + Objects.requireNonNull(path, "Path must not be null"); + this.file = new File(path); + this.path = StringUtils.cleanPath(path); + } + + + /** + * Return the file path for this resource. + */ + public final String getPath() { + return this.path; + } + + + /** + * This implementation returns whether the underlying file exists. + * + * @see java.io.File#exists() + */ + @Override + public boolean exists() { + return this.file.exists(); + } + + /** + * This implementation checks whether the underlying file is marked as readable + * (and corresponds to an actual file with content, not to a directory). + * + * @see java.io.File#canRead() + * @see java.io.File#isDirectory() + */ + @Override + public boolean isReadable() { + return (this.file.canRead() && !this.file.isDirectory()); + } + + /** + * This implementation opens a FileInputStream for the underlying file. + * + * @see java.io.FileInputStream + */ + @Override + public InputStream getInputStream() throws IOException { + return new FileInputStream(this.file); + } + + /** + * This implementation returns a URL for the underlying file. + * + * @see java.io.File#toURI() + */ + @Override + public URL toURL() throws IOException { + return this.file.toURI().toURL(); + } + + /** + * This implementation returns a URI for the underlying file. + * + * @see java.io.File#toURI() + */ + @Override + public URI getURI() throws IOException { + return this.file.toURI(); + } + + /** + * This implementation returns the underlying File reference. + */ + @Override + public File toFile() { + return this.file; + } + + /** + * This implementation returns the underlying File's length. + */ + @Override + public long contentLength() throws IOException { + return this.file.length(); + } + + /** + * This implementation creates a FileSystemResource, applying the given path + * relative to the path current the underlying file current this resource descriptor. + * + * @see StringUtils#applyRelativePath(String, String) + */ + @Override + public Resource createRelative(String relativePath) { + String pathToUse = StringUtils.applyRelativePath(this.path, relativePath); + return new FileSystemResource(pathToUse); + } + + /** + * This implementation returns the name current the file. + * + * @see java.io.File#getName() + */ + @Override + public String getDisplayName() { + return this.file.getName(); + } + + /** + * This implementation returns a description that includes the absolute + * path current the file. + * + * @see java.io.File#getAbsolutePath() + */ + @Override + public String toString() { + return "file [" + this.file.getAbsolutePath() + "]"; + } + + + // implementation current WritableResource + + /** + * This implementation checks whether the underlying file is marked as writable + * (and corresponds to an actual file with content, not to a directory). + * + * @see java.io.File#canWrite() + * @see java.io.File#isDirectory() + */ + public boolean isWritable() { + return (this.file.canWrite() && !this.file.isDirectory()); + } + + /** + * This implementation opens a FileOutputStream for the underlying file. + * + * @see java.io.FileOutputStream + */ + public OutputStream getOutputStream() throws IOException { + return new FileOutputStream(this.file); + } + + + /** + * This implementation compares the underlying File references. + */ + @Override + public boolean equals(Object obj) { + return (obj == this || + (obj instanceof FileSystemResource && this.path.equals(((FileSystemResource) obj).path))); + } + + /** + * This implementation returns the hash code current the underlying File reference. + */ + @Override + public int hashCode() { + return this.path.hashCode(); + } }
