tamaya-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From strub...@apache.org
Subject [24/34] incubator-tamaya git commit: first step: move all sources to a 'dormant' directory
Date Sat, 27 Dec 2014 13:58:08 GMT
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/&#42;&#42;/test.jsp} - matches all
- * {@code test.jsp} files underneath the {@code com} path</li> <li>{@code org/springframework/&#42;&#42;/*.jsp}
- * - matches all {@code .jsp} files underneath the {@code org/springframework} path</li>
- * <li>{@code org/&#42;&#42;/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/&#42;&#42;</td><td>/bookings</td><td>/hotels/&#42;&#42;/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/&#42;&#42;</td><td>{hotel}</td><td>/hotels/&#42;&#42;/{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));
-//	}
-
-}


Mime
View raw message