org.keycloak.common.util.KeycloakUriBuilder クラス

org.keycloak.common.util.KeycloakUriBuilder 連携図

公開メンバ関数
KeycloakUriBuilder	clone ()
KeycloakUriBuilder	uriTemplate (String uriTemplate)
KeycloakUriBuilder	uri (String uriTemplate) throws IllegalArgumentException
KeycloakUriBuilder	uri (URI uri) throws IllegalArgumentException
KeycloakUriBuilder	scheme (String scheme) throws IllegalArgumentException
KeycloakUriBuilder	schemeSpecificPart (String ssp) throws IllegalArgumentException
KeycloakUriBuilder	userInfo (String ui)
KeycloakUriBuilder	host (String host) throws IllegalArgumentException
KeycloakUriBuilder	port (int port) throws IllegalArgumentException
KeycloakUriBuilder	path (String segment) throws IllegalArgumentException
KeycloakUriBuilder	replaceMatrix (String matrix) throws IllegalArgumentException
KeycloakUriBuilder	replaceQuery (String query) throws IllegalArgumentException
KeycloakUriBuilder	fragment (String fragment) throws IllegalArgumentException
KeycloakUriBuilder	encodedFragment (String fragment)
KeycloakUriBuilder	substitutePathParam (String name, Object value, boolean isEncoded)
URI	buildFromMap (Map< String, ?> values) throws IllegalArgumentException
URI	buildFromEncodedMap (Map< String, ?> values) throws IllegalArgumentException
URI	buildFromMap (Map< String, ?> values, boolean encodeSlashInPath) throws IllegalArgumentException
List< String >	getPathParamNamesInDeclarationOrder ()
URI	build (Object... values) throws IllegalArgumentException
KeycloakUriBuilder	matrixParam (String name, Object... values) throws IllegalArgumentException
KeycloakUriBuilder	queryParam (String name, Object... values) throws IllegalArgumentException
KeycloakUriBuilder	replaceQueryParam (String name, Object... values) throws IllegalArgumentException
String	getHost ()
String	getScheme ()
int	getPort ()
String	getUserInfo ()
String	getPath ()
String	getQuery ()
String	getFragment ()
KeycloakUriBuilder	segment (String... segments) throws IllegalArgumentException
KeycloakUriBuilder	replacePath (String path)
URI	build (Object[] values, boolean encodeSlashInPath) throws IllegalArgumentException
String	toTemplate ()
KeycloakUriBuilder	resolveTemplate (String name, Object value) throws IllegalArgumentException
KeycloakUriBuilder	resolveTemplates (Map< String, Object > templateValues) throws IllegalArgumentException
KeycloakUriBuilder	resolveTemplate (String name, Object value, boolean encodeSlashInPath) throws IllegalArgumentException
KeycloakUriBuilder	resolveTemplates (Map< String, Object > templateValues, boolean encodeSlashInPath) throws IllegalArgumentException
KeycloakUriBuilder	resolveTemplatesFromEncoded (Map< String, Object > templateValues) throws IllegalArgumentException

静的公開メンバ関数
static KeycloakUriBuilder	fromUri (URI uri)
static KeycloakUriBuilder	fromUri (String uriTemplate)
static KeycloakUriBuilder	fromPath (String path) throws IllegalArgumentException
static boolean	compare (String s1, String s2)
static URI	relativize (URI from, URI to)
static KeycloakUriBuilder	fromTemplate (String uriTemplate)
static Matcher	createUriParamMatcher (String string)

限定公開メンバ関数
KeycloakUriBuilder	parseHierarchicalUri (String uriTemplate, Matcher match)
URI	buildUriFromMap (Map< String, ?> paramMap, boolean fromEncodedMap, boolean encodeSlash) throws IllegalArgumentException
StringBuffer	replacePathParameter (String name, String value, boolean isEncoded, String string, StringBuffer buffer, boolean encodeSlash)
StringBuffer	replaceParameter (Map< String, ?> paramMap, boolean fromEncodedMap, boolean isTemplate, String string, StringBuffer buffer, boolean encodeSlash)
StringBuffer	replaceQueryStringParameter (Map< String, ?> paramMap, boolean fromEncodedMap, boolean isTemplate, String string, StringBuffer buffer)
URI	buildFromValues (boolean encodeSlash, boolean encoded, Object... values)

静的限定公開メンバ関数
static String	paths (boolean encode, String basePath, String... segments)

非公開メンバ関数
String	buildString (Map< String, ?> paramMap, boolean fromEncodedMap, boolean isTemplate, boolean encodeSlash)
void	addToPathParamList (List< String > params, HashSet< String > set, String string)

非公開変数類
String	host
String	scheme
int	port = -1
String	userInfo
String	path
String	query
String	fragment
String	ssp
String	authority

静的非公開変数類
static final Pattern	opaqueUri = Pattern.compile("^([^:/?#]+):([^/].*)")
static final Pattern	hierarchicalUri = Pattern.compile("^(([^:/?#]+):)?(//([^/?#]*))?([^?#]*)(\\?([^#]*))?(#(.*))?")
static final Pattern	hostPortPattern = Pattern.compile("([^/:]+):(\\d+)")
static final Pattern	PARAM_REPLACEMENT = Pattern.compile("_resteasy_uri_parameter")

詳解

著者

Bill Burke

バージョン

Revision

1

関数詳解

addToPathParamList()

void org.keycloak.common.util.KeycloakUriBuilder.addToPathParamList ( List< String >  params, HashSet< String >  set, String  string  )

inlineprivate

                                                                                             {
        Matcher matcher = PathHelper.URI_PARAM_PATTERN.matcher(PathHelper.replaceEnclosedCurlyBraces(string));
        while (matcher.find()) {
            String param = matcher.group(1);
            if (set.contains(param)) continue;
            else {
                set.add(param);
                params.add(param);
            }
        }
    }

build() [1/2]

URI org.keycloak.common.util.KeycloakUriBuilder.build ( Object...  values ) throws IllegalArgumentException

inline

                                                                       {
        if (values == null) throw new IllegalArgumentException("values parameter is null");
        return buildFromValues(true, false, values);
    }

build() [2/2]

URI org.keycloak.common.util.KeycloakUriBuilder.build ( Object []  values, boolean  encodeSlashInPath  ) throws IllegalArgumentException

inline

                                                                                                 {
        if (values == null) throw new IllegalArgumentException("values param is null");
        return buildFromValues(encodeSlashInPath, false, values);
    }

buildFromEncodedMap()

URI org.keycloak.common.util.KeycloakUriBuilder.buildFromEncodedMap ( Map< String, ?>  values ) throws IllegalArgumentException

inline

                                                                                          {
        if (values == null) throw new IllegalArgumentException("values parameter is null");
        return buildUriFromMap(values, true, false);
    }

buildFromMap() [1/2]

URI org.keycloak.common.util.KeycloakUriBuilder.buildFromMap ( Map< String, ?>  values ) throws IllegalArgumentException

inline

                                                                                   {
        if (values == null) throw new IllegalArgumentException("values parameter is null");
        return buildUriFromMap(values, false, true);
    }

buildFromMap() [2/2]

URI org.keycloak.common.util.KeycloakUriBuilder.buildFromMap ( Map< String, ?>  values, boolean  encodeSlashInPath  ) throws IllegalArgumentException

inline

                                                                                                              {
        if (values == null) throw new IllegalArgumentException("values parameter is null");
        return buildUriFromMap(values, false, encodeSlashInPath);
    }

buildFromValues()

URI org.keycloak.common.util.KeycloakUriBuilder.buildFromValues ( boolean  encodeSlash, boolean  encoded, Object...  values  )

inlineprotected

                                                                                          {
        List<String> params = getPathParamNamesInDeclarationOrder();
        if (values.length < params.size())
            throw new IllegalArgumentException("You did not supply enough values to fill path parameters");

        Map<String, Object> pathParams = new HashMap<String, Object>();


        for (int i = 0; i < params.size(); i++) {
            String pathParam = params.get(i);
            Object val = values[i];
            if (val == null) throw new IllegalArgumentException("A value was null");
            pathParams.put(pathParam, val.toString());
        }
        String buf = null;
        try {
            buf = buildString(pathParams, encoded, false, encodeSlash);
            return new URI(buf);
            //return URI.create(buf);
        } catch (Exception e) {
            throw new RuntimeException("Failed to create URI: " + buf, e);
        }
    }

buildString()

String org.keycloak.common.util.KeycloakUriBuilder.buildString ( Map< String, ?>  paramMap, boolean  fromEncodedMap, boolean  isTemplate, boolean  encodeSlash  )

inlineprivate

                                                                                                                         {
        for (Map.Entry<String, ? extends Object> entry : paramMap.entrySet()) {
            if (entry.getKey() == null) throw new IllegalArgumentException("map key is null");
            if (entry.getValue() == null) throw new IllegalArgumentException("map value is null");
        }
        StringBuffer buffer = new StringBuffer();

        if (scheme != null)
            replaceParameter(paramMap, fromEncodedMap, isTemplate, scheme, buffer, encodeSlash).append(":");
        if (ssp != null) {
            buffer.append(ssp);
        } else if (userInfo != null || host != null || port != -1) {
            buffer.append("//");
            if (userInfo != null)
                replaceParameter(paramMap, fromEncodedMap, isTemplate, userInfo, buffer, encodeSlash).append("@");
            if (host != null) {
                if ("".equals(host)) throw new RuntimeException("empty host name");
                replaceParameter(paramMap, fromEncodedMap, isTemplate, host, buffer, encodeSlash);
            }
            if (port != -1 && (scheme == null || (scheme.equals("http") && port != 80) || (scheme.equals("https") && port != 443)) ) {
                buffer.append(":").append(Integer.toString(port));
            }
        } else if (authority != null) {
            buffer.append("//");
            replaceParameter(paramMap, fromEncodedMap, isTemplate, authority, buffer, encodeSlash);
        }
        if (path != null) {
            StringBuffer tmp = new StringBuffer();
            replaceParameter(paramMap, fromEncodedMap, isTemplate, path, tmp, encodeSlash);
            String tmpPath = tmp.toString();
            if (userInfo != null || host != null) {
                if (!tmpPath.startsWith("/")) buffer.append("/");
            }
            buffer.append(tmpPath);
        }
        if (query != null) {
            buffer.append("?");
            replaceQueryStringParameter(paramMap, fromEncodedMap, isTemplate, query, buffer);
        }
        if (fragment != null) {
            buffer.append("#");
            replaceParameter(paramMap, fromEncodedMap, isTemplate, fragment, buffer, encodeSlash);
        }
        return buffer.toString();
    }

buildUriFromMap()

URI org.keycloak.common.util.KeycloakUriBuilder.buildUriFromMap ( Map< String, ?>  paramMap, boolean  fromEncodedMap, boolean  encodeSlash  ) throws IllegalArgumentException

inlineprotected

                                                                                                                                        {
        String buf = buildString(paramMap, fromEncodedMap, false, encodeSlash);
        try {
            return URI.create(buf);
        } catch (Exception e) {
            throw new RuntimeException("Failed to create URI: " + buf, e);
        }
    }

clone()

KeycloakUriBuilder org.keycloak.common.util.KeycloakUriBuilder.clone ( )

inline

                                      {
        KeycloakUriBuilder impl = new KeycloakUriBuilder();
        impl.host = host;
        impl.scheme = scheme;
        impl.port = port;
        impl.userInfo = userInfo;
        impl.path = path;
        impl.query = query;
        impl.fragment = fragment;
        impl.ssp = ssp;
        impl.authority = authority;

        return impl;
    }

compare()

static boolean org.keycloak.common.util.KeycloakUriBuilder.compare ( String  s1, String  s2  )

inlinestatic

                                                        {
        if (s1 == s2) return true;
        if (s1 == null || s2 == null) return false;
        return s1.equals(s2);
    }

createUriParamMatcher()

static Matcher org.keycloak.common.util.KeycloakUriBuilder.createUriParamMatcher ( String  string )

inlinestatic

                                                               {
        return PathHelper.URI_PARAM_PATTERN.matcher(PathHelper.replaceEnclosedCurlyBraces(string));
    }

encodedFragment()

KeycloakUriBuilder org.keycloak.common.util.KeycloakUriBuilder.encodedFragment ( String  fragment )

inline

Set fragment, but not encode it. It assumes that given fragment was already properly encoded

引数

fragment

戻り値

                                                               {
        this.fragment = fragment;
        return this;
    }

fragment()

KeycloakUriBuilder org.keycloak.common.util.KeycloakUriBuilder.fragment ( String  fragment ) throws IllegalArgumentException

inline

                                                                                        {
        if (fragment == null) {
            this.fragment = null;
            return this;
        }
        this.fragment = Encode.encodeFragment(fragment);
        return this;
    }

fromPath()

static KeycloakUriBuilder org.keycloak.common.util.KeycloakUriBuilder.fromPath ( String  path ) throws IllegalArgumentException

inlinestatic

                                                                                           {
        return new KeycloakUriBuilder().path(path);
    }

fromTemplate()

static KeycloakUriBuilder org.keycloak.common.util.KeycloakUriBuilder.fromTemplate ( String  uriTemplate )

inlinestatic

You may put path parameters anywhere within the uriTemplate except port

引数

uriTemplate

戻り値

                                                                      {
        KeycloakUriBuilder impl = new KeycloakUriBuilder();
        impl.uriTemplate(uriTemplate);
        return impl;
    }

fromUri() [1/2]

static KeycloakUriBuilder org.keycloak.common.util.KeycloakUriBuilder.fromUri ( URI  uri )

inlinestatic

                                                      {
        return new KeycloakUriBuilder().uri(uri);
    }

fromUri() [2/2]

static KeycloakUriBuilder org.keycloak.common.util.KeycloakUriBuilder.fromUri ( String  uriTemplate )

inlinestatic

                                                                 {
        return new KeycloakUriBuilder().uri(uriTemplate);
    }

getFragment()

String org.keycloak.common.util.KeycloakUriBuilder.getFragment ( )

inline

                                {
        return fragment;
    }

getHost()

String org.keycloak.common.util.KeycloakUriBuilder.getHost ( )

inline

                            {
        return host;
    }

getPath()

String org.keycloak.common.util.KeycloakUriBuilder.getPath ( )

inline

                            {
        return path;
    }

getPathParamNamesInDeclarationOrder()

List<String> org.keycloak.common.util.KeycloakUriBuilder.getPathParamNamesInDeclarationOrder ( )

inline

Return a unique order list of path params

戻り値

                                                              {
        List<String> params = new ArrayList<String>();
        HashSet<String> set = new HashSet<String>();
        if (scheme != null) addToPathParamList(params, set, scheme);
        if (userInfo != null) addToPathParamList(params, set, userInfo);
        if (host != null) addToPathParamList(params, set, host);
        if (path != null) addToPathParamList(params, set, path);
        if (query != null) addToPathParamList(params, set, query);
        if (fragment != null) addToPathParamList(params, set, fragment);

        return params;
    }

getPort()

int org.keycloak.common.util.KeycloakUriBuilder.getPort ( )

inline

                         {
        return port;
    }

getQuery()

String org.keycloak.common.util.KeycloakUriBuilder.getQuery ( )

inline

                             {
        return query;
    }

getScheme()

String org.keycloak.common.util.KeycloakUriBuilder.getScheme ( )

inline

                              {
        return scheme;
    }

getUserInfo()

String org.keycloak.common.util.KeycloakUriBuilder.getUserInfo ( )

inline

                                {
        return userInfo;
    }

host()

KeycloakUriBuilder org.keycloak.common.util.KeycloakUriBuilder.host ( String  host ) throws IllegalArgumentException

inline

                                                                                {
        if (host != null && host.equals("")) throw new IllegalArgumentException("invalid host");
        this.host = host;
        return this;
    }

matrixParam()

KeycloakUriBuilder org.keycloak.common.util.KeycloakUriBuilder.matrixParam ( String  name, Object...  values  ) throws IllegalArgumentException

inline

                                                                                                         {
        if (name == null) throw new IllegalArgumentException("name parameter is null");
        if (values == null) throw new IllegalArgumentException("values parameter is null");
        if (path == null) path = "";
        for (Object val : values) {
            if (val == null) throw new IllegalArgumentException("null value");
            path += ";" + Encode.encodeMatrixParam(name) + "=" + Encode.encodeMatrixParam(val.toString());
        }
        return this;
    }

parseHierarchicalUri()

KeycloakUriBuilder org.keycloak.common.util.KeycloakUriBuilder.parseHierarchicalUri ( String  uriTemplate, Matcher  match  )

inlineprotected

                                                                                         {
        boolean scheme = match.group(2) != null;
        if (scheme) this.scheme = match.group(2);
        String authority = match.group(4);
        if (authority != null) {
            this.authority = null;
            String host = match.group(4);
            int at = host.indexOf('@');
            if (at > -1) {
                String user = host.substring(0, at);
                host = host.substring(at + 1);
                this.userInfo = user;
            }
            Matcher hostPortMatch = hostPortPattern.matcher(host);
            if (hostPortMatch.matches()) {
                this.host = hostPortMatch.group(1);
                try {
                    this.port = Integer.parseInt(hostPortMatch.group(2));
                } catch (NumberFormatException e) {
                    throw new IllegalArgumentException("Illegal uri template: " + uriTemplate, e);
                }
            } else {
                this.host = host;
            }
        }
        if (match.group(5) != null) {
            String group = match.group(5);
            if (!scheme && !"".equals(group) && !group.startsWith("/") && group.indexOf(':') > -1)
                throw new IllegalArgumentException("Illegal uri template: " + uriTemplate);
            if (!"".equals(group)) replacePath(group);
        }
        if (match.group(7) != null) replaceQuery(match.group(7));
        if (match.group(9) != null) fragment(match.group(9));
        return this;
    }

path()

KeycloakUriBuilder org.keycloak.common.util.KeycloakUriBuilder.path ( String  segment ) throws IllegalArgumentException

inline

                                                                                   {
        if (segment == null) throw new IllegalArgumentException("path was null");
        path = paths(true, path, segment);
        return this;
    }

paths()

static String org.keycloak.common.util.KeycloakUriBuilder.paths ( boolean  encode, String  basePath, String...  segments  )

inlinestaticprotected

                                                                                       {
        String path = basePath;
        if (path == null) path = "";
        for (String segment : segments) {
            if ("".equals(segment)) continue;
            if (path.endsWith("/")) {
                if (segment.startsWith("/")) {
                    segment = segment.substring(1);
                    if ("".equals(segment)) continue;
                }
                if (encode) segment = Encode.encodePath(segment);
                path += segment;
            } else {
                if (encode) segment = Encode.encodePath(segment);
                if ("".equals(path)) {
                    path = segment;
                } else if (segment.startsWith("/")) {
                    path += segment;
                } else {
                    path += "/" + segment;
                }
            }

        }
        return path;
    }

port()

KeycloakUriBuilder org.keycloak.common.util.KeycloakUriBuilder.port ( int  port ) throws IllegalArgumentException

inline

                                                                             {
        if (port < -1) throw new IllegalArgumentException("Invalid port value");
        this.port = port;
        return this;
    }

queryParam()

KeycloakUriBuilder org.keycloak.common.util.KeycloakUriBuilder.queryParam ( String  name, Object...  values  ) throws IllegalArgumentException

inline

                                                                                                        {
        if (name == null) throw new IllegalArgumentException("name parameter is null");
        if (values == null) throw new IllegalArgumentException("values parameter is null");
        for (Object value : values) {
            if (value == null) throw new IllegalArgumentException("A passed in value was null");
            if (query == null) query = "";
            else query += "&";
            query += Encode.encodeQueryParamAsIs(name) + "=" + Encode.encodeQueryParamAsIs(value.toString());
        }
        return this;
    }

relativize()

static URI org.keycloak.common.util.KeycloakUriBuilder.relativize ( URI  from, URI  to  )

inlinestatic

                                                   {
        if (!compare(from.getScheme(), to.getScheme())) return to;
        if (!compare(from.getHost(), to.getHost())) return to;
        if (from.getPort() != to.getPort()) return to;
        if (from.getPath() == null && to.getPath() == null) return URI.create("");
        else if (from.getPath() == null) return URI.create(to.getPath());
        else if (to.getPath() == null) return to;


        String fromPath = from.getPath();
        if (fromPath.startsWith("/")) fromPath = fromPath.substring(1);
        String[] fsplit = fromPath.split("/");
        String toPath = to.getPath();
        if (toPath.startsWith("/")) toPath = toPath.substring(1);
        String[] tsplit = toPath.split("/");

        int f = 0;

        for (; f < fsplit.length && f < tsplit.length; f++) {
            if (!fsplit[f].equals(tsplit[f])) break;
        }

        KeycloakUriBuilder builder = KeycloakUriBuilder.fromPath("");
        for (int i = f; i < fsplit.length; i++) builder.path("..");
        for (int i = f; i < tsplit.length; i++) builder.path(tsplit[i]);
        return builder.build();
    }

replaceMatrix()

KeycloakUriBuilder org.keycloak.common.util.KeycloakUriBuilder.replaceMatrix ( String  matrix ) throws IllegalArgumentException

inline

                                                                                           {
        if (matrix == null) matrix = "";
        if (!matrix.startsWith(";")) matrix = ";" + matrix;
        matrix = Encode.encodePath(matrix);
        if (path == null) {
            path = matrix;
        } else {
            int start = path.lastIndexOf('/');
            if (start < 0) start = 0;
            int matrixIndex = path.indexOf(';', start);
            if (matrixIndex > -1) path = path.substring(0, matrixIndex) + matrix;
            else path += matrix;

        }
        return this;
    }

replaceParameter()

StringBuffer org.keycloak.common.util.KeycloakUriBuilder.replaceParameter ( Map< String, ?>  paramMap, boolean  fromEncodedMap, boolean  isTemplate, String  string, StringBuffer  buffer, boolean  encodeSlash  )

inlineprotected

                                                                                                                                                                          {
        Matcher matcher = createUriParamMatcher(string);
        while (matcher.find()) {
            String param = matcher.group(1);
            Object valObj = paramMap.get(param);
            if (valObj == null && !isTemplate) {
                throw new IllegalArgumentException("NULL value for template parameter: " + param);
            } else if (valObj == null && isTemplate) {
                matcher.appendReplacement(buffer, matcher.group());
                continue;
            }
            String value = valObj.toString();
            if (value != null) {
                if (!fromEncodedMap) {
                    if (encodeSlash) value = Encode.encodePathSegmentAsIs(value);
                    else value = Encode.encodePathAsIs(value);
                } else {
                    if (encodeSlash) value = Encode.encodePathSegmentSaveEncodings(value);
                    else value = Encode.encodePathSaveEncodings(value);
                }
                matcher.appendReplacement(buffer, Matcher.quoteReplacement(value));
            } else {
                throw new IllegalArgumentException("path param " + param + " has not been provided by the parameter map");
            }
        }
        matcher.appendTail(buffer);
        return buffer;
    }

replacePath()

KeycloakUriBuilder org.keycloak.common.util.KeycloakUriBuilder.replacePath ( String  path )

inline

                                                       {
        if (path == null) {
            this.path = null;
            return this;
        }
        this.path = Encode.encodePath(path);
        return this;
    }

replacePathParameter()

StringBuffer org.keycloak.common.util.KeycloakUriBuilder.replacePathParameter ( String  name, String  value, boolean  isEncoded, String  string, StringBuffer  buffer, boolean  encodeSlash  )

inlineprotected

                                                                                                                                                       {
        Matcher matcher = createUriParamMatcher(string);
        while (matcher.find()) {
            String param = matcher.group(1);
            if (!param.equals(name)) continue;
            if (!isEncoded) {
                if (encodeSlash) value = Encode.encodePath(value);
                else value = Encode.encodePathSegment(value);

            } else {
                value = Encode.encodeNonCodes(value);
            }
            // if there is a $ then we must backslash it or it will screw up regex group substitution
            value = value.replace("$", "\\$");
            matcher.appendReplacement(buffer, value);
        }
        matcher.appendTail(buffer);
        return buffer;
    }

replaceQuery()

KeycloakUriBuilder org.keycloak.common.util.KeycloakUriBuilder.replaceQuery ( String  query ) throws IllegalArgumentException

inline

                                                                                         {
        if (query == null || query.length() == 0) {
            this.query = null;
            return this;
        }
        this.query = Encode.encodeQueryString(query);
        return this;
    }

replaceQueryParam()

KeycloakUriBuilder org.keycloak.common.util.KeycloakUriBuilder.replaceQueryParam ( String  name, Object...  values  ) throws IllegalArgumentException

inline

                                                                                                               {
        if (name == null) throw new IllegalArgumentException("name parameter is null");
        if (query == null || query.equals("")) {
            if (values != null) return queryParam(name, values);
            return this;
        }

        String[] params = query.split("&");
        query = null;

        String replacedName = Encode.encodeQueryParam(name);


        for (String param : params) {
            int pos = param.indexOf('=');
            if (pos >= 0) {
                String paramName = param.substring(0, pos);
                if (paramName.equals(replacedName)) continue;
            } else {
                if (param.equals(replacedName)) continue;
            }
            if (query == null) query = "";
            else query += "&";
            query += param;
        }
        // don't set values if values is null
        if (values == null) return this;
        return queryParam(name, values);
    }

replaceQueryStringParameter()

StringBuffer org.keycloak.common.util.KeycloakUriBuilder.replaceQueryStringParameter ( Map< String, ?>  paramMap, boolean  fromEncodedMap, boolean  isTemplate, String  string, StringBuffer  buffer  )

inlineprotected

                                                                                                                                                                {
        Matcher matcher = createUriParamMatcher(string);
        while (matcher.find()) {
            String param = matcher.group(1);
            Object valObj = paramMap.get(param);
            if (valObj == null && !isTemplate) {
                throw new IllegalArgumentException("NULL value for template parameter: " + param);
            } else if (valObj == null && isTemplate) {
                matcher.appendReplacement(buffer, matcher.group());
                continue;
            }
            String value = valObj.toString();
            if (value != null) {
                if (!fromEncodedMap) {
                    value = Encode.encodeQueryParamAsIs(value);
                } else {
                    value = Encode.encodeQueryParamSaveEncodings(value);
                }
                matcher.appendReplacement(buffer, value);
            } else {
                throw new IllegalArgumentException("path param " + param + " has not been provided by the parameter map");
            }
        }
        matcher.appendTail(buffer);
        return buffer;
    }

resolveTemplate() [1/2]

KeycloakUriBuilder org.keycloak.common.util.KeycloakUriBuilder.resolveTemplate ( String  name, Object  value  ) throws IllegalArgumentException

inline

                                                                                                         {
        if (name == null) throw new IllegalArgumentException("name param is null");
        if (value == null) throw new IllegalArgumentException("value param is null");
        HashMap<String, Object> vals = new HashMap<String, Object>();
        vals.put(name, value);
        return resolveTemplates(vals);
    }

resolveTemplate() [2/2]

KeycloakUriBuilder org.keycloak.common.util.KeycloakUriBuilder.resolveTemplate ( String  name, Object  value, boolean  encodeSlashInPath  ) throws IllegalArgumentException

inline

                                                                                                                                    {
        if (name == null) throw new IllegalArgumentException("name param is null");
        if (value == null) throw new IllegalArgumentException("value param is null");
        HashMap<String, Object> vals = new HashMap<String, Object>();
        vals.put(name, value);
        String str = buildString(vals, false, true, encodeSlashInPath);
        return fromTemplate(str);
    }

resolveTemplates() [1/2]

KeycloakUriBuilder org.keycloak.common.util.KeycloakUriBuilder.resolveTemplates ( Map< String, Object >  templateValues ) throws IllegalArgumentException

inline

                                                                                                                   {
        if (templateValues == null) throw new IllegalArgumentException("templateValues param null");
        String str = buildString(templateValues, false, true, true);
        return fromTemplate(str);
    }

resolveTemplates() [2/2]

KeycloakUriBuilder org.keycloak.common.util.KeycloakUriBuilder.resolveTemplates ( Map< String, Object >  templateValues, boolean  encodeSlashInPath  ) throws IllegalArgumentException

inline

                                                                                                                                              {
        if (templateValues == null) throw new IllegalArgumentException("templateValues param null");
        String str = buildString(templateValues, false, true, encodeSlashInPath);
        return fromTemplate(str);
    }

resolveTemplatesFromEncoded()

KeycloakUriBuilder org.keycloak.common.util.KeycloakUriBuilder.resolveTemplatesFromEncoded ( Map< String, Object >  templateValues ) throws IllegalArgumentException

inline

                                                                                                                              {
        if (templateValues == null) throw new IllegalArgumentException("templateValues param null");
        String str = buildString(templateValues, true, true, true);
        return fromTemplate(str);
    }

scheme()

KeycloakUriBuilder org.keycloak.common.util.KeycloakUriBuilder.scheme ( String  scheme ) throws IllegalArgumentException

inline

                                                                                    {
        this.scheme = scheme;
        return this;
    }

schemeSpecificPart()

KeycloakUriBuilder org.keycloak.common.util.KeycloakUriBuilder.schemeSpecificPart ( String  ssp ) throws IllegalArgumentException

inline

                                                                                             {
        if (ssp == null) throw new IllegalArgumentException("schemeSpecificPart was null");

        StringBuilder sb = new StringBuilder();
        if (scheme != null) sb.append(scheme).append(':');
        if (ssp != null)
            sb.append(ssp);
        if (fragment != null && fragment.length() > 0) sb.append('#').append(fragment);
        URI uri = URI.create(sb.toString());

        if (uri.getRawSchemeSpecificPart() != null && uri.getRawPath() == null) {
            this.ssp = uri.getRawSchemeSpecificPart();
        } else {
            this.ssp = null;
            userInfo = uri.getRawUserInfo();
            host = uri.getHost();
            port = uri.getPort();
            path = uri.getRawPath();
            query = uri.getRawQuery();

        }
        return this;

    }

segment()

KeycloakUriBuilder org.keycloak.common.util.KeycloakUriBuilder.segment ( String...  segments ) throws IllegalArgumentException

inline

                                                                                          {
        if (segments == null) throw new IllegalArgumentException("segments parameter was null");
        for (String segment : segments) {
            if (segment == null) throw new IllegalArgumentException("A segment is null");
            path(Encode.encodePathSegment(segment));
        }
        return this;
    }

substitutePathParam()

KeycloakUriBuilder org.keycloak.common.util.KeycloakUriBuilder.substitutePathParam ( String  name, Object  value, boolean  isEncoded  )

inline

Only replace path params in path of URI. This changes state of URIBuilder.

引数

name
value
isEncoded

戻り値

                                                                                                {
        if (path != null) {
            StringBuffer buffer = new StringBuffer();
            replacePathParameter(name, value.toString(), isEncoded, path, buffer, false);
            path = buffer.toString();
        }
        return this;
    }

toTemplate()

String org.keycloak.common.util.KeycloakUriBuilder.toTemplate ( )

inline

                               {
        return buildString(new HashMap<String, Object>(), true, true, true);
    }

uri() [1/2]

KeycloakUriBuilder org.keycloak.common.util.KeycloakUriBuilder.uri ( String  uriTemplate ) throws IllegalArgumentException

inline

                                                                                      {
        return uriTemplate(uriTemplate);
    }

uri() [2/2]

KeycloakUriBuilder org.keycloak.common.util.KeycloakUriBuilder.uri ( URI  uri ) throws IllegalArgumentException

inline

                                                                           {
        if (uri == null) throw new IllegalArgumentException("URI was null");

        if (uri.getRawFragment() != null) fragment = uri.getRawFragment();

        if (uri.isOpaque()) {
            scheme = uri.getScheme();
            ssp = uri.getRawSchemeSpecificPart();
            return this;
        }

        if (uri.getScheme() == null) {
            if (ssp != null) {
                if (uri.getRawSchemeSpecificPart() != null) {
                    ssp = uri.getRawSchemeSpecificPart();
                    return this;
                }
            }
        } else {
            scheme = uri.getScheme();
        }

        ssp = null;
        if (uri.getRawAuthority() != null) {
            if (uri.getRawUserInfo() == null && uri.getHost() == null && uri.getPort() == -1) {
                authority = uri.getRawAuthority();
                userInfo = null;
                host = null;
                port = -1;
            } else {
                authority = null;
                if (uri.getRawUserInfo() != null) {
                    userInfo = uri.getRawUserInfo();
                }
                if (uri.getHost() != null) {
                    host = uri.getHost();
                }
                if (uri.getPort() != -1) {
                    port = uri.getPort();
                }
            }
        }

        if (uri.getRawPath() != null && uri.getRawPath().length() > 0) {
            path = uri.getRawPath();
        }
        if (uri.getRawQuery() != null && uri.getRawQuery().length() > 0) {
            query = uri.getRawQuery();
        }

        return this;
    }

uriTemplate()

KeycloakUriBuilder org.keycloak.common.util.KeycloakUriBuilder.uriTemplate ( String  uriTemplate )

inline

You may put path parameters anywhere within the uriTemplate except port

引数

uriTemplate

戻り値

                                                              {
        if (uriTemplate == null) throw new IllegalArgumentException("uriTemplate parameter is null");
        Matcher opaque = opaqueUri.matcher(uriTemplate);
        if (opaque.matches()) {
            this.authority = null;
            this.host = null;
            this.port = -1;
            this.userInfo = null;
            this.query = null;
            this.scheme = opaque.group(1);
            this.ssp = opaque.group(2);
            return this;
        } else {
            Matcher match = hierarchicalUri.matcher(uriTemplate);
            if (match.matches()) {
                ssp = null;
                return parseHierarchicalUri(uriTemplate, match);
            }
        }
        throw new IllegalArgumentException("Illegal uri template: " + uriTemplate);
    }

userInfo()

KeycloakUriBuilder org.keycloak.common.util.KeycloakUriBuilder.userInfo ( String  ui )

inline

                                                  {
        this.userInfo = ui;
        return this;
    }

メンバ詳解

authority

String org.keycloak.common.util.KeycloakUriBuilder.authority

private

fragment

String org.keycloak.common.util.KeycloakUriBuilder.fragment

private

hierarchicalUri

final Pattern org.keycloak.common.util.KeycloakUriBuilder.hierarchicalUri = Pattern.compile("^(([^:/?#]+):)?(//([^/?#]*))?([^?#]*)(\\?([^#]*))?(#(.*))?")

staticprivate

host

String org.keycloak.common.util.KeycloakUriBuilder.host

private

hostPortPattern

final Pattern org.keycloak.common.util.KeycloakUriBuilder.hostPortPattern = Pattern.compile("([^/:]+):(\\d+)")

staticprivate

opaqueUri

final Pattern org.keycloak.common.util.KeycloakUriBuilder.opaqueUri = Pattern.compile("^([^:/?#]+):([^/].*)")

staticprivate

PARAM_REPLACEMENT

final Pattern org.keycloak.common.util.KeycloakUriBuilder.PARAM_REPLACEMENT = Pattern.compile("_resteasy_uri_parameter")

staticprivate

path

String org.keycloak.common.util.KeycloakUriBuilder.path

private

port

int org.keycloak.common.util.KeycloakUriBuilder.port = -1

private

query

String org.keycloak.common.util.KeycloakUriBuilder.query

private

scheme

String org.keycloak.common.util.KeycloakUriBuilder.scheme

private

ssp

String org.keycloak.common.util.KeycloakUriBuilder.ssp

private

userInfo

String org.keycloak.common.util.KeycloakUriBuilder.userInfo

private

---

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

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