@Override public List<Element> elements() { return this.fullPath.elements(); }
public MatchingContext(PathContainer pathContainer, boolean extractVariables) { this.candidate = pathContainer; this.pathElements = pathContainer.elements(); this.pathLength = this.pathElements.size(); this.extractingVariables = extractVariables; }
/** * Return if the container is not null and has more than zero elements. * @param container a path container * @return {@code true} has more than zero elements */ private boolean hasLength(@Nullable PathContainer container) { return container != null && container.elements().size() > 0; }
@Override public List<Element> elements() { return this.fullPath.elements(); }
public MatchingContext(PathContainer pathContainer, boolean extractVariables) { this.candidate = pathContainer; this.pathElements = pathContainer.elements(); this.pathLength = this.pathElements.size(); this.extractingVariables = extractVariables; }
/** * Extract a sub-path from the given offset into the elements list. * @param index the start element index (inclusive) * @return the sub-path */ default PathContainer subPath(int index) { return subPath(index, elements().size()); }
private static PathContainer extractPathWithinApplication(PathContainer fullPath, PathContainer contextPath) { return fullPath.subPath(contextPath.elements().size()); }
/** * Return if the container is not null and has more than zero elements. * @param container a path container * @return {@code true} has more than zero elements */ private boolean hasLength(@Nullable PathContainer container) { return container != null && container.elements().size() > 0; }
static PathContainer subPath(PathContainer container, int fromIndex, int toIndex) { List<Element> elements = container.elements(); if (fromIndex == 0 && toIndex == elements.size()) { return container; } if (fromIndex == toIndex) { return EMPTY_PATH; } Assert.isTrue(fromIndex >= 0 && fromIndex < elements.size(), () -> "Invalid fromIndex: " + fromIndex); Assert.isTrue(toIndex >= 0 && toIndex <= elements.size(), () -> "Invalid toIndex: " + toIndex); Assert.isTrue(fromIndex < toIndex, () -> "fromIndex: " + fromIndex + " should be < toIndex " + toIndex); List<Element> subList = elements.subList(fromIndex, toIndex); String path = subList.stream().map(Element::value).collect(Collectors.joining("")); return new DefaultPathContainer(path, subList); }
/** * Extract a sub-path from the given offset into the elements list. * @param index the start element index (inclusive) * @return the sub-path */ default PathContainer subPath(int index) { return subPath(index, elements().size()); }
private static PathContainer initContextPath(PathContainer path, @Nullable String contextPath) { if (!StringUtils.hasText(contextPath) || "/".equals(contextPath)) { return PathContainer.parsePath(""); } validateContextPath(path.value(), contextPath); int length = contextPath.length(); int counter = 0; for (int i=0; i < path.elements().size(); i++) { PathContainer.Element element = path.elements().get(i); counter += element.value().length(); if (length == counter) { return path.subPath(0, i + 1); } } // Should not happen.. throw new IllegalStateException("Failed to initialize contextPath '" + contextPath + "'" + " for requestPath '" + path.value() + "'"); }
private static PathContainer extractPathWithinApplication(PathContainer fullPath, PathContainer contextPath) { return fullPath.subPath(contextPath.elements().size()); }
private Mono<String> resolveResourceUrl(ServerWebExchange exchange, PathContainer lookupPath) { return this.handlerMap.entrySet().stream() .filter(entry -> entry.getKey().matches(lookupPath)) .min((entry1, entry2) -> PathPattern.SPECIFICITY_COMPARATOR.compare(entry1.getKey(), entry2.getKey())) .map(entry -> { PathContainer path = entry.getKey().extractPathWithinPattern(lookupPath); int endIndex = lookupPath.elements().size() - path.elements().size(); PathContainer mapping = lookupPath.subPath(0, endIndex); ResourceWebHandler handler = entry.getValue(); List<ResourceResolver> resolvers = handler.getResourceResolvers(); ResourceResolverChain chain = new DefaultResourceResolverChain(resolvers); return chain.resolveUrlPath(path.value(), handler.getLocations()) .map(resolvedPath -> mapping.value() + resolvedPath); }) .orElseGet(() ->{ if (logger.isTraceEnabled()) { logger.trace(exchange.getLogPrefix() + "No match for \"" + lookupPath + "\""); } return Mono.empty(); }); }
static PathContainer subPath(PathContainer container, int fromIndex, int toIndex) { List<Element> elements = container.elements(); if (fromIndex == 0 && toIndex == elements.size()) { return container; } if (fromIndex == toIndex) { return EMPTY_PATH; } Assert.isTrue(fromIndex >= 0 && fromIndex < elements.size(), () -> "Invalid fromIndex: " + fromIndex); Assert.isTrue(toIndex >= 0 && toIndex <= elements.size(), () -> "Invalid toIndex: " + toIndex); Assert.isTrue(fromIndex < toIndex, () -> "fromIndex: " + fromIndex + " should be < toIndex " + toIndex); List<Element> subList = elements.subList(fromIndex, toIndex); String path = subList.stream().map(Element::value).collect(Collectors.joining("")); return new DefaultPathContainer(path, subList); }
public SubPathContainer(PathContainer original) { this.value = prefixWithSlash(original.value()); this.elements = prependWithSeparator(original.elements()); }
private static PathContainer initContextPath(PathContainer path, @Nullable String contextPath) { if (!StringUtils.hasText(contextPath) || "/".equals(contextPath)) { return PathContainer.parsePath(""); } validateContextPath(path.value(), contextPath); int length = contextPath.length(); int counter = 0; for (int i=0; i < path.elements().size(); i++) { PathContainer.Element element = path.elements().get(i); counter += element.value().length(); if (length == counter) { return path.subPath(0, i + 1); } } // Should not happen.. throw new IllegalStateException("Failed to initialize contextPath '" + contextPath + "'" + " for requestPath '" + path.value() + "'"); }
private void testPath(String input, String value, List<String> expectedElements) { PathContainer path = PathContainer.parsePath(input); assertEquals("value: '" + input + "'", value, path.value()); assertEquals("elements: " + input, expectedElements, path.elements().stream() .map(PathContainer.Element::value).collect(Collectors.toList())); }
private void testPathSegment(String rawValue, String valueToMatch, MultiValueMap<String, String> params) { PathContainer container = PathContainer.parsePath(rawValue); if ("".equals(rawValue)) { assertEquals(0, container.elements().size()); return; } assertEquals(1, container.elements().size()); PathSegment segment = (PathSegment) container.elements().get(0); assertEquals("value: '" + rawValue + "'", rawValue, segment.value()); assertEquals("valueToMatch: '" + rawValue + "'", valueToMatch, segment.valueToMatch()); assertEquals("params: '" + rawValue + "'", params, segment.parameters()); }
@Test public void pathContainer() { assertEquals("[/][abc][/][def]",elementsToString(toPathContainer("/abc/def").elements())); assertEquals("[abc][/][def]",elementsToString(toPathContainer("abc/def").elements())); assertEquals("[abc][/][def][/]",elementsToString(toPathContainer("abc/def/").elements())); assertEquals("[abc][/][/][def][/][/]",elementsToString(toPathContainer("abc//def//").elements())); assertEquals("[/]",elementsToString(toPathContainer("/").elements())); assertEquals("[/][/][/]",elementsToString(toPathContainer("///").elements())); }
if (matchingContext.remainingPathIndex == pathContainer.elements().size()) { info = new PathRemainingMatchInfo(EMPTY_PATH, matchingContext.getPathMatchResult());