org.keycloak.common.util.PathMatcher< P > クラステンプレート

org.keycloak.common.util.PathMatcher< P > 連携図

公開メンバ関数
P	matches (final String targetUri)
boolean	endsWithWildcard (String expectedUri)

限定公開メンバ関数
abstract String	getPath (P entry)
abstract Collection< P >	getPaths ()
String	buildUriFromTemplate (String template, String targetUri, boolean onlyFirstParam)
P	resolvePathConfig (P entry, String path)

非公開メンバ関数
boolean	exactMatch (String expectedUri, String targetUri, String value)
boolean	isTemplate (String uri)

静的非公開変数類
static final char	WILDCARD = '*'

詳解

著者

Pedro Igor

関数詳解

buildUriFromTemplate()

String org.keycloak.common.util.PathMatcher< P >.buildUriFromTemplate ( String  template, String  targetUri, boolean  onlyFirstParam  )

inlineprotected

                                                                                                     {
        String expectedUri = template;
        int patternStartIndex = expectedUri.indexOf("{");

        if (expectedUri.endsWith("/*")) {
            expectedUri = expectedUri.substring(0, expectedUri.length() - 2);
        }

        if (patternStartIndex == -1 || patternStartIndex >= targetUri.length()) {
            return null;
        }

        if (expectedUri.split("/").length > targetUri.split("/").length) {
            return null;
        }

        char[] expectedUriChars = expectedUri.toCharArray();
        char[] matchingUri = Arrays.copyOfRange(expectedUriChars, 0, patternStartIndex);
        int matchingUriLastIndex = matchingUri.length;
        String targetUriParams = targetUri.substring(patternStartIndex);

        if (Arrays.equals(matchingUri, Arrays.copyOf(targetUri.toCharArray(), matchingUri.length))) {
            matchingUri = Arrays.copyOf(matchingUri, targetUri.length());
            int paramIndex = 0;

            for (int i = patternStartIndex; i < expectedUriChars.length; i++) {
                if (matchingUriLastIndex >= matchingUri.length) {
                    break;
                }

                char c = expectedUriChars[i];

                if (c == '{' || c == '*') {
                    String[] params = targetUriParams.split("/");

                    for (int k = paramIndex; k <= (c == '*' ? params.length : paramIndex); k++) {
                        if (k == params.length) {
                            break;
                        }

                        int paramLength = params[k].length();

                        if (matchingUriLastIndex + paramLength > matchingUri.length) {
                            return null;
                        }

                        for (int j = 0; j < paramLength; j++) {
                            matchingUri[matchingUriLastIndex++] = params[k].charAt(j);
                        }

                        if (c == '*' && matchingUriLastIndex < matchingUri.length) {
                            matchingUri[matchingUriLastIndex++] = '/';
                        }
                    }

                    i = expectedUri.indexOf('}', i);

                    if (i == expectedUri.lastIndexOf('}') && onlyFirstParam) {
                        return String.valueOf(matchingUri).substring(0, matchingUriLastIndex);
                    }
                } else {
                    if (c == '/') {
                        paramIndex++;
                    }
                    matchingUri[matchingUriLastIndex++] = c;
                }
            }

            if (matchingUri[matchingUri.length - 1] == '\u0000') {
                if (template.endsWith("*")) {
                    StringBuilder firstParam = new StringBuilder(String.valueOf(matchingUri).substring(0, matchingUriLastIndex));

                    firstParam.append(targetUri.substring(firstParam.length()));

                    return firstParam.toString();
                }
                return null;
            }

            return String.valueOf(matchingUri);
        }

        return null;
    }

endsWithWildcard()

boolean org.keycloak.common.util.PathMatcher< P >.endsWithWildcard ( String  expectedUri )

inline

                                                        {
        int length = expectedUri.length();
        return length > 0 && WILDCARD == expectedUri.charAt(length - 1);
    }

exactMatch()

boolean org.keycloak.common.util.PathMatcher< P >.exactMatch ( String  expectedUri, String  targetUri, String  value  )

inlineprivate

                                                                                   {
        if (targetUri.equals(value)) {
            return value.equals(targetUri);
        }

        if (endsWithWildcard(expectedUri)) {
            return targetUri.startsWith(expectedUri.substring(0, expectedUri.length() - 2));
        }

        String suffix = "/*.";
        int suffixIndex = expectedUri.indexOf(suffix);

        if (suffixIndex != -1) {
            return targetUri.endsWith(expectedUri.substring(suffixIndex + suffix.length() - 1));
        }

        return false;
    }

getPath()

abstract String org.keycloak.common.util.PathMatcher< P >.getPath ( P  entry )

abstractprotected

getPaths()

abstract Collection<P> org.keycloak.common.util.PathMatcher< P >.getPaths ( )

abstractprotected

isTemplate()

boolean org.keycloak.common.util.PathMatcher< P >.isTemplate ( String  uri )

inlineprivate

                                           {
        return uri.indexOf("{") != -1;
    }

matches()

P org.keycloak.common.util.PathMatcher< P >.matches ( final String  targetUri )

inline

                                             {
        int patternCount = 0;
        P matchingPath = null;
        P matchingAnyPath = null;
        P matchingAnySuffixPath = null;

        for (P entry : getPaths()) {
            String expectedUri = getPath(entry);

            if (expectedUri == null) {
                continue;
            }

            String matchingUri = null;

            if (exactMatch(expectedUri, targetUri, expectedUri)) {
                matchingUri = expectedUri;
            }

            if (isTemplate(expectedUri)) {
                String templateUri = buildUriFromTemplate(expectedUri, targetUri, false);

                if (templateUri != null) {
                    int length = expectedUri.split("\\/").length;

                    if (exactMatch(expectedUri, targetUri, templateUri) && (patternCount == 0 || length > patternCount)) {
                        matchingUri = templateUri;
                        P resolved = resolvePathConfig(entry, targetUri);

                        if (resolved != null) {
                            entry = resolved;
                        }

                        patternCount = length;
                    }
                }
            }

            if (matchingUri != null) {
                StringBuilder path = new StringBuilder(expectedUri);
                int patternIndex = path.indexOf("/" + WILDCARD);

                if (patternIndex != -1) {
                    path.delete(patternIndex, path.length());
                }

                patternIndex = path.indexOf("{");

                if (patternIndex != -1) {
                    path.delete(patternIndex, path.length());
                }

                String pathString = path.toString();

                if ("".equals(pathString)) {
                    pathString = "/";
                }

                if (matchingUri.equals(targetUri) || pathString.equals(targetUri)) {
                    if (patternCount == 0) {
                        return entry;
                    } else {
                        matchingPath = entry;
                    }
                }

                if (WILDCARD == expectedUri.charAt(expectedUri.length() - 1)) {
                    if (matchingAnyPath == null || getPath(matchingAnyPath).length() < matchingUri.length()) {
                        matchingAnyPath = entry;
                    }
                } else {
                    int suffixIndex = expectedUri.indexOf(WILDCARD + ".");

                    if (suffixIndex != -1) {
                        String protectedSuffix = expectedUri.substring(suffixIndex + 1);

                        if (targetUri.endsWith(protectedSuffix)) {
                            matchingAnySuffixPath = entry;
                        }
                    }
                }
            }
        }

        if (matchingPath != null) {
            return matchingPath;
        }

        if (matchingAnySuffixPath != null) {
            return matchingAnySuffixPath;
        }

        return matchingAnyPath;
    }

resolvePathConfig()

P org.keycloak.common.util.PathMatcher< P >.resolvePathConfig ( P  entry, String  path  )

inlineprotected

                                                        {
        return entry;
    }

メンバ詳解

WILDCARD

final char org.keycloak.common.util.PathMatcher< P >.WILDCARD = '*'

staticprivate

---

このクラス詳解は次のファイルから抽出されました:

• D:/AppData/doxygen/keycloak/src/keycloak/src/main/java/org/keycloak/common/util/PathMatcher.java