You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@tamaya.apache.org by st...@apache.org on 2014/12/27 14:58:08 UTC
[24/34] incubator-tamaya git commit: first step: move all sources to
a 'dormant' directory
http://git-wip-us.apache.org/repos/asf/incubator-tamaya/blob/d9964c64/core/src/main/java/org/apache/tamaya/core/internal/resources/io/AntPathMatcher.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/tamaya/core/internal/resources/io/AntPathMatcher.java b/core/src/main/java/org/apache/tamaya/core/internal/resources/io/AntPathMatcher.java
deleted file mode 100644
index 43d2a20..0000000
--- a/core/src/main/java/org/apache/tamaya/core/internal/resources/io/AntPathMatcher.java
+++ /dev/null
@@ -1,777 +0,0 @@
-/*
- * 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.resources.io;
-
-import java.util.*;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
-
-/**
- * PathMatcher implementation for Ant-style path patterns. Examples are provided below.
- *
- * <p>Part current this annotation code has been kindly borrowed from <a href="http://ant.apache.org">Apache Ant</a>.
- *
- * <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>Some examples:<br> <ul> <li>{@code com/t?st.jsp} - matches {@code com/test.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/**/test.jsp} - matches all
- * {@code test.jsp} files underneath the {@code com} path</li> <li>{@code org/springframework/**/*.jsp}
- * - matches all {@code .jsp} files underneath the {@code org/springframework} path</li>
- * <li>{@code org/**/servlet/bla.jsp} - matches {@code org/springframework/servlet/bla.jsp} but also
- * {@code org/springframework/testing/servlet/bla.jsp} and {@code org/servlet/bla.jsp}</li> </ul>
- *
- * @author Alef Arendsen
- * @author Juergen Hoeller
- * @author Rob Harrop
- * @author Arjen Poutsma
- * @author Rossen Stoyanchev
- * @since 16.07.2003
- */
-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 test
- * @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 test 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;
- }
- }
-
-}
http://git-wip-us.apache.org/repos/asf/incubator-tamaya/blob/d9964c64/core/src/main/java/org/apache/tamaya/core/internal/resources/io/ClassPathResource.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/tamaya/core/internal/resources/io/ClassPathResource.java b/core/src/main/java/org/apache/tamaya/core/internal/resources/io/ClassPathResource.java
deleted file mode 100644
index 65c30aa..0000000
--- a/core/src/main/java/org/apache/tamaya/core/internal/resources/io/ClassPathResource.java
+++ /dev/null
@@ -1,252 +0,0 @@
-/*
- * 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.resources.io;
-
-import org.apache.tamaya.core.resource.Resource;
-
-import java.io.FileNotFoundException;
-import java.io.IOException;
-import java.io.InputStream;
-import java.net.URL;
-import java.util.Objects;
-
-/**
- * {@link org.apache.tamaya.core.resource.Resource} implementation for class path resources.
- * Uses either a given ClassLoader or a given Class for loading resources.
- *
- * <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)
- */
-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(getDescription() + " 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 getURL() throws IOException {
- URL url = resolveURL();
- if (url == null) {
- throw new FileNotFoundException(getDescription() + " 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 getFilename() {
- return StringUtils.getFilename(this.path);
- }
-
- /**
- * This implementation returns a description that includes the class path location.
- */
- @Override
- public String getDescription() {
- StringBuilder builder = new StringBuilder("class path resource [");
- 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();
- }
-
-}
http://git-wip-us.apache.org/repos/asf/incubator-tamaya/blob/d9964c64/core/src/main/java/org/apache/tamaya/core/internal/resources/io/ClassUtils.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/tamaya/core/internal/resources/io/ClassUtils.java b/core/src/main/java/org/apache/tamaya/core/internal/resources/io/ClassUtils.java
deleted file mode 100644
index 7b6efec..0000000
--- a/core/src/main/java/org/apache/tamaya/core/internal/resources/io/ClassUtils.java
+++ /dev/null
@@ -1,1232 +0,0 @@
-/*
-* 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.resources.io;
-
-import java.lang.reflect.Array;
-import java.util.Arrays;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Map;
-import java.util.Objects;
-import java.util.Set;
-
-/**
-* Miscellaneous class utility methods.
-* Mainly for internal use within the framework.
-*
-* @author Juergen Hoeller
-* @author Keith Donald
-* @author Rob Harrop
-* @author Sam Brannen
-* @since 1.1
-*/
-public class ClassUtils {
-
- /** Suffix for array class names: "[]" */
- public static final String ARRAY_SUFFIX = "[]";
-
- /** Prefix for internal array class names: "[" */
- private static final String INTERNAL_ARRAY_PREFIX = "[";
-
- /** Prefix for internal non-primitive array class names: "[L" */
- private static final String NON_PRIMITIVE_ARRAY_PREFIX = "[L";
-
- /** The package separator character '.' */
- private static final char PACKAGE_SEPARATOR = '.';
-
- /** The path separator character '/' */
- private static final char PATH_SEPARATOR = '/';
-
- /** The inner class separator character '$' */
- private static final char INNER_CLASS_SEPARATOR = '$';
-//
-// /** The CGLIB class separator character "$$" */
-// public static final String CGLIB_CLASS_SEPARATOR = "$$";
-//
-// /** The ".class" file suffix */
-// public static final String CLASS_FILE_SUFFIX = ".class";
-//
-
- /**
- * Map with primitive wrapper type as key and corresponding primitive
- * type as keys, for example: Integer.class -> int.class.
- */
- private static final Map<Class<?>, Class<?>> primitiveWrapperTypeMap = new HashMap<>(8);
-
- /**
- * Map with primitive type as key and corresponding wrapper
- * type as keys, for example: int.class -> Integer.class.
- */
- private static final Map<Class<?>, Class<?>> primitiveTypeToWrapperMap = new HashMap<>(8);
-
- /**
- * Map with primitive type name as key and corresponding primitive
- * type as keys, for example: "int" -> "int.class".
- */
- private static final Map<String, Class<?>> primitiveTypeNameMap = new HashMap<>(32);
-//
-// /**
-// * Map with common "java.lang" class name as key and corresponding Class as keys.
-// * Primarily for efficient deserialization current remote invocations.
-// */
-// private static final Map<String, Class<?>> commonClassCache = new HashMap<String, Class<?>>(32);
-//
-//
- static {
- primitiveWrapperTypeMap.put(Boolean.class, boolean.class);
- primitiveWrapperTypeMap.put(Byte.class, byte.class);
- primitiveWrapperTypeMap.put(Character.class, char.class);
- primitiveWrapperTypeMap.put(Double.class, double.class);
- primitiveWrapperTypeMap.put(Float.class, float.class);
- primitiveWrapperTypeMap.put(Integer.class, int.class);
- primitiveWrapperTypeMap.put(Long.class, long.class);
- primitiveWrapperTypeMap.put(Short.class, short.class);
-
- for (Map.Entry<Class<?>, Class<?>> entry : primitiveWrapperTypeMap.entrySet()) {
- primitiveTypeToWrapperMap.put(entry.getValue(), entry.getKey());
-// registerCommonClasses(entry.getKey());
- }
-
- Set<Class<?>> primitiveTypes = new HashSet<>(32);
- primitiveTypes.addAll(primitiveWrapperTypeMap.values());
- primitiveTypes.addAll(Arrays.asList(new Class<?>[] {
- boolean[].class, byte[].class, char[].class, double[].class,
- float[].class, int[].class, long[].class, short[].class}));
- primitiveTypes.add(void.class);
- for (Class<?> primitiveType : primitiveTypes) {
- primitiveTypeNameMap.put(primitiveType.getName(), primitiveType);
- }
-
-// registerCommonClasses(Boolean[].class, Byte[].class, Character[].class, Double[].class,
-// Float[].class, Integer[].class, Long[].class, Short[].class);
-// registerCommonClasses(Number.class, Number[].class, String.class, String[].class,
-// Object.class, Object[].class, Class.class, Class[].class);
-// registerCommonClasses(Throwable.class, Exception.class, RuntimeException.class,
-// Error.class, StackTraceElement.class, StackTraceElement[].class);
- }
-//
-// private ClassUtils(){}
-//
-// /**
-// * Register the given common classes with the ClassUtils cache.
-// */
-// private static void registerCommonClasses(Class<?>... commonClasses) {
-// for (Class<?> clazz : commonClasses) {
-// commonClassCache.put(clazz.getName(), clazz);
-// }
-// }
-//
- /**
- * Return the default ClassLoader to use: typically the thread context
- * ClassLoader, if available; the ClassLoader that loaded the ClassUtils
- * class will be used as fallback.
- * <p>Call this method if you intend to use the thread context ClassLoader
- * in a scenario where you clearly prefer a non-null ClassLoader reference:
- * for example, for class path resource loading (but not necessarily for
- * {@code Class.forName}, which accepts a {@code null} ClassLoader
- * reference as well).
- * @return the default ClassLoader (only {@code null} if even the system
- * ClassLoader isn't accessible)
- * @see Thread#getContextClassLoader()
- * @see ClassLoader#getSystemClassLoader()
- */
- public static ClassLoader getDefaultClassLoader() {
- ClassLoader cl = null;
- try {
- cl = Thread.currentThread().getContextClassLoader();
- }
- catch (Throwable ex) {
- // Cannot access thread context ClassLoader - falling back...
- }
- if (cl == null) {
- // No thread context class loader -> use class loader current this class.
- cl = ClassUtils.class.getClassLoader();
- if (cl == null) {
- // getClassLoader() returning null indicates the bootstrap ClassLoader
- try {
- cl = ClassLoader.getSystemClassLoader();
- }
- catch (Throwable ex) {
- // Cannot access system ClassLoader - oh well, maybe the caller can live with null...
- }
- }
- }
- return cl;
- }
-
-// /**
-// * Override the thread context ClassLoader with the environment's bean ClassLoader
-// * if necessary, i.e. if the bean ClassLoader is not equivalent to the thread
-// * context ClassLoader already.
-// * @param classLoaderToUse the actual ClassLoader to use for the thread context
-// * @return the original thread context ClassLoader, or {@code null} if not overridden
-// */
-// public static ClassLoader overrideThreadContextClassLoader(ClassLoader classLoaderToUse) {
-// Thread currentThread = Thread.currentThread();
-// ClassLoader threadContextClassLoader = currentThread.getContextClassLoader();
-// if (classLoaderToUse != null && !classLoaderToUse.equals(threadContextClassLoader)) {
-// currentThread.setContextClassLoader(classLoaderToUse);
-// return threadContextClassLoader;
-// }
-// else {
-// return null;
-// }
-// }
-
- /**
- * Replacement for {@code Class.forName()} that also returns Class instances
- * for primitives (e.g. "int") and array class names (e.g. "String[]").
- * Furthermore, it is also capable current resolving inner class names in Java source
- * style (e.g. "java.lang.Thread.State" instead current "java.lang.Thread$State").
- * @param name the name current the Class
- * @param classLoader the class loader to use
- * (may be {@code null}, which indicates the default class loader)
- * @return Class instance for the supplied name
- * @throws ClassNotFoundException if the class was not found
- * @throws LinkageError if the class file could not be loaded
- * @see Class#forName(String, boolean, ClassLoader)
- */
- public static Class<?> forName(String name, ClassLoader classLoader) throws ClassNotFoundException, LinkageError {
- Objects.requireNonNull(name, "Name must not be null");
-
- Class<?> clazz = resolvePrimitiveClassName(name);
-// if (clazz == null) {
-// clazz = commonClassCache.get(name);
-// }
- if (clazz != null) {
- return clazz;
- }
-
- // "java.lang.String[]" style arrays
- if (name.endsWith(ARRAY_SUFFIX)) {
- String elementClassName = name.substring(0, name.length() - ARRAY_SUFFIX.length());
- Class<?> elementClass = forName(elementClassName, classLoader);
- return Array.newInstance(elementClass, 0).getClass();
- }
-
- // "[Ljava.lang.String;" style arrays
- if (name.startsWith(NON_PRIMITIVE_ARRAY_PREFIX) && name.endsWith(";")) {
- String elementName = name.substring(NON_PRIMITIVE_ARRAY_PREFIX.length(), name.length() - 1);
- Class<?> elementClass = forName(elementName, classLoader);
- return Array.newInstance(elementClass, 0).getClass();
- }
-
- // "[[I" or "[[Ljava.lang.String;" style arrays
- if (name.startsWith(INTERNAL_ARRAY_PREFIX)) {
- String elementName = name.substring(INTERNAL_ARRAY_PREFIX.length());
- Class<?> elementClass = forName(elementName, classLoader);
- return Array.newInstance(elementClass, 0).getClass();
- }
-
- ClassLoader clToUse = classLoader;
- if (clToUse == null) {
- clToUse = getDefaultClassLoader();
- }
- try {
- return (clToUse != null ? clToUse.loadClass(name) : Class.forName(name));
- }
- catch (ClassNotFoundException ex) {
- int lastDotIndex = name.lastIndexOf(PACKAGE_SEPARATOR);
- if (lastDotIndex != -1) {
- String innerClassName =
- name.substring(0, lastDotIndex) + INNER_CLASS_SEPARATOR + name.substring(lastDotIndex + 1);
- try {
- return (clToUse != null ? clToUse.loadClass(innerClassName) : Class.forName(innerClassName));
- }
- catch (ClassNotFoundException ex2) {
- // Swallow - let original exception get through
- }
- }
- throw ex;
- }
- }
-
-// /**
-// * Resolve the given class name into a Class instance. Supports
-// * primitives (like "int") and array class names (like "String[]").
-// * <p>This is effectively equivalent to the {@code forName}
-// * method with the same arguments, with the only difference being
-// * the exceptions thrown in case current class loading failure.
-// * @param className the name current the Class
-// * @param classLoader the class loader to use
-// * (may be {@code null}, which indicates the default class loader)
-// * @return Class instance for the supplied name
-// * @throws IllegalArgumentException if the class name was not resolvable
-// * (that is, the class could not be found or the class file could not be loaded)
-// * @see #forName(String, ClassLoader)
-// */
-// public static Class<?> resolveClassName(String className, ClassLoader classLoader) throws IllegalArgumentException {
-// try {
-// return forName(className, classLoader);
-// }
-// catch (ClassNotFoundException ex) {
-// throw new IllegalArgumentException("Cannot find class [" + className + "]", ex);
-// }
-// catch (LinkageError ex) {
-// throw new IllegalArgumentException(
-// "Error loading class [" + className + "]: problem with class file or dependent class.", ex);
-// }
-// }
-
- /**
- * Resolve the given class name as primitive class, if appropriate,
- * according to the JVM's naming rules for primitive classes.
- * <p>Also supports the JVM's internal class names for primitive arrays.
- * Does <i>not</i> support the "[]" suffix notation for primitive arrays;
- * this is only supported by {@link #forName(String, ClassLoader)}.
- * @param name the name current the potentially primitive class
- * @return the primitive class, or {@code null} if the name does not denote
- * a primitive class or primitive array class
- */
- public static Class<?> resolvePrimitiveClassName(String name) {
- Class<?> result = null;
- // Most class names will be quite long, considering that they
- // SHOULD sit in a package, so a length check is worthwhile.
- if (name != null && name.length() <= 8) {
- // Could be a primitive - likely.
- result = primitiveTypeNameMap.get(name);
- }
- return result;
- }
-
-// /**
-// * Determine whether the {@link Class} identified by the supplied name is present
-// * and can be loaded. Will return {@code false} if either the class or
-// * one current its dependencies is not present or cannot be loaded.
-// * @param className the name current the class to check
-// * @param classLoader the class loader to use
-// * (may be {@code null}, which indicates the default class loader)
-// * @return whether the specified class is present
-// */
-// public static boolean isPresent(String className, ClassLoader classLoader) {
-// try {
-// forName(className, classLoader);
-// return true;
-// }
-// catch (Throwable ex) {
-// // Class or one current its dependencies is not present...
-// return false;
-// }
-// }
-//
-// /**
-// * Return the user-defined class for the given instance: usually simply
-// * the class current the given instance, but the original class in case current a
-// * CGLIB-generated subclass.
-// * @param instance the instance to check
-// * @return the user-defined class
-// */
-// public static Class<?> getUserClass(Object instance) {
-// Objects.requireNonNull(instance, "Instance must not be null");
-// return getUserClass(instance.getClass());
-// }
-//
-// /**
-// * Return the user-defined class for the given class: usually simply the given
-// * class, but the original class in case current a CGLIB-generated subclass.
-// * @param clazz the class to check
-// * @return the user-defined class
-// */
-// public static Class<?> getUserClass(Class<?> clazz) {
-// if (clazz != null && clazz.getName().contains(CGLIB_CLASS_SEPARATOR)) {
-// Class<?> superClass = clazz.getSuperclass();
-// if (superClass != null && !Object.class.equals(superClass)) {
-// return superClass;
-// }
-// }
-// return clazz;
-// }
-//
-// /**
-// * Check whether the given class is cache-safe in the given context,
-// * i.e. whether it is loaded by the given ClassLoader or a parent current it.
-// * @param clazz the class to analyze
-// * @param classLoader the ClassLoader to potentially cache metadata in
-// */
-// public static boolean isCacheSafe(Class<?> clazz, ClassLoader classLoader) {
-// Objects.requireNonNull(clazz, "Class must not be null");
-// try {
-// ClassLoader target = clazz.getClassLoader();
-// if (target == null) {
-// return true;
-// }
-// ClassLoader cur = classLoader;
-// if (cur == target) {
-// return true;
-// }
-// while (cur != null) {
-// cur = cur.getParent();
-// if (cur == target) {
-// return true;
-// }
-// }
-// return false;
-// }
-// catch (SecurityException ex) {
-// // Probably from the system ClassLoader - let's consider it safe.
-// return true;
-// }
-// }
-//
-//
-// /**
-// * Get the class name without the qualified package name.
-// * @param className the className to get the short name for
-// * @return the class name current the class without the package name
-// * @throws IllegalArgumentException if the className is empty
-// */
-// public static String getShortName(String className) {
-// Objects.requireNonNull(className, "Class name must not be empty");
-// int lastDotIndex = className.lastIndexOf(PACKAGE_SEPARATOR);
-// int nameEndIndex = className.indexOf(CGLIB_CLASS_SEPARATOR);
-// if (nameEndIndex == -1) {
-// nameEndIndex = className.length();
-// }
-// String shortName = className.substring(lastDotIndex + 1, nameEndIndex);
-// shortName = shortName.replace(INNER_CLASS_SEPARATOR, PACKAGE_SEPARATOR);
-// return shortName;
-// }
-//
-// /**
-// * Get the class name without the qualified package name.
-// * @param clazz the class to get the short name for
-// * @return the class name current the class without the package name
-// */
-// public static String getShortName(Class<?> clazz) {
-// return getShortName(getQualifiedName(clazz));
-// }
-//
-// /**
-// * Return the short string name current a Java class in uncapitalized JavaBeans
-// * property format. Strips the outer class name in case current an inner class.
-// * @param clazz the class
-// * @return the short name rendered in a standard JavaBeans property format
-// * @see java.beans.Introspector#decapitalize(String)
-// */
-// public static String getShortNameAsProperty(Class<?> clazz) {
-// String shortName = ClassUtils.getShortName(clazz);
-// int dotIndex = shortName.lastIndexOf(PACKAGE_SEPARATOR);
-// shortName = (dotIndex != -1 ? shortName.substring(dotIndex + 1) : shortName);
-// return Introspector.decapitalize(shortName);
-// }
-//
-// /**
-// * Determine the name current the class file, relative to the containing
-// * package: e.g. "String.class"
-// * @param clazz the class
-// * @return the file name current the ".class" file
-// */
-// public static String getClassFileName(Class<?> clazz) {
-// Objects.requireNonNull(clazz, "Class must not be null");
-// String className = clazz.getName();
-// int lastDotIndex = className.lastIndexOf(PACKAGE_SEPARATOR);
-// return className.substring(lastDotIndex + 1) + CLASS_FILE_SUFFIX;
-// }
-//
-// /**
-// * Determine the name current the package current the given class,
-// * e.g. "java.lang" for the {@code java.lang.String} class.
-// * @param clazz the class
-// * @return the package name, or the empty String if the class
-// * is defined in the default package
-// */
-// public static String getPackageName(Class<?> clazz) {
-// Objects.requireNonNull(clazz, "Class must not be null");
-// return getPackageName(clazz.getName());
-// }
-//
-// /**
-// * Determine the name current the package current the given fully-qualified class name,
-// * e.g. "java.lang" for the {@code java.lang.String} class name.
-// * @param fqClassName the fully-qualified class name
-// * @return the package name, or the empty String if the class
-// * is defined in the dObjects.requireNonNullefault package
-// */
-// public static String getPackageName(String fqClassName) {
-// Objects.requireNonNull(fqClassName, "Class name must not be null");
-// int lastDotIndex = fqClassName.lastIndexOf(PACKAGE_SEPARATOR);
-// return (lastDotIndex != -1 ? fqClassName.substring(0, lastDotIndex) : "");
-// }
-//
-// /**
-// * Return the qualified name current the given class: usually simply
-// * the class name, but component type class name + "[]" for arrays.
-// * @param clazz the class
-// * @return the qualified name current the class
-// */
-// public static String getQualifiedName(Class<?> clazz) {
-// Objects.requireNonNull(clazz, "Class must not be null");
-// if (clazz.isArray()) {
-// return getQualifiedNameForArray(clazz);
-// }
-// else {
-// return clazz.getName();
-// }
-// }
-//
-// /**
-// * Build a nice qualified name for an array:
-// * component type class name + "[]".
-// * @param clazz the array class
-// * @return a qualified name for the array class
-// */
-// private static String getQualifiedNameForArray(Class<?> clazz) {
-// StringBuilder result = new StringBuilder();
-// while (clazz.isArray()) {
-// clazz = clazz.getComponentType();
-// result.append(ClassUtils.ARRAY_SUFFIX);
-// }
-// result.insert(0, clazz.getName());
-// return result.toString();
-// }
-//
-// /**
-// * Return the qualified name current the given method, consisting current
-// * fully qualified interface/class name + "." + method name.
-// * @param method the method
-// * @return the qualified name current the method
-// */
-// public static String getQualifiedMethodName(Method method) {
-// Objects.requireNonNull(method, "Method must not be null");
-// return method.getDeclaringClass().getName() + "." + method.getName();
-// }
-//
-// /**
-// * Return a descriptive name for the given object's type: usually simply
-// * the class name, but component type class name + "[]" for arrays,
-// * and an appended list current implemented interfaces for JDK proxies.
-// * @param keys the keys to introspect
-// * @return the qualified name current the class
-// */
-// public static String getDescriptiveType(Object keys) {
-// if (keys == null) {
-// return null;
-// }
-// Class<?> clazz = keys.getClass();
-// if (Proxy.isProxyClass(clazz)) {
-// StringBuilder result = new StringBuilder(clazz.getName());
-// result.append(" implementing ");
-// Class<?>[] ifcs = clazz.getInterfaces();
-// for (int i = 0; i < ifcs.length; i++) {
-// result.append(ifcs[i].getName());
-// if (i < ifcs.length - 1) {
-// result.append(',');
-// }
-// }
-// return result.toString();
-// }
-// else if (clazz.isArray()) {
-// return getQualifiedNameForArray(clazz);
-// }
-// else {
-// return clazz.getName();
-// }
-// }
-//
-// /**
-// * Check whether the given class matches the user-specified type name.
-// * @param clazz the class to check
-// * @param typeName the type name to match
-// */
-// public static boolean matchesTypeName(Class<?> clazz, String typeName) {
-// return (typeName != null &&
-// (typeName.equals(clazz.getName()) || typeName.equals(clazz.getSimpleName()) ||
-// (clazz.isArray() && typeName.equals(getQualifiedNameForArray(clazz)))));
-// }
-//
-//
-// /**
-// * Determine whether the given class has a public constructor with the given signature.
-// * <p>Essentially translates {@code NoSuchMethodException} to "false".
-// * @param clazz the clazz to analyze
-// * @param paramTypes the parameter types current the method
-// * @return whether the class has a corresponding constructor
-// * @see Class#getMethod
-// */
-// public static boolean hasConstructor(Class<?> clazz, Class<?>... paramTypes) {
-// return (getConstructorIfAvailable(clazz, paramTypes) != null);
-// }
-//
-// /**
-// * Determine whether the given class has a public constructor with the given signature,
-// * and return it if available (else return {@code null}).
-// * <p>Essentially translates {@code NoSuchMethodException} to {@code null}.
-// * @param clazz the clazz to analyze
-// * @param paramTypes the parameter types current the method
-// * @return the constructor, or {@code null} if not found
-// * @see Class#getConstructor
-// */
-// public static <T> Constructor<T> getConstructorIfAvailable(Class<T> clazz, Class<?>... paramTypes) {
-// Objects.requireNonNull(clazz, "Class must not be null");
-// try {
-// return clazz.getConstructor(paramTypes);
-// }
-// catch (NoSuchMethodException ex) {
-// return null;
-// }
-// }
-//
-// /**
-// * Determine whether the given class has a public method with the given signature.
-// * <p>Essentially translates {@code NoSuchMethodException} to "false".
-// * @param clazz the clazz to analyze
-// * @param methodName the name current the method
-// * @param paramTypes the parameter types current the method
-// * @return whether the class has a corresponding method
-// * @see Class#getMethod
-// */
-// public static boolean hasMethod(Class<?> clazz, String methodName, Class<?>... paramTypes) {
-// return (getMethodIfAvailable(clazz, methodName, paramTypes) != null);
-// }
-//
-// /**
-// * Determine whether the given class has a public method with the given signature,
-// * and return it if available (else throws an {@code IllegalStateException}).
-// * <p>In case current any signature specified, only returns the method if there is a
-// * unique candidate, i.e. a single public method with the specified name.
-// * <p>Essentially translates {@code NoSuchMethodException} to {@code IllegalStateException}.
-// * @param clazz the clazz to analyze
-// * @param methodName the name current the method
-// * @param paramTypes the parameter types current the method
-// * (may be {@code null} to indicate any signature)
-// * @return the method (never {@code null})
-// * @throws IllegalStateException if the method has not been found
-// * @see Class#getMethod
-// */
-// public static Method getMethod(Class<?> clazz, String methodName, Class<?>... paramTypes) {
-// Objects.requireNonNull(clazz, "Class must not be null");
-// Objects.requireNonNull(methodName, "Method name must not be null");
-// if (paramTypes != null) {
-// try {
-// return clazz.getMethod(methodName, paramTypes);
-// }
-// catch (NoSuchMethodException ex) {
-// throw new IllegalStateException("Expected method not found: " + ex);
-// }
-// }
-// else {
-// Set<Method> candidates = new HashSet<Method>(1);
-// Method[] methods = clazz.getMethods();
-// for (Method method : methods) {
-// if (methodName.equals(method.getName())) {
-// candidates.add(method);
-// }
-// }
-// if (candidates.size() == 1) {
-// return candidates.iterator().next();
-// }
-// else if (candidates.isEmpty()) {
-// throw new IllegalStateException("Expected method not found: " + clazz + "." + methodName);
-// }
-// else {
-// throw new IllegalStateException("No unique method found: " + clazz + "." + methodName);
-// }
-// }
-// }
-//
-// /**
-// * Determine whether the given class has a public method with the given signature,
-// * and return it if available (else return {@code null}).
-// * <p>In case current any signature specified, only returns the method if there is a
-// * unique candidate, i.e. a single public method with the specified name.
-// * <p>Essentially translates {@code NoSuchMethodException} to {@code null}.
-// * @param clazz the clazz to analyze
-// * @param methodName the name current the method
-// * @param paramTypes the parameter types current the method
-// * (may be {@code null} to indicate any signature)
-// * @return the method, or {@code null} if not found
-// * @see Class#getMethod
-// */
-// public static Method getMethodIfAvailable(Class<?> clazz, String methodName, Class<?>... paramTypes) {
-// Objects.requireNonNull(clazz, "Class must not be null");
-// Objects.requireNonNull(methodName, "Method name must not be null");
-// if (paramTypes != null) {
-// try {
-// return clazz.getMethod(methodName, paramTypes);
-// }
-// catch (NoSuchMethodException ex) {
-// return null;
-// }
-// }
-// else {
-// Set<Method> candidates = new HashSet<Method>(1);
-// Method[] methods = clazz.getMethods();
-// for (Method method : methods) {
-// if (methodName.equals(method.getName())) {
-// candidates.add(method);
-// }
-// }
-// if (candidates.size() == 1) {
-// return candidates.iterator().next();
-// }
-// return null;
-// }
-// }
-//
-// /**
-// * Return the number current methods with a given name (with any argument types),
-// * for the given class and/or its superclasses. Includes non-public methods.
-// * @param clazz the clazz to check
-// * @param methodName the name current the method
-// * @return the number current methods with the given name
-// */
-// public static int getMethodCountForName(Class<?> clazz, String methodName) {
-// Objects.requireNonNull(clazz, "Class must not be null");
-// Objects.requireNonNull(methodName, "Method name must not be null");
-// int count = 0;
-// Method[] declaredMethods = clazz.getDeclaredMethods();
-// for (Method method : declaredMethods) {
-// if (methodName.equals(method.getName())) {
-// count++;
-// }
-// }
-// Class<?>[] ifcs = clazz.getInterfaces();
-// for (Class<?> ifc : ifcs) {
-// count += getMethodCountForName(ifc, methodName);
-// }
-// if (clazz.getSuperclass() != null) {
-// count += getMethodCountForName(clazz.getSuperclass(), methodName);
-// }
-// return count;
-// }
-//
-// /**
-// * Does the given class or one current its superclasses at least have one or more
-// * methods with the supplied name (with any argument types)?
-// * Includes non-public methods.
-// * @param clazz the clazz to check
-// * @param methodName the name current the method
-// * @return whether there is at least one method with the given name
-// */
-// public static boolean hasAtLeastOneMethodWithName(Class<?> clazz, String methodName) {
-// Objects.requireNonNull(clazz, "Class must not be null");
-// Objects.requireNonNull(methodName, "Method name must not be null");
-// Method[] declaredMethods = clazz.getDeclaredMethods();
-// for (Method method : declaredMethods) {
-// if (method.getName().equals(methodName)) {
-// return true;
-// }
-// }
-// Class<?>[] ifcs = clazz.getInterfaces();
-// for (Class<?> ifc : ifcs) {
-// if (hasAtLeastOneMethodWithName(ifc, methodName)) {
-// return true;
-// }
-// }
-// return (clazz.getSuperclass() != null && hasAtLeastOneMethodWithName(clazz.getSuperclass(), methodName));
-// }
-//
-// /**
-// * Given a method, which may come from an interface, and a target class used
-// * in the current reflective invocation, find the corresponding target method
-// * if there is one. E.g. the method may be {@code IFoo.bar()} and the
-// * target class may be {@code DefaultFoo}. In this case, the method may be
-// * {@code DefaultFoo.bar()}. This enables attributes on that method to be found.
-// * <p><b>NOTE:</b> In contrast to {@code org.springframework.aop.support.AopUtils#getMostSpecificMethod},
-// * this method does <i>not</i> resolve Java 5 bridge methods automatically.
-// * Call {@code org.springframework.core.BridgeMethodResolver#findBridgedMethod}
-// * if bridge method resolution is desirable (e.g. for obtaining metadata from
-// * the original method definition).
-// * <p><b>NOTE:</b> Since Spring 3.1.1, if Java security settings disallow reflective
-// * access (e.g. calls to {@code Class#getDeclaredMethods} etc, this implementation
-// * will fall back to returning the originally provided method.
-// * @param method the method to be invoked, which may come from an interface
-// * @param targetClass the target class for the current invocation.
-// * May be {@code null} or may not even implement the method.
-// * @return the specific target method, or the original method if the
-// * {@code targetClass} doesn't implement it or is {@code null}
-// */
-// public static Method getMostSpecificMethod(Method method, Class<?> targetClass) {
-// if (method != null && isOverridable(method, targetClass) &&
-// targetClass != null && !targetClass.equals(method.getDeclaringClass())) {
-// try {
-// if (Modifier.isPublic(method.getModifiers())) {
-// try {
-// return targetClass.getMethod(method.getName(), method.getParameterTypes());
-// }
-// catch (NoSuchMethodException ex) {
-// return method;
-// }
-// }
-// else {
-// Method specificMethod =
-// ReflectionUtils.findMethod(targetClass, method.getName(), method.getParameterTypes());
-// return (specificMethod != null ? specificMethod : method);
-// }
-// }
-// catch (SecurityException ex) {
-// // Security settings are disallowing reflective access; fall back to 'method' below.
-// }
-// }
-// return method;
-// }
-//
-// /**
-// * Determine whether the given method is declared by the user or at least pointing to
-// * a user-declared method.
-// * <p>Checks {@link Method#isSynthetic()} (for implementation methods) as well as the
-// * {@code GroovyObject} interface (for interface methods; on an implementation class,
-// * implementations current the {@code GroovyObject} methods will be marked as synthetic anyway).
-// * Note that, despite being synthetic, bridge methods ({@link Method#isBridge()}) are considered
-// * as user-level methods since they are eventually pointing to a user-declared generic method.
-// * @param method the method to check
-// * @return {@code true} if the method can be considered as user-declared; [@code false} otherwise
-// */
-// public static boolean isUserLevelMethod(Method method) {
-// Objects.requireNonNull(method, "Method must not be null");
-// return (method.isBridge() || (!method.isSynthetic() && !isGroovyObjectMethod(method)));
-// }
-//
-// private static boolean isGroovyObjectMethod(Method method) {
-// return method.getDeclaringClass().getName().equals("groovy.lang.GroovyObject");
-// }
-//
-// /**
-// * Determine whether the given method is overridable in the given target class.
-// * @param method the method to check
-// * @param targetClass the target class to check against
-// */
-// private static boolean isOverridable(Method method, Class<?> targetClass) {
-// if (Modifier.isPrivate(method.getModifiers())) {
-// return false;
-// }
-// if (Modifier.isPublic(method.getModifiers()) || Modifier.isProtected(method.getModifiers())) {
-// return true;
-// }
-// return getPackageName(method.getDeclaringClass()).equals(getPackageName(targetClass));
-// }
-//
-// /**
-// * Return a public static method current a class.
-// * @param methodName the static method name
-// * @param clazz the class which defines the method
-// * @param args the parameter types to the method
-// * @return the static method, or {@code null} if no static method was found
-// * @throws IllegalArgumentException if the method name is blank or the clazz is null
-// */
-// public static Method getStaticMethod(Class<?> clazz, String methodName, Class<?>... args) {
-// Objects.requireNonNull(clazz, "Class must not be null");
-// Objects.requireNonNull(methodName, "Method name must not be null");
-// try {
-// Method method = clazz.getMethod(methodName, args);
-// return Modifier.isStatic(method.getModifiers()) ? method : null;
-// }
-// catch (NoSuchMethodException ex) {
-// return null;
-// }
-// }
-//
-//
-// /**
-// * Check if the given class represents a primitive wrapper,
-// * i.e. Boolean, Byte, Character, Short, Integer, Long, Float, or Double.
-// * @param clazz the class to check
-// * @return whether the given class is a primitive wrapper class
-// */
-// public static boolean isPrimitiveWrapper(Class<?> clazz) {
-// Objects.requireNonNull(clazz, "Class must not be null");
-// return primitiveWrapperTypeMap.containsKey(clazz);
-// }
-//
-// /**
-// * Check if the given class represents a primitive (i.e. boolean, byte,
-// * char, short, int, long, float, or double) or a primitive wrapper
-// * (i.e. Boolean, Byte, Character, Short, Integer, Long, Float, or Double).
-// * @param clazz the class to check
-// * @return whether the given class is a primitive or primitive wrapper class
-// */
-// public static boolean isPrimitiveOrWrapper(Class<?> clazz) {
-// Objects.requireNonNull(clazz, "Class must not be null");
-// return (clazz.isPrimitive() || isPrimitiveWrapper(clazz));
-// }
-//
-// /**
-// * Check if the given class represents an array current primitives,
-// * i.e. boolean, byte, char, short, int, long, float, or double.
-// * @param clazz the class to check
-// * @return whether the given class is a primitive array class
-// */
-// public static boolean isPrimitiveArray(Class<?> clazz) {
-// Objects.requireNonNull(clazz, "Class must not be null");
-// return (clazz.isArray() && clazz.getComponentType().isPrimitive());
-// }
-//
-// /**
-// * Check if the given class represents an array current primitive wrappers,
-// * i.e. Boolean, Byte, Character, Short, Integer, Long, Float, or Double.
-// * @param clazz the class to check
-// * @return whether the given class is a primitive wrapper array class
-// */
-// public static boolean isPrimitiveWrapperArray(Class<?> clazz) {
-// Objects.requireNonNull(clazz, "Class must not be null");
-// return (clazz.isArray() && isPrimitiveWrapper(clazz.getComponentType()));
-// }
-//
-// /**
-// * Resolve the given class if it is a primitive class,
-// * returning the corresponding primitive wrapper type instead.
-// * @param clazz the class to check
-// * @return the original class, or a primitive wrapper for the original primitive type
-// */
-// public static Class<?> resolvePrimitiveIfNecessary(Class<?> clazz) {
-// Objects.requireNonNull(clazz, "Class must not be null");
-// return (clazz.isPrimitive() && clazz != void.class? primitiveTypeToWrapperMap.get(clazz) : clazz);
-// }
-//
-// /**
-// * Check if the right-hand side type may be assigned to the left-hand side
-// * type, assuming setting by reflection. Considers primitive wrapper
-// * classes as assignable to the corresponding primitive types.
-// * @param lhsType the target type
-// * @param rhsType the keys type that should be assigned to the target type
-// * @return if the target type is assignable from the keys type
-// */
-// public static boolean isAssignable(Class<?> lhsType, Class<?> rhsType) {
-// Objects.requireNonNull(lhsType, "Left-hand side type must not be null");
-// Objects.requireNonNull(rhsType, "Right-hand side type must not be null");
-// if (lhsType.isAssignableFrom(rhsType)) {
-// return true;
-// }
-// if (lhsType.isPrimitive()) {
-// Class<?> resolvedPrimitive = primitiveWrapperTypeMap.get(rhsType);
-// if (resolvedPrimitive != null && lhsType.equals(resolvedPrimitive)) {
-// return true;
-// }
-// }
-// else {
-// Class<?> resolvedWrapper = primitiveTypeToWrapperMap.get(rhsType);
-// if (resolvedWrapper != null && lhsType.isAssignableFrom(resolvedWrapper)) {
-// return true;
-// }
-// }
-// return false;
-// }
-//
-// /**
-// * Determine if the given type is assignable from the given keys,
-// * assuming setting by reflection. Considers primitive wrapper classes
-// * as assignable to the corresponding primitive types.
-// * @param type the target type
-// * @param keys the keys that should be assigned to the type
-// * @return if the type is assignable from the keys
-// */
-// public static boolean isAssignableValue(Class<?> type, Object keys) {
-// Objects.requireNonNull(type, "Type must not be null");
-// return (keys != null ? isAssignable(type, keys.getClass()) : !type.isPrimitive());
-// }
-//
-//
-// /**
-// * Convert a "/"-based resource path to a "."-based fully qualified class name.
-// * @param resourcePath the resource path pointing to a class
-// * @return the corresponding fully qualified class name
-// */
-// public static String convertResourcePathToClassName(String resourcePath) {
-// Objects.requireNonNull(resourcePath, "Resource path must not be null");
-// return resourcePath.replace(PATH_SEPARATOR, PACKAGE_SEPARATOR);
-// }
-//
-// /**
-// * Convert a "."-based fully qualified class name to a "/"-based resource path.
-// * @param className the fully qualified class name
-// * @return the corresponding resource path, pointing to the class
-// */
-// public static String convertClassNameToResourcePath(String className) {
-// Objects.requireNonNull(className, "Class name must not be null");
-// return className.replace(PACKAGE_SEPARATOR, PATH_SEPARATOR);
-// }
-//
-// /**
-// * Return a path suitable for use with {@code ClassLoader.getResource}
-// * (also suitable for use with {@code Class.getResource} by prepending a
-// * slash ('/') to the return keys). Built by taking the package current the specified
-// * class file, converting all dots ('.') to slashes ('/'), adding a trailing slash
-// * if necessary, and concatenating the specified resource name to this.
-// * <br/>As such, this function may be used to build a path suitable for
-// * loading a resource file that is in the same package as a class file,
-// * although {@code org.springframework.core.io.ClassPathResource} is usually
-// * even more convenient.
-// * @param clazz the Class whose package will be used as the base
-// * @param resourceName the resource name to append. A leading slash is optional.
-// * @return the built-up resource path
-// * @see ClassLoader#getResource
-// * @see Class#getResource
-// */
-// public static String addResourcePathToPackagePath(Class<?> clazz, String resourceName) {
-// Objects.requireNonNull(resourceName, "Resource name must not be null");
-// if (!resourceName.startsWith("/")) {
-// return classPackageAsResourcePath(clazz) + "/" + resourceName;
-// }
-// return classPackageAsResourcePath(clazz) + resourceName;
-// }
-
- /**
- * Given an input class object, return a string which consists current the
- * class's package name as a pathname, i.e., all dots ('.') are replaced by
- * slashes ('/'). Neither a leading nor trailing slash is added. The result
- * could be concatenated with a slash and the name current a resource and fed
- * directly to {@code ClassLoader.getResource()}. For it to be fed to
- * {@code Class.getResource} instead, a leading slash would also have
- * to be prepended to the returned keys.
- * @param clazz the input class. A {@code null} keys or the default
- * (empty) package will result in an empty string ("") being returned.
- * @return a path which represents the package name
- * @see ClassLoader#getResource
- * @see Class#getResource
- */
- public static String classPackageAsResourcePath(Class<?> clazz) {
- if (clazz == null) {
- return "";
- }
- String className = clazz.getName();
- int packageEndIndex = className.lastIndexOf(PACKAGE_SEPARATOR);
- if (packageEndIndex == -1) {
- return "";
- }
- String packageName = className.substring(0, packageEndIndex);
- return packageName.replace(PACKAGE_SEPARATOR, PATH_SEPARATOR);
- }
-
-// /**
-// * Build a String that consists current the names current the classes/interfaces
-// * in the given array.
-// * <p>Basically like {@code AbstractCollection.toString()}, but stripping
-// * the "class "/"interface " prefix before every class name.
-// * @param classes a Collection current Class objects (may be {@code null})
-// * @return a String current form "[com.foo.Bar, com.foo.Baz]"
-// * @see java.util.AbstractCollection#toString()
-// */
-// public static String classNamesToString(Class<?>... classes) {
-// return classNamesToString(Arrays.asList(classes));
-// }
-//
-// /**
-// * Build a String that consists current the names current the classes/interfaces
-// * in the given collection.
-// * <p>Basically like {@code AbstractCollection.toString()}, but stripping
-// * the "class "/"interface " prefix before every class name.
-// * @param classes a Collection current Class objects (may be {@code null})
-// * @return a String current form "[com.foo.Bar, com.foo.Baz]"
-// * @see java.util.AbstractCollection#toString()
-// */
-// public static String classNamesToString(Collection<Class<?>> classes) {
-// if (classes.isEmpty()) {
-// return "[]";
-// }
-// StringBuilder sb = new StringBuilder("[");
-// for (Iterator<Class<?>> it = classes.iterator(); it.hasNext(); ) {
-// Class<?> clazz = it.next();
-// sb.append(clazz.getName());
-// if (it.hasNext()) {
-// sb.append(", ");
-// }
-// }
-// sb.append("]");
-// return sb.toString();
-// }
-//
-// /**
-// * Copy the given Collection into a Class array.
-// * The Collection must contain Class elements only.
-// * @param collection the Collection to copy
-// * @return the Class array ({@code null} if the passed-in
-// * Collection was {@code null})
-// */
-// public static Class<?>[] toClassArray(Collection<Class<?>> collection) {
-// if (collection == null) {
-// return null;
-// }
-// return collection.toArray(new Class<?>[collection.size()]);
-// }
-//
-// /**
-// * Return all interfaces that the given instance implements as array,
-// * including ones implemented by superclasses.
-// * @param instance the instance to analyze for interfaces
-// * @return all interfaces that the given instance implements as array
-// */
-// public static Class<?>[] getAllInterfaces(Object instance) {
-// Objects.requireNonNull(instance, "Instance must not be null");
-// return getAllInterfacesForClass(instance.getClass());
-// }
-//
-// /**
-// * Return all interfaces that the given class implements as array,
-// * including ones implemented by superclasses.
-// * <p>If the class itself is an interface, it gets returned as sole interface.
-// * @param clazz the class to analyze for interfaces
-// * @return all interfaces that the given object implements as array
-// */
-// public static Class<?>[] getAllInterfacesForClass(Class<?> clazz) {
-// return getAllInterfacesForClass(clazz, null);
-// }
-//
-// /**
-// * Return all interfaces that the given class implements as array,
-// * including ones implemented by superclasses.
-// * <p>If the class itself is an interface, it gets returned as sole interface.
-// * @param clazz the class to analyze for interfaces
-// * @param classLoader the ClassLoader that the interfaces need to be visible in
-// * (may be {@code null} when accepting all declared interfaces)
-// * @return all interfaces that the given object implements as array
-// */
-// public static Class<?>[] getAllInterfacesForClass(Class<?> clazz, ClassLoader classLoader) {
-// Set<Class<?>> ifcs = getAllInterfacesForClassAsSet(clazz, classLoader);
-// return ifcs.toArray(new Class<?>[ifcs.size()]);
-// }
-//
-// /**
-// * Return all interfaces that the given instance implements as Set,
-// * including ones implemented by superclasses.
-// * @param instance the instance to analyze for interfaces
-// * @return all interfaces that the given instance implements as Set
-// */
-// public static Set<Class<?>> getAllInterfacesAsSet(Object instance) {
-// Objects.requireNonNull(instance, "Instance must not be null");
-// return getAllInterfacesForClassAsSet(instance.getClass());
-// }
-//
-// /**
-// * Return all interfaces that the given class implements as Set,
-// * including ones implemented by superclasses.
-// * <p>If the class itself is an interface, it gets returned as sole interface.
-// * @param clazz the class to analyze for interfaces
-// * @return all interfaces that the given object implements as Set
-// */
-// public static Set<Class<?>> getAllInterfacesForClassAsSet(Class<?> clazz) {
-// return getAllInterfacesForClassAsSet(clazz, null);
-// }
-//
-// /**
-// * Return all interfaces that the given class implements as Set,
-// * including ones implemented by superclasses.
-// * <p>If the class itself is an interface, it gets returned as sole interface.
-// * @param clazz the class to analyze for interfaces
-// * @param classLoader the ClassLoader that the interfaces need to be visible in
-// * (may be {@code null} when accepting all declared interfaces)
-// * @return all interfaces that the given object implements as Set
-// */
-// public static Set<Class<?>> getAllInterfacesForClassAsSet(Class<?> clazz, ClassLoader classLoader) {
-// Objects.requireNonNull(clazz, "Class must not be null");
-// if (clazz.isInterface() && isVisible(clazz, classLoader)) {
-// return Collections.<Class<?>>singleton(clazz);
-// }
-// Set<Class<?>> interfaces = new LinkedHashSet<Class<?>>();
-// while (clazz != null) {
-// Class<?>[] ifcs = clazz.getInterfaces();
-// for (Class<?> ifc : ifcs) {
-// interfaces.addAll(getAllInterfacesForClassAsSet(ifc, classLoader));
-// }
-// clazz = clazz.getSuperclass();
-// }
-// return interfaces;
-// }
-//
-// /**
-// * Create a composite interface Class for the given interfaces,
-// * implementing the given interfaces in one single Class.
-// * <p>This implementation builds a JDK proxy class for the given interfaces.
-// * @param interfaces the interfaces to merge
-// * @param classLoader the ClassLoader to of the composite Class in
-// * @return the merged interface as Class
-// * @see java.lang.reflect.Proxy#getProxyClass
-// */
-// public static Class<?> createCompositeInterface(Class<?>[] interfaces, ClassLoader classLoader) {
-// if(interfaces.length==0) throw new IllegalArgumentException("Interfaces must not be empty");
-// Objects.requireNonNull(classLoader, "ClassLoader must not be null");
-// return Proxy.getProxyClass(classLoader, interfaces);
-// }
-//
-// /**
-// * Determine the common ancestor current the given classes, if any.
-// * @param clazz1 the class to introspect
-// * @param clazz2 the other class to introspect
-// * @return the common ancestor (i.e. common superclass, one interface
-// * extending the other), or {@code null} if none found. If any current the
-// * given classes is {@code null}, the other class will be returned.
-// * @since 3.2.6
-// */
-// public static Class<?> determineCommonAncestor(Class<?> clazz1, Class<?> clazz2) {
-// if (clazz1 == null) {
-// return clazz2;
-// }
-// if (clazz2 == null) {
-// return clazz1;
-// }
-// if (clazz1.isAssignableFrom(clazz2)) {
-// return clazz1;
-// }
-// if (clazz2.isAssignableFrom(clazz1)) {
-// return clazz2;
-// }
-// Class<?> ancestor = clazz1;
-// do {
-// ancestor = ancestor.getSuperclass();
-// if (ancestor == null || Object.class.equals(ancestor)) {
-// return null;
-// }
-// }
-// while (!ancestor.isAssignableFrom(clazz2));
-// return ancestor;
-// }
-//
-// /**
-// * Check whether the given class is visible in the given ClassLoader.
-// * @param clazz the class to check (typically an interface)
-// * @param classLoader the ClassLoader to check against (may be {@code null},
-// * in which case this method will always return {@code true})
-// */
-// public static boolean isVisible(Class<?> clazz, ClassLoader classLoader) {
-// if (classLoader == null) {
-// return true;
-// }
-// try {
-// Class<?> actualClass = classLoader.loadClass(clazz.getName());
-// return (clazz == actualClass);
-// // Else: different interface class found...
-// }
-// catch (ClassNotFoundException ex) {
-// // No interface class found...
-// return false;
-// }
-// }
-//
-// /**
-// * Check whether the given object is a CGLIB proxy.
-// * @param object the object to check
-// */
-// public static boolean isCglibProxy(Object object) {
-// return ClassUtils.isCglibProxyClass(object.getClass());
-// }
-//
-// /**
-// * Check whether the specified class is a CGLIB-generated class.
-// * @param clazz the class to check
-// */
-// public static boolean isCglibProxyClass(Class<?> clazz) {
-// return (clazz != null && isCglibProxyClassName(clazz.getName()));
-// }
-//
-// /**
-// * Check whether the specified class name is a CGLIB-generated class.
-// * @param className the class name to check
-// */
-// public static boolean isCglibProxyClassName(String className) {
-// return (className != null && className.contains(CGLIB_CLASS_SEPARATOR));
-// }
-
-}