mirror of
https://github.com/TermoraDev/termora.git
synced 2026-01-16 10:22:58 +08:00
chore!: migrate to version 2.x
This commit is contained in:
hstyi
994
src/main/java/app/termora/AntPathMatcher.java
Normal file
994
src/main/java/app/termora/AntPathMatcher.java
Normal file
@@ -0,0 +1,994 @@
|
||||
/*
|
||||
* Copyright 2002-2024 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
|
||||
*
|
||||
* https://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 app.termora;
|
||||
|
||||
import org.apache.commons.lang3.ArrayUtils;
|
||||
import org.jspecify.annotations.Nullable;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Collection;
|
||||
import java.util.Comparator;
|
||||
import java.util.LinkedHashMap;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import java.util.StringTokenizer;
|
||||
import java.util.concurrent.ConcurrentHashMap;
|
||||
import java.util.regex.Matcher;
|
||||
import java.util.regex.Pattern;
|
||||
|
||||
/**
|
||||
* <p>Part of this mapping code has been kindly borrowed from <a href="https://ant.apache.org">Apache Ant</a>.
|
||||
*
|
||||
* <p>The mapping matches URLs using the following rules:<br>
|
||||
* <ul>
|
||||
* <li>{@code ?} matches one character</li>
|
||||
* <li>{@code *} matches zero or more characters</li>
|
||||
* <li>{@code **} matches zero or more <em>directories</em> in a path</li>
|
||||
* <li>{@code {spring:[a-z]+}} matches the regexp {@code [a-z]+} as a path variable named "spring"</li>
|
||||
* </ul>
|
||||
*
|
||||
* <h3>Examples</h3>
|
||||
* <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</code> — matches all {@code test.jsp}
|
||||
* files underneath the {@code com} path</li>
|
||||
* <li><code>org/springframework/**/*.jsp</code> — matches all
|
||||
* {@code .jsp} files underneath the {@code org/springframework} path</li>
|
||||
* <li><code>org/**/servlet/bla.jsp</code> — matches
|
||||
* {@code org/springframework/servlet/bla.jsp} but also
|
||||
* {@code org/springframework/testing/servlet/bla.jsp} and {@code org/servlet/bla.jsp}</li>
|
||||
* <li>{@code com/{filename:\\w+}.jsp} will match {@code com/test.jsp} and assign the value {@code test}
|
||||
* to the {@code filename} variable</li>
|
||||
* </ul>
|
||||
*
|
||||
* <p><strong>Note:</strong> a pattern and a path must both be absolute or must
|
||||
* both be relative in order for the two to match. Therefore, it is recommended
|
||||
* that users of this implementation to sanitize patterns in order to prefix
|
||||
* them with "/" as it makes sense in the context in which they're used.
|
||||
*
|
||||
* @author Alef Arendsen
|
||||
* @author Juergen Hoeller
|
||||
* @author Rob Harrop
|
||||
* @author Arjen Poutsma
|
||||
* @author Rossen Stoyanchev
|
||||
* @author Sam Brannen
|
||||
* @author Vladislav Kisel
|
||||
* @since 16.07.2003
|
||||
*/
|
||||
public 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 static final char[] WILDCARD_CHARS = {'*', '?', '{'};
|
||||
|
||||
|
||||
private String pathSeparator;
|
||||
|
||||
private PathSeparatorPatternCache pathSeparatorPatternCache;
|
||||
|
||||
private boolean caseSensitive = true;
|
||||
|
||||
private boolean trimTokens = false;
|
||||
|
||||
private volatile @Nullable 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 convenient, 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) {
|
||||
this.pathSeparator = pathSeparator;
|
||||
this.pathSeparatorPatternCache = new PathSeparatorPatternCache(pathSeparator);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Set the path separator to use for pattern parsing.
|
||||
* <p>Default is "/", as in Ant.
|
||||
*/
|
||||
public void setPathSeparator(@Nullable String pathSeparator) {
|
||||
this.pathSeparator = (pathSeparator != null ? pathSeparator : DEFAULT_PATH_SEPARATOR);
|
||||
this.pathSeparatorPatternCache = new PathSeparatorPatternCache(this.pathSeparator);
|
||||
}
|
||||
|
||||
/**
|
||||
* Specify whether to perform pattern matching in a case-sensitive fashion.
|
||||
* <p>Default is {@code true}. Switch this to {@code false} for case-insensitive matching.
|
||||
*
|
||||
* @since 4.2
|
||||
*/
|
||||
public void setCaseSensitive(boolean caseSensitive) {
|
||||
this.caseSensitive = caseSensitive;
|
||||
}
|
||||
|
||||
/**
|
||||
* Specify whether to trim tokenized paths and patterns.
|
||||
* <p>Default is {@code false}.
|
||||
*/
|
||||
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 value of {@code true}
|
||||
* activates an unlimited pattern cache; a value of {@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 of patterns
|
||||
* are coming in, with little chance for encountering a recurring pattern.
|
||||
*
|
||||
* @see #getStringMatcher(String)
|
||||
* @since 4.0.1
|
||||
*/
|
||||
public void setCachePatterns(boolean cachePatterns) {
|
||||
this.cachePatterns = cachePatterns;
|
||||
}
|
||||
|
||||
private void deactivatePatternCache() {
|
||||
this.cachePatterns = false;
|
||||
this.tokenizedPatternCache.clear();
|
||||
this.stringMatcherCache.clear();
|
||||
}
|
||||
|
||||
|
||||
public boolean isPattern(@Nullable String path) {
|
||||
if (path == null) {
|
||||
return false;
|
||||
}
|
||||
boolean uriVar = false;
|
||||
for (int i = 0; i < path.length(); i++) {
|
||||
char c = path.charAt(i);
|
||||
if (c == '*' || c == '?') {
|
||||
return true;
|
||||
}
|
||||
if (c == '{') {
|
||||
uriVar = true;
|
||||
continue;
|
||||
}
|
||||
if (c == '}' && uriVar) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
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 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, @Nullable String path, boolean fullMatch,
|
||||
@Nullable Map<String, String> uriTemplateVariables) {
|
||||
|
||||
if (path == null || path.startsWith(this.pathSeparator) != pattern.startsWith(this.pathSeparator)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
String[] pattDirs = tokenizePattern(pattern);
|
||||
if (fullMatch && this.caseSensitive && !isPotentialMatch(path, pattDirs)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
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 of pattern is * or **'s
|
||||
if (pattIdxStart > pattIdxEnd) {
|
||||
return (pattern.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;
|
||||
}
|
||||
if (pattIdxEnd == (pattDirs.length - 1) &&
|
||||
pattern.endsWith(this.pathSeparator) != path.endsWith(this.pathSeparator)) {
|
||||
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;
|
||||
}
|
||||
|
||||
private boolean isPotentialMatch(String path, String[] pattDirs) {
|
||||
if (!this.trimTokens) {
|
||||
int pos = 0;
|
||||
for (String pattDir : pattDirs) {
|
||||
int skipped = skipSeparator(path, pos, this.pathSeparator);
|
||||
pos += skipped;
|
||||
skipped = skipSegment(path, pos, pattDir);
|
||||
if (skipped < pattDir.length()) {
|
||||
return (skipped > 0 || (pattDir.length() > 0 && isWildcardChar(pattDir.charAt(0))));
|
||||
}
|
||||
pos += skipped;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
private int skipSegment(String path, int pos, String prefix) {
|
||||
int skipped = 0;
|
||||
for (int i = 0; i < prefix.length(); i++) {
|
||||
char c = prefix.charAt(i);
|
||||
if (isWildcardChar(c)) {
|
||||
return skipped;
|
||||
}
|
||||
int currPos = pos + skipped;
|
||||
if (currPos >= path.length()) {
|
||||
return 0;
|
||||
}
|
||||
if (c == path.charAt(currPos)) {
|
||||
skipped++;
|
||||
}
|
||||
}
|
||||
return skipped;
|
||||
}
|
||||
|
||||
private int skipSeparator(String path, int pos, String separator) {
|
||||
int skipped = 0;
|
||||
while (path.startsWith(separator, pos + skipped)) {
|
||||
skipped += separator.length();
|
||||
}
|
||||
return skipped;
|
||||
}
|
||||
|
||||
private boolean isWildcardChar(char c) {
|
||||
for (char candidate : WILDCARD_CHARS) {
|
||||
if (c == candidate) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* 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 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 tokenizeToStringArray(path, this.pathSeparator, this.trimTokens, true);
|
||||
}
|
||||
|
||||
/**
|
||||
* Test whether 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,
|
||||
@Nullable 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.
|
||||
* <p>When encountering too many patterns to cache at runtime (the threshold is 65536),
|
||||
* it turns the default cache off, assuming that arbitrary permutations of patterns
|
||||
* are coming in, with little chance for encountering a recurring pattern.
|
||||
* <p>This method may be 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, this.pathSeparator, this.caseSensitive);
|
||||
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 = tokenizeToStringArray(pattern, this.pathSeparator, this.trimTokens, true);
|
||||
String[] pathParts = 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 IllegalStateException("Pattern \"" + pattern + "\" is not a match for \"" + path + "\"");
|
||||
}
|
||||
return variables;
|
||||
}
|
||||
|
||||
/**
|
||||
* Combine two patterns into a new pattern.
|
||||
* <p>This implementation simply concatenates the two patterns, unless
|
||||
* the first pattern contains a file extension match (for example, {@code *.html}).
|
||||
* In that case, the second pattern will be merged into the first. Otherwise,
|
||||
* an {@code IllegalArgumentException} will be thrown.
|
||||
* <h4>Examples</h4>
|
||||
* <table border="1">
|
||||
* <tr><th>Pattern 1</th><th>Pattern 2</th><th>Result</th></tr>
|
||||
* <tr><td>{@code null}</td><td>{@code null}</td><td> </td></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>{@code IllegalArgumentException}</td></tr>
|
||||
* </table>
|
||||
*
|
||||
* @param pattern1 the first pattern
|
||||
* @param pattern2 the second pattern
|
||||
* @return the combination of the two patterns
|
||||
* @throws IllegalArgumentException if the two patterns cannot be combined
|
||||
*/
|
||||
|
||||
public String combine(String pattern1, String pattern2) {
|
||||
if (!hasText(pattern1) && !hasText(pattern2)) {
|
||||
return "";
|
||||
}
|
||||
if (!hasText(pattern1)) {
|
||||
return pattern2;
|
||||
}
|
||||
if (!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 ext1 = pattern1.substring(starDotPos1 + 1);
|
||||
int dotPos2 = pattern2.indexOf('.');
|
||||
String file2 = (dotPos2 == -1 ? pattern2 : pattern2.substring(0, dotPos2));
|
||||
String ext2 = (dotPos2 == -1 ? "" : pattern2.substring(dotPos2));
|
||||
boolean ext1All = (ext1.equals(".*") || ext1.isEmpty());
|
||||
boolean ext2All = (ext2.equals(".*") || ext2.isEmpty());
|
||||
if (!ext1All && !ext2All) {
|
||||
throw new IllegalArgumentException("Cannot combine patterns: " + pattern1 + " vs " + pattern2);
|
||||
}
|
||||
String ext = (ext1All ? ext2 : ext1);
|
||||
return file2 + ext;
|
||||
}
|
||||
|
||||
public static boolean hasText(@Nullable String str) {
|
||||
return (str != null && !str.isBlank());
|
||||
}
|
||||
|
||||
public static String[] tokenizeToStringArray(
|
||||
@Nullable String str, String delimiters, boolean trimTokens, boolean ignoreEmptyTokens) {
|
||||
|
||||
if (str == null) {
|
||||
return ArrayUtils.EMPTY_STRING_ARRAY;
|
||||
}
|
||||
|
||||
StringTokenizer st = new StringTokenizer(str, delimiters);
|
||||
List<String> tokens = new ArrayList<>();
|
||||
while (st.hasMoreTokens()) {
|
||||
String token = st.nextToken();
|
||||
if (trimTokens) {
|
||||
token = token.trim();
|
||||
}
|
||||
if (!ignoreEmptyTokens || !token.isEmpty()) {
|
||||
tokens.add(token);
|
||||
}
|
||||
}
|
||||
return toStringArray(tokens);
|
||||
}
|
||||
|
||||
public static String[] toStringArray(@Nullable Collection<String> collection) {
|
||||
return (!(collection == null || collection.isEmpty()) ? collection.toArray(ArrayUtils.EMPTY_STRING_ARRAY) : ArrayUtils.EMPTY_STRING_ARRAY);
|
||||
}
|
||||
|
||||
private String concat(String path1, String path2) {
|
||||
boolean path1EndsWithSeparator = path1.endsWith(this.pathSeparator);
|
||||
boolean path2StartsWithSeparator = path2.startsWith(this.pathSeparator);
|
||||
|
||||
if (path1EndsWithSeparator && path2StartsWithSeparator) {
|
||||
return path1 + path2.substring(1);
|
||||
} else if (path1EndsWithSeparator || path2StartsWithSeparator) {
|
||||
return path1 + path2;
|
||||
} else {
|
||||
return path1 + this.pathSeparator + path2;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Given a full path, returns a {@link Comparator} suitable for sorting patterns in order of
|
||||
* explicitness.
|
||||
* <p>This {@code Comparator} will {@linkplain java.util.List#sort(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, the returned comparator
|
||||
* will sort this list so that the order will be as indicated.
|
||||
* <ol>
|
||||
* <li>{@code /hotels/new}</li>
|
||||
* <li>{@code /hotels/{hotel}}</li>
|
||||
* <li>{@code /hotels/*}</li>
|
||||
* </ol>
|
||||
* <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 of sorting patterns in order of explicitness
|
||||
*/
|
||||
|
||||
public Comparator<String> getPatternComparator(String path) {
|
||||
return new AntPatternComparator(path, this.pathSeparator);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Tests whether 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 {@code /users/{user}}.
|
||||
*/
|
||||
protected static class AntPathStringMatcher {
|
||||
|
||||
private static final String DEFAULT_VARIABLE_PATTERN = "((?s).*)";
|
||||
|
||||
private final String rawPattern;
|
||||
|
||||
private final boolean caseSensitive;
|
||||
|
||||
private final boolean exactMatch;
|
||||
|
||||
private final @Nullable Pattern pattern;
|
||||
|
||||
private final List<String> variableNames = new ArrayList<>();
|
||||
|
||||
protected AntPathStringMatcher(String pattern, String pathSeparator, boolean caseSensitive) {
|
||||
this.rawPattern = pattern;
|
||||
this.caseSensitive = caseSensitive;
|
||||
StringBuilder patternBuilder = new StringBuilder();
|
||||
Matcher matcher = getGlobPattern(pathSeparator).matcher(pattern);
|
||||
int end = 0;
|
||||
while (matcher.find()) {
|
||||
patternBuilder.append(quote(pattern, end, matcher.start()));
|
||||
String match = matcher.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(matcher.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 = matcher.end();
|
||||
}
|
||||
// No glob pattern was found, this is an exact String match
|
||||
if (end == 0) {
|
||||
this.exactMatch = true;
|
||||
this.pattern = null;
|
||||
} else {
|
||||
this.exactMatch = false;
|
||||
patternBuilder.append(quote(pattern, end, pattern.length()));
|
||||
this.pattern = Pattern.compile(patternBuilder.toString(),
|
||||
Pattern.DOTALL | (this.caseSensitive ? 0 : Pattern.CASE_INSENSITIVE));
|
||||
}
|
||||
}
|
||||
|
||||
private static Pattern getGlobPattern(String pathSeparator) {
|
||||
String pattern = "\\?|\\*|\\{((?:\\{[^" + pathSeparator + "]+?\\}|[^" + pathSeparator + "{}]|\\\\[{}])+?)\\}";
|
||||
return Pattern.compile(pattern);
|
||||
}
|
||||
|
||||
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, @Nullable Map<String, String> uriTemplateVariables) {
|
||||
if (this.exactMatch) {
|
||||
return this.caseSensitive ? this.rawPattern.equals(str) : this.rawPattern.equalsIgnoreCase(str);
|
||||
} else if (this.pattern != null) {
|
||||
Matcher matcher = this.pattern.matcher(str);
|
||||
if (matcher.matches()) {
|
||||
if (uriTemplateVariables != null) {
|
||||
if (this.variableNames.size() != matcher.groupCount()) {
|
||||
throw new IllegalArgumentException("The number of capturing groups in the pattern segment " +
|
||||
this.pattern + " does not match the number of 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);
|
||||
if (name.startsWith("*")) {
|
||||
throw new IllegalArgumentException("Capturing patterns (" + name + ") are not " +
|
||||
"supported by the AntPathMatcher. Use the PathPatternParser instead.");
|
||||
}
|
||||
String value = matcher.group(i);
|
||||
uriTemplateVariables.put(name, value);
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
}
|
||||
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;
|
||||
|
||||
private final String pathSeparator;
|
||||
|
||||
public AntPatternComparator(String path) {
|
||||
this(path, DEFAULT_PATH_SEPARATOR);
|
||||
}
|
||||
|
||||
public AntPatternComparator(String path, String pathSeparator) {
|
||||
this.path = path;
|
||||
this.pathSeparator = pathSeparator;
|
||||
}
|
||||
|
||||
/**
|
||||
* 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.
|
||||
*/
|
||||
|
||||
public int compare(String pattern1, String pattern2) {
|
||||
PatternInfo info1 = new PatternInfo(pattern1, this.pathSeparator);
|
||||
PatternInfo info2 = new PatternInfo(pattern2, this.pathSeparator);
|
||||
|
||||
if (info1.isLeastSpecific() && info2.isLeastSpecific()) {
|
||||
return 0;
|
||||
} else if (info1.isLeastSpecific()) {
|
||||
return 1;
|
||||
} else if (info2.isLeastSpecific()) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
boolean pattern1EqualsPath = pattern1.equals(this.path);
|
||||
boolean pattern2EqualsPath = pattern2.equals(this.path);
|
||||
if (pattern1EqualsPath && pattern2EqualsPath) {
|
||||
return 0;
|
||||
} else if (pattern1EqualsPath) {
|
||||
return -1;
|
||||
} else if (pattern2EqualsPath) {
|
||||
return 1;
|
||||
}
|
||||
|
||||
if (info1.isPrefixPattern() && info2.isPrefixPattern()) {
|
||||
return info2.getLength() - info1.getLength();
|
||||
} else 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, for example, number of
|
||||
* occurrences of "*", "**", and "{" pattern elements.
|
||||
*/
|
||||
private static class PatternInfo {
|
||||
|
||||
|
||||
private final @Nullable String pattern;
|
||||
|
||||
private int uriVars;
|
||||
|
||||
private int singleWildcards;
|
||||
|
||||
private int doubleWildcards;
|
||||
|
||||
private boolean catchAllPattern;
|
||||
|
||||
private boolean prefixPattern;
|
||||
|
||||
private @Nullable Integer length;
|
||||
|
||||
PatternInfo(@Nullable String pattern, String pathSeparator) {
|
||||
this.pattern = pattern;
|
||||
if (this.pattern != null) {
|
||||
initCounters();
|
||||
this.catchAllPattern = this.pattern.equals(pathSeparator + "**");
|
||||
this.prefixPattern = !this.catchAllPattern && this.pattern.endsWith(pathSeparator + "**");
|
||||
}
|
||||
if (this.uriVars == 0) {
|
||||
this.length = (this.pattern != null ? this.pattern.length() : 0);
|
||||
}
|
||||
}
|
||||
|
||||
protected void initCounters() {
|
||||
int pos = 0;
|
||||
if (this.pattern != null) {
|
||||
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 (pos > 0 && !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 of the given pattern, where template variables are considered to be 1 long.
|
||||
*/
|
||||
public int getLength() {
|
||||
if (this.length == null) {
|
||||
this.length = (this.pattern != null ?
|
||||
VARIABLE_PATTERN.matcher(this.pattern).replaceAll("#").length() : 0);
|
||||
}
|
||||
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;
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,70 +0,0 @@
|
||||
package app.termora;
|
||||
|
||||
import org.apache.sshd.common.keyprovider.KeyIdentityProvider;
|
||||
import org.apache.sshd.common.session.SessionContext;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.security.GeneralSecurityException;
|
||||
import java.security.KeyPair;
|
||||
import java.util.*;
|
||||
|
||||
@Deprecated
|
||||
public class CombinedKeyIdentityProvider implements KeyIdentityProvider {
|
||||
|
||||
private final List<KeyIdentityProvider> providers = new ArrayList<>();
|
||||
|
||||
@Override
|
||||
public Iterable<KeyPair> loadKeys(SessionContext context) {
|
||||
return () -> new Iterator<>() {
|
||||
|
||||
private final Iterator<KeyIdentityProvider> factories = providers
|
||||
.iterator();
|
||||
private Iterator<KeyPair> current;
|
||||
|
||||
private Boolean hasElement;
|
||||
|
||||
@Override
|
||||
public boolean hasNext() {
|
||||
if (hasElement != null) {
|
||||
return hasElement;
|
||||
}
|
||||
while (current == null || !current.hasNext()) {
|
||||
if (factories.hasNext()) {
|
||||
try {
|
||||
current = factories.next().loadKeys(context)
|
||||
.iterator();
|
||||
} catch (IOException | GeneralSecurityException e) {
|
||||
throw new RuntimeException(e);
|
||||
}
|
||||
} else {
|
||||
current = null;
|
||||
hasElement = Boolean.FALSE;
|
||||
return false;
|
||||
}
|
||||
}
|
||||
hasElement = Boolean.TRUE;
|
||||
return true;
|
||||
}
|
||||
|
||||
@Override
|
||||
public KeyPair next() {
|
||||
if ((hasElement == null && !hasNext()) || !hasElement) {
|
||||
throw new NoSuchElementException();
|
||||
}
|
||||
hasElement = null;
|
||||
KeyPair result;
|
||||
try {
|
||||
result = current.next();
|
||||
} catch (NoSuchElementException e) {
|
||||
result = null;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
};
|
||||
}
|
||||
|
||||
public void addKeyKeyIdentityProvider(KeyIdentityProvider provider) {
|
||||
providers.add(Objects.requireNonNull(provider));
|
||||
}
|
||||
}
|
||||
@@ -1,140 +0,0 @@
|
||||
package app.termora;
|
||||
|
||||
import com.formdev.flatlaf.ui.FlatTabbedPaneUI;
|
||||
import com.formdev.flatlaf.ui.FlatUIUtils;
|
||||
|
||||
import javax.swing.*;
|
||||
import java.awt.*;
|
||||
import java.awt.geom.Path2D;
|
||||
import java.awt.geom.Rectangle2D;
|
||||
|
||||
import static com.formdev.flatlaf.FlatClientProperties.*;
|
||||
import static com.formdev.flatlaf.util.UIScale.scale;
|
||||
|
||||
/**
|
||||
* 如果要升级 FlatLaf 需要检查是否兼容
|
||||
*/
|
||||
@Deprecated
|
||||
public class MyFlatTabbedPaneUI extends FlatTabbedPaneUI {
|
||||
@Override
|
||||
protected void paintContentBorder(Graphics g, int tabPlacement, int selectedIndex) {
|
||||
if (tabPane.getTabCount() <= 0 ||
|
||||
contentSeparatorHeight == 0 ||
|
||||
!clientPropertyBoolean(tabPane, TABBED_PANE_SHOW_CONTENT_SEPARATOR, showContentSeparator))
|
||||
return;
|
||||
|
||||
Insets insets = tabPane.getInsets();
|
||||
Insets tabAreaInsets = getTabAreaInsets(tabPlacement);
|
||||
|
||||
int x = insets.left;
|
||||
int y = insets.top;
|
||||
int w = tabPane.getWidth() - insets.right - insets.left;
|
||||
int h = tabPane.getHeight() - insets.top - insets.bottom;
|
||||
|
||||
// remove tabs from bounds
|
||||
switch (tabPlacement) {
|
||||
case BOTTOM:
|
||||
h -= calculateTabAreaHeight(tabPlacement, runCount, maxTabHeight);
|
||||
h += tabAreaInsets.top;
|
||||
break;
|
||||
|
||||
case LEFT:
|
||||
x += calculateTabAreaWidth(tabPlacement, runCount, maxTabWidth);
|
||||
x -= tabAreaInsets.right;
|
||||
w -= (x - insets.left);
|
||||
break;
|
||||
|
||||
case RIGHT:
|
||||
w -= calculateTabAreaWidth(tabPlacement, runCount, maxTabWidth);
|
||||
w += tabAreaInsets.left;
|
||||
break;
|
||||
|
||||
case TOP:
|
||||
default:
|
||||
y += calculateTabAreaHeight(tabPlacement, runCount, maxTabHeight);
|
||||
y -= tabAreaInsets.bottom;
|
||||
h -= (y - insets.top);
|
||||
break;
|
||||
}
|
||||
|
||||
// compute insets for separator or full border
|
||||
boolean hasFullBorder = clientPropertyBoolean(tabPane, TABBED_PANE_HAS_FULL_BORDER, this.hasFullBorder);
|
||||
int sh = scale(contentSeparatorHeight * 100); // multiply by 100 because rotateInsets() does not use floats
|
||||
Insets ci = new Insets(0, 0, 0, 0);
|
||||
rotateInsets(hasFullBorder ? new Insets(sh, sh, sh, sh) : new Insets(sh, 0, 0, 0), ci, tabPlacement);
|
||||
|
||||
// create path for content separator or full border
|
||||
Path2D path = new Path2D.Float(Path2D.WIND_EVEN_ODD);
|
||||
path.append(new Rectangle2D.Float(x, y, w, h), false);
|
||||
path.append(new Rectangle2D.Float(x + (ci.left / 100f), y + (ci.top / 100f),
|
||||
w - (ci.left / 100f) - (ci.right / 100f), h - (ci.top / 100f) - (ci.bottom / 100f)), false);
|
||||
|
||||
// add gap for selected tab to path
|
||||
if (getTabType() == TAB_TYPE_CARD && selectedIndex >= 0) {
|
||||
float csh = scale((float) contentSeparatorHeight);
|
||||
|
||||
Rectangle tabRect = getTabBounds(tabPane, selectedIndex);
|
||||
boolean componentHasFullBorder = false;
|
||||
if (tabPane.getComponentAt(selectedIndex) instanceof JComponent c) {
|
||||
componentHasFullBorder = c.getClientProperty(TABBED_PANE_HAS_FULL_BORDER) == Boolean.TRUE;
|
||||
}
|
||||
Rectangle2D.Float innerTabRect = new Rectangle2D.Float(tabRect.x + csh, tabRect.y + csh,
|
||||
componentHasFullBorder ? 0 : tabRect.width - (csh * 2), tabRect.height - (csh * 2));
|
||||
|
||||
// Ensure that the separator outside the tabViewport is present (doesn't get cutoff by the active tab)
|
||||
// If left unsolved the active tab is "visible" in the separator (the gap) even when outside the viewport
|
||||
if (tabViewport != null)
|
||||
Rectangle2D.intersect(tabViewport.getBounds(), innerTabRect, innerTabRect);
|
||||
|
||||
Rectangle2D.Float gap = null;
|
||||
if (isHorizontalTabPlacement(tabPlacement)) {
|
||||
if (innerTabRect.width > 0) {
|
||||
float y2 = (tabPlacement == TOP) ? y : y + h - csh;
|
||||
gap = new Rectangle2D.Float(innerTabRect.x, y2, innerTabRect.width, csh);
|
||||
}
|
||||
} else {
|
||||
if (innerTabRect.height > 0) {
|
||||
float x2 = (tabPlacement == LEFT) ? x : x + w - csh;
|
||||
gap = new Rectangle2D.Float(x2, innerTabRect.y, csh, innerTabRect.height);
|
||||
}
|
||||
}
|
||||
|
||||
if (gap != null) {
|
||||
path.append(gap, false);
|
||||
|
||||
// fill gap in case that the tab is colored (e.g. focused or hover)
|
||||
Color background = getTabBackground(tabPlacement, selectedIndex, true);
|
||||
g.setColor(FlatUIUtils.deriveColor(background, tabPane.getBackground()));
|
||||
((Graphics2D) g).fill(gap);
|
||||
}
|
||||
}
|
||||
|
||||
// paint content separator or full border
|
||||
g.setColor(contentAreaColor);
|
||||
((Graphics2D) g).fill(path);
|
||||
|
||||
// repaint selection in scroll-tab-layout because it may be painted before
|
||||
// the content border was painted (from BasicTabbedPaneUI$ScrollableTabPanel)
|
||||
if (isScrollTabLayout() && selectedIndex >= 0 && tabViewport != null) {
|
||||
Rectangle tabRect = getTabBounds(tabPane, selectedIndex);
|
||||
|
||||
// clip to "scrolling sides" of viewport
|
||||
// (left and right if horizontal, top and bottom if vertical)
|
||||
Shape oldClip = g.getClip();
|
||||
Rectangle vr = tabViewport.getBounds();
|
||||
if (isHorizontalTabPlacement(tabPlacement))
|
||||
g.clipRect(vr.x, 0, vr.width, tabPane.getHeight());
|
||||
else
|
||||
g.clipRect(0, vr.y, tabPane.getWidth(), vr.height);
|
||||
|
||||
paintTabSelection(g, tabPlacement, selectedIndex, tabRect.x, tabRect.y, tabRect.width, tabRect.height);
|
||||
g.setClip(oldClip);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
private boolean isScrollTabLayout() {
|
||||
return tabPane.getTabLayoutPolicy() == JTabbedPane.SCROLL_TAB_LAYOUT;
|
||||
}
|
||||
|
||||
}
|
||||
463
src/main/java/app/termora/VerticalFlowLayout.java
Normal file
463
src/main/java/app/termora/VerticalFlowLayout.java
Normal file
@@ -0,0 +1,463 @@
|
||||
package app.termora;
|
||||
|
||||
import javax.swing.JComponent;
|
||||
import java.awt.Component;
|
||||
import java.awt.Container;
|
||||
import java.awt.Dimension;
|
||||
import java.awt.Insets;
|
||||
import java.awt.LayoutManager;
|
||||
|
||||
/**
|
||||
* A vertical flow layout arranges components in a top-to-bottom flow, much
|
||||
* like lines of text in a paragraph. Flow layouts are typically used
|
||||
* to arrange buttons in a panel. It will arrange
|
||||
* buttons top to bottom until no more buttons fit on the same line.
|
||||
* Each line is centered.
|
||||
*/
|
||||
public class VerticalFlowLayout implements LayoutManager, java.io.Serializable {
|
||||
|
||||
/**
|
||||
* This value indicates that each row of components
|
||||
* should be left-justified.
|
||||
*/
|
||||
public static final int TOP = 0;
|
||||
|
||||
/**
|
||||
* This value indicates that each row of components
|
||||
* should be centered.
|
||||
*/
|
||||
public static final int CENTER = 1;
|
||||
|
||||
/**
|
||||
* This value indicates that each row of components
|
||||
* should be right-justified.
|
||||
*/
|
||||
public static final int BOTTOM = 2;
|
||||
|
||||
/**
|
||||
* <code>align</code> is the property that determines
|
||||
* how each row distributes empty space.
|
||||
* It can be one of the following values:
|
||||
* <ul>
|
||||
* <code>TOP</code>
|
||||
* <code>BOTTOM</code>
|
||||
* <code>CENTER</code>
|
||||
* <code>LEADING</code>
|
||||
* <code>TRAILING</code>
|
||||
* </ul>
|
||||
*
|
||||
* @serial
|
||||
* @see #getAlignment
|
||||
* @see #setAlignment
|
||||
*/
|
||||
int alisgn; // This is for 1.1 serialization compatibility
|
||||
|
||||
/**
|
||||
* <code>newAlign</code> is the property that determines
|
||||
* how each row distributes empty space for the Java 2 platform,
|
||||
* v1.2 and greater.
|
||||
* It can be one of the following three values:
|
||||
* <ul>
|
||||
* <code>TOP</code>
|
||||
* <code>BOTTOM</code>
|
||||
* <code>CENTER</code>
|
||||
* <code>LEADING</code>
|
||||
* <code>TRAILING</code>
|
||||
* </ul>
|
||||
*
|
||||
* @serial
|
||||
* @see #getAlignment
|
||||
* @see #setAlignment
|
||||
* @since 1.2
|
||||
*/
|
||||
int newAlign; // This is the one we actually use
|
||||
|
||||
/**
|
||||
* The flow layout manager allows a seperation of
|
||||
* components with gaps. The horizontal gap will
|
||||
* specify the space between components.
|
||||
*
|
||||
* @serial
|
||||
* @see #getHgap()
|
||||
* @see #setHgap(int)
|
||||
*/
|
||||
protected int hgap;
|
||||
|
||||
/**
|
||||
* The flow layout manager allows a seperation of
|
||||
* components with gaps. The vertical gap will
|
||||
* specify the space between rows.
|
||||
*
|
||||
* @serial
|
||||
* @see #getHgap()
|
||||
* @see #setHgap(int)
|
||||
*/
|
||||
protected int vgap;
|
||||
|
||||
/**
|
||||
* Constructs a new <code>FlowLayout</code> with a centered alignment and a
|
||||
* default 5-unit horizontal and vertical gap.
|
||||
*/
|
||||
public VerticalFlowLayout() {
|
||||
this(CENTER, 5, 5);
|
||||
}
|
||||
|
||||
/**
|
||||
* Constructs a new <code>FlowLayout</code> with the specified
|
||||
* alignment and a default 5-unit horizontal and vertical gap.
|
||||
* The value of the alignment argument must be one of
|
||||
* <code>FlowLayout.TOP</code>, <code>FlowLayout.BOTTOM</code>,
|
||||
* or <code>FlowLayout.CENTER</code>.
|
||||
*
|
||||
* @param align the alignment value
|
||||
*/
|
||||
public VerticalFlowLayout(int align) {
|
||||
this(align, 5, 5);
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a new flow layout manager with the indicated alignment
|
||||
* and the indicated horizontal and vertical gaps.
|
||||
* <p/>
|
||||
* The value of the alignment argument must be one of
|
||||
* <code>FlowLayout.TOP</code>, <code>FlowLayout.BOTTOM</code>,
|
||||
* or <code>FlowLayout.CENTER</code>.
|
||||
*
|
||||
* @param align the alignment value
|
||||
* @param hgap the horizontal gap between components
|
||||
* @param vgap the vertical gap between components
|
||||
*/
|
||||
public VerticalFlowLayout(int align, int hgap, int vgap) {
|
||||
this.hgap = hgap;
|
||||
this.vgap = vgap;
|
||||
|
||||
setAlignment(align);
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the alignment for this layout.
|
||||
* Possible values are <code>FlowLayout.TOP</code>,
|
||||
* <code>FlowLayout.BOTTOM</code>, <code>FlowLayout.CENTER</code>,
|
||||
* <code>FlowLayout.LEADING</code>,
|
||||
* or <code>FlowLayout.TRAILING</code>.
|
||||
*
|
||||
* @return the alignment value for this layout
|
||||
* @see java.awt.FlowLayout#setAlignment
|
||||
* @since JDK1.1
|
||||
*/
|
||||
public int getAlignment() {
|
||||
return newAlign;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the alignment for this layout.
|
||||
* Possible values are
|
||||
* <ul>
|
||||
* <li><code>FlowLayout.TOP</code>
|
||||
* <li><code>FlowLayout.BOTTOM</code>
|
||||
* <li><code>FlowLayout.CENTER</code>
|
||||
* <li><code>FlowLayout.LEADING</code>
|
||||
* <li><code>FlowLayout.TRAILING</code>
|
||||
* </ul>
|
||||
*
|
||||
* @param align one of the alignment values shown above
|
||||
* @see #getAlignment()
|
||||
* @since JDK1.1
|
||||
*/
|
||||
public void setAlignment(int align) {
|
||||
this.newAlign = align;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the horizontal gap between components.
|
||||
*
|
||||
* @return the horizontal gap between components
|
||||
* @see java.awt.FlowLayout#setHgap
|
||||
* @since JDK1.1
|
||||
*/
|
||||
public int getHgap() {
|
||||
return hgap;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the horizontal gap between components.
|
||||
*
|
||||
* @param hgap the horizontal gap between components
|
||||
* @see java.awt.FlowLayout#getHgap
|
||||
* @since JDK1.1
|
||||
*/
|
||||
public void setHgap(int hgap) {
|
||||
this.hgap = hgap;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the vertical gap between components.
|
||||
*
|
||||
* @return the vertical gap between components
|
||||
* @see java.awt.FlowLayout#setVgap
|
||||
* @since JDK1.1
|
||||
*/
|
||||
public int getVgap() {
|
||||
return vgap;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the vertical gap between components.
|
||||
*
|
||||
* @param vgap the vertical gap between components
|
||||
* @see java.awt.FlowLayout#getVgap
|
||||
* @since JDK1.1
|
||||
*/
|
||||
public void setVgap(int vgap) {
|
||||
this.vgap = vgap;
|
||||
}
|
||||
|
||||
/**
|
||||
* Adds the specified component to the layout. Not used by this class.
|
||||
*
|
||||
* @param name the name of the component
|
||||
* @param comp the component to be added
|
||||
*/
|
||||
public void addLayoutComponent(String name, Component comp) {
|
||||
}
|
||||
|
||||
/**
|
||||
* Removes the specified component from the layout. Not used by
|
||||
* this class.
|
||||
*
|
||||
* @param comp the component to remove
|
||||
* @see java.awt.Container#removeAll
|
||||
*/
|
||||
public void removeLayoutComponent(Component comp) {
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the preferred dimensions for this layout given the
|
||||
* <i>visible</i> components in the specified target container.
|
||||
*
|
||||
* @param target the component which needs to be laid out
|
||||
* @return the preferred dimensions to lay out the
|
||||
* subcomponents of the specified container
|
||||
* @see java.awt.Container
|
||||
* @see #minimumLayoutSize
|
||||
* @see java.awt.Container#getPreferredSize
|
||||
*/
|
||||
public Dimension preferredLayoutSize(Container target) {
|
||||
synchronized (target.getTreeLock()) {
|
||||
Dimension dim = new Dimension(0, 0);
|
||||
int nmembers = target.getComponentCount();
|
||||
Boolean firstVisibleComponent = true;
|
||||
|
||||
for (int i = 0; i < nmembers; i++) {
|
||||
Component m = target.getComponent(i);
|
||||
if (m.isVisible()) {
|
||||
Dimension d = m.getPreferredSize();
|
||||
|
||||
firstVisibleComponent = dialWithDim4PreferredLayoutSize(dim, d, firstVisibleComponent);
|
||||
}
|
||||
}
|
||||
Insets insets = target.getInsets();
|
||||
dim.width += insets.left + insets.right + hgap * 2;
|
||||
dim.height += insets.top + insets.bottom + vgap * 2;
|
||||
return dim;
|
||||
}
|
||||
}
|
||||
|
||||
protected boolean dialWithDim4PreferredLayoutSize(Dimension dim, Dimension d, boolean firstVisibleComponent) {
|
||||
dim.width = Math.max(dim.width, d.width);
|
||||
if (firstVisibleComponent) {
|
||||
firstVisibleComponent = false;
|
||||
} else {
|
||||
dim.height += vgap;
|
||||
}
|
||||
|
||||
dim.height += d.height;
|
||||
|
||||
return firstVisibleComponent;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the minimum dimensions needed to layout the <i>visible</i>
|
||||
* components contained in the specified target container.
|
||||
*
|
||||
* @param target the component which needs to be laid out
|
||||
* @return the minimum dimensions to lay out the
|
||||
* subcomponents of the specified container
|
||||
* @see #preferredLayoutSize
|
||||
* @see java.awt.Container
|
||||
* @see java.awt.Container#doLayout
|
||||
*/
|
||||
public Dimension minimumLayoutSize(Container target) {
|
||||
synchronized (target.getTreeLock()) {
|
||||
Dimension dim = new Dimension(0, 0);
|
||||
int nmembers = target.getComponentCount();
|
||||
boolean firstVisibleComponent = true;
|
||||
|
||||
for (int i = 0; i < nmembers; i++) {
|
||||
Component m = target.getComponent(i);
|
||||
if (m.isVisible()) {
|
||||
Dimension d = m.getMinimumSize();
|
||||
|
||||
firstVisibleComponent = dialWithDim4MinimumLayoutSize(dim, d, i, firstVisibleComponent);
|
||||
}
|
||||
}
|
||||
Insets insets = target.getInsets();
|
||||
dim.width += insets.left + insets.right + hgap * 2;
|
||||
dim.height += insets.top + insets.bottom + vgap * 2;
|
||||
return dim;
|
||||
}
|
||||
}
|
||||
|
||||
protected boolean dialWithDim4MinimumLayoutSize(Dimension dim, Dimension d, int i, boolean firstVisibleComponent) {
|
||||
dim.width = Math.max(dim.width, d.width);
|
||||
if (i > 0) {
|
||||
dim.height += vgap;
|
||||
}
|
||||
dim.height += d.height;
|
||||
|
||||
return firstVisibleComponent;
|
||||
}
|
||||
|
||||
/**
|
||||
* Centers the elements in the specified row, if there is any slack.
|
||||
*
|
||||
* @param target the component which needs to be moved
|
||||
* @param x the x coordinate
|
||||
* @param y the y coordinate
|
||||
* @param width the width dimensions
|
||||
* @param height the height dimensions
|
||||
* @param rowStart the beginning of the row
|
||||
* @param rowEnd the the ending of the row
|
||||
*/
|
||||
private void moveComponents(Container target, int x, int y, int width, int height,
|
||||
int rowStart, int rowEnd, boolean ltr) {
|
||||
synchronized (target.getTreeLock()) {
|
||||
switch (newAlign) {
|
||||
case TOP:
|
||||
y += ltr ? 0 : height;
|
||||
break;
|
||||
case CENTER:
|
||||
y += height / 2;
|
||||
break;
|
||||
case BOTTOM:
|
||||
y += ltr ? height : 0;
|
||||
break;
|
||||
}
|
||||
for (int i = rowStart; i < rowEnd; i++) {
|
||||
Component m = target.getComponent(i);
|
||||
if (m.isVisible()) {
|
||||
if (ltr) {
|
||||
m.setLocation(x + (width - m.getWidth()) / 2, y);
|
||||
} else {
|
||||
m.setLocation(x + (width - m.getWidth()) / 2, target.getHeight() - y - m.getHeight());
|
||||
}
|
||||
y += m.getHeight() + vgap;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Lays out the container. This method lets each component take
|
||||
* its preferred size by reshaping the components in the
|
||||
* target container in order to satisfy the alignment of
|
||||
* this <code>FlowLayout</code> object.
|
||||
*
|
||||
* @param target the specified component being laid out
|
||||
* @see java.awt.Container
|
||||
* @see java.awt.Container#doLayout
|
||||
*/
|
||||
public void layoutContainer(Container target) {
|
||||
synchronized (target.getTreeLock()) {
|
||||
Insets insets = target.getInsets();
|
||||
|
||||
int maxlen = getMaxLen4LayoutContainer(target, insets);
|
||||
int nmembers = target.getComponentCount();
|
||||
int x = getX4LayoutContainer(insets), y = getY4LayoutContainer(insets);
|
||||
int roww = 0, start = 0;
|
||||
|
||||
boolean ltr = target.getComponentOrientation().isLeftToRight();
|
||||
|
||||
int[] rs;
|
||||
for (int i = 0; i < nmembers; i++) {
|
||||
Component m = target.getComponent(i);
|
||||
if (m.isVisible()) {
|
||||
Dimension d = getPreferredSize(target, m);
|
||||
if (target instanceof JComponent t) {
|
||||
m.setSize(t.getWidth(), d.height);
|
||||
d.width = m.getWidth();
|
||||
} else {
|
||||
m.setSize(d.width, d.height);
|
||||
}
|
||||
|
||||
rs = dealWithDim4LayoutContainer(target, insets, d, x, y, roww, start, maxlen, i, ltr);
|
||||
x = rs[0];
|
||||
y = rs[1];
|
||||
roww = rs[2];
|
||||
start = rs[3];
|
||||
}
|
||||
}
|
||||
|
||||
dealWithMC4LayoutContainer(target, insets, x, y, roww, start, maxlen, nmembers, ltr);
|
||||
}
|
||||
}
|
||||
|
||||
protected Dimension getPreferredSize(Container target, Component m) {
|
||||
return m.getPreferredSize();
|
||||
}
|
||||
|
||||
protected void dealWithMC4LayoutContainer(Container target, Insets insets, int x, int y, int roww, int start, int maxlen, int nmembers, boolean ltr) {
|
||||
moveComponents(target, x, insets.top + vgap, roww, maxlen - y, start, nmembers, ltr);
|
||||
}
|
||||
|
||||
protected int[] dealWithDim4LayoutContainer(Container target, Insets insets, Dimension d, int x, int y, int roww, int start, int maxlen, int i, boolean ltr) {
|
||||
if ((y == 0) || ((y + d.height) <= maxlen)) {
|
||||
if (y > 0) y += vgap;
|
||||
y += d.height;
|
||||
roww = Math.max(roww, d.width);
|
||||
} else {
|
||||
moveComponents(target, x, insets.top + vgap, roww, maxlen - y, start, i, ltr);
|
||||
y = d.height;
|
||||
x += hgap + roww;
|
||||
roww = d.width;
|
||||
start = i;
|
||||
}
|
||||
return new int[]{x, y, roww, start};
|
||||
}
|
||||
|
||||
protected int getMaxLen4LayoutContainer(Container target, Insets insets) {
|
||||
return target.getHeight() - (insets.top + insets.bottom + vgap * 2);
|
||||
}
|
||||
|
||||
protected int getX4LayoutContainer(Insets insets) {
|
||||
return insets.left + hgap;
|
||||
}
|
||||
|
||||
protected int getY4LayoutContainer(Insets insets) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Returns a string representation of this <code>FlowLayout</code>
|
||||
* object and its values.
|
||||
*
|
||||
* @return a string representation of this layout
|
||||
*/
|
||||
public String toString() {
|
||||
String str = "";
|
||||
switch (this.newAlign) {
|
||||
case TOP:
|
||||
str = ",align=top";
|
||||
break;
|
||||
case CENTER:
|
||||
str = ",align=center";
|
||||
break;
|
||||
case BOTTOM:
|
||||
str = ",align=bottom";
|
||||
break;
|
||||
}
|
||||
|
||||
return getClass().getName() + "[hgap=" + hgap + ",vgap=" + vgap + str + "]";
|
||||
}
|
||||
}
|
||||
43
src/main/java/app/termora/plugin/ExtensionProxy.java
Normal file
43
src/main/java/app/termora/plugin/ExtensionProxy.java
Normal file
@@ -0,0 +1,43 @@
|
||||
package app.termora.plugin;
|
||||
|
||||
import org.slf4j.Logger;
|
||||
import org.slf4j.LoggerFactory;
|
||||
|
||||
import javax.swing.SwingUtilities;
|
||||
import java.lang.reflect.InvocationHandler;
|
||||
import java.lang.reflect.InvocationTargetException;
|
||||
import java.lang.reflect.Method;
|
||||
import java.lang.reflect.Proxy;
|
||||
|
||||
record ExtensionProxy(Plugin plugin, Extension extension) implements InvocationHandler {
|
||||
private static final Logger log = LoggerFactory.getLogger(ExtensionProxy.class);
|
||||
|
||||
public Object getProxy() {
|
||||
return Proxy.newProxyInstance(extension.getClass().getClassLoader(), extension.getClass().getInterfaces(), this);
|
||||
}
|
||||
|
||||
@Override
|
||||
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
|
||||
if (extension.getDispatchThread() == DispatchThread.EDT) {
|
||||
if (!SwingUtilities.isEventDispatchThread()) {
|
||||
if (log.isErrorEnabled()) {
|
||||
log.error("Event Dispatch Thread", new WrongThreadException("Event Dispatch Thread"));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
try {
|
||||
return method.invoke(extension, args);
|
||||
} catch (InvocationTargetException e) {
|
||||
final Throwable target = e.getTargetException();
|
||||
// 尽可能避免抛出致命性错误
|
||||
if (target instanceof Error && !(target instanceof VirtualMachineError)) {
|
||||
if (log.isErrorEnabled()) {
|
||||
log.error("Error Invoking method {}", method.getName(), target);
|
||||
}
|
||||
throw new IllegalCallerException(target.getMessage(), target);
|
||||
}
|
||||
throw e;
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user