{@inheritDoc}

@see java.nio.file.Path#resolveSibling(java.lang.String)
163683
@Override
    public Path resolveSibling(final String other) {
        // Delegate
        final Path otherPath = this.fromString(other);
        return this.resolveSibling(otherPath);
    }
364360
@CheckForNull
    public static File resolveSymlinkToFile(@Nonnull File link) throws InterruptedException, IOException {
        String target = resolveSymlink(link);
        if (target==null)   return null;

        File f = new File(target);
        if (f.isAbsolute()) return f;   // absolute symlink
        return new File(link.getParentFile(),target);   // relative symlink
    }
310958
String resolveSymbolicString(String symbolicPath) {
        if (symbolicPath == null)
            throw new NullPointerException("Path must be non-null");

        return resolveStringSymbols(symbolicPath, symbolicPath, true, 0, true);
    }
1040746
static String resolveArgument(String[] args) {
    return Optional.ofNullable(args).map(ArrayUtils::getFirst).filter(StringUtils::hasText)
      .orElseThrow(() -> newIllegalArgumentException("Directory is required"));
  }
537680
public void finalizeDisc(File isoPath) {
        ISOImageFileHandler handler = null;
        try {
            handler = new ISOImageFileHandler(isoPath);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
        try {
            CreateISO iso = new CreateISO(handler, root);
            try {
                iso.process(iso9660config, rockConfig, jolietConfig, elToritoConfig);

            } catch (HandlerException e) {
                e.printStackTrace();
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }
54196
public static String resolveTitle(final String title, final String reference) {
        if (StringUtils.isBlank(title) && !StringUtils.isBlank(reference)) {
            // If there is no title, assume the reference is a path and take the last part (the "file name")
            final String[] splitReference = PATH_SEPARATOR_REGEX.split(reference);
            final String lastPart = splitReference[splitReference.length - 1];

            return StringUtils.isBlank(lastPart) || reference.endsWith("/") || reference.endsWith("\\") ? reference : lastPart;
        } else {
            return title;
        }
    }
90595
private String resolveString(String s) {

		int pos = s.indexOf(":", 0);

		if (pos == -1)
			return System.getProperty(s);

		String key = s.substring(0, pos);
		String defval = s.substring(pos + 1);

		String val = System.getProperty(key);

		if (val != null)
			return val;
		else
			return defval;
	}
1352451
def resolve(self, path, strict):
        """"""
        if self.filesystem.is_windows_fs:
            return self._resolve_windows(path, strict)
        return self._resolve_posix(path, strict)
620218
public static String resolve( String base, String child )
	{
		String childPath = child.startsWith( "/" ) ? child.substring( 1 ) : child;
		String basePath = base.endsWith( "/" ) ? base : base + "/";
		return basePath + childPath;
	}
1039813
public static String resolve(String uriInitial, String uriString) {
        try {
            return uriToString((new URI(uriInitial)).resolve(uriString));
        }
        catch (URISyntaxException e) {
            try {
                return (new NetworkInterfaceURI(uriInitial)).resolve(uriString);
            }
            catch (IllegalArgumentException ne) {
                throw new IllegalArgumentException(ne.getMessage(), ne);
            }
        }
    }
25331
@Override
    public boolean accept(File pathname) {

        boolean accepted = super.accept(pathname);
        if (accepted) {
            final File parentDir = pathname.getParentFile();
            accepted = parentDir != null && parentDir.getName().equals(SPECIFICATIONS);
        }

        return accepted;
    }
483885
private String resolvePathVariables(String inputPath) {
        if (PathUtil.containsSymbol(inputPath)) {
            return locationService.resolveString(inputPath);
        } else {
            return inputPath;
        }
    }
1296542
public void resolveType() {
        if (getTypeStyle() == null) {
            setTypeStyle("");
        }
        final String fieldType = getFieldType();
        String generics = "";
        if (fieldType.contains("<")) {
            generics = fieldType.substring(fieldType.indexOf('<'));
        }
        if (getTypeStyle().equals("smart")) {
            setType(fieldType);
        } else if (getTypeStyle().length() > 0) {
            if (getTypeStyle().contains("<>")) {
                setType(getTypeStyle().replace("<>", generics));
            } else if (getTypeStyle().contains("<")) {
                setType(getTypeStyle());
            } else {
                setType(getTypeStyle() + generics);
            }
        } else {
            setType(fieldType);
        }
    }
1153240
@Override
    public InputSource resolveEntity(String publicId, String systemId) throws SAXException {
        if (validating) {
            try {
                InputSource source = null;
                if (publicId != null) {
                    String path = doctypeMap.get(publicId.toUpperCase());
                    source = getInputSource(path);
                }
                if (source == null && systemId != null) {
                    String path = doctypeMap.get(systemId.toUpperCase());
                    source = getInputSource(path);
                }
                return source;
            } catch (Exception e) {
                throw new SAXException(e.toString());
            }
        } else {
            return new InputSource(new StringReader(""));
        }
    }
479225
private Collection<Import> resolveImport(Path path) throws IOException, URISyntaxException {
		URL resource = resolveResource(path);

		if (null == resource) {
			return null;
		}

		// calculate a webapp absolute URI
		final URI uri = new URI(
			Paths.get("/").resolve(
				Paths.get(getServletContext().getResource("/").toURI()).relativize(Paths.get(resource.toURI()))
			).toString()
		);
		final String source = IOUtils.toString(resource, StandardCharsets.UTF_8);

		final Import scssImport = new Import(uri, uri, source);
		return Collections.singleton(scssImport);
	}
1254584
public void resolve(@Nullable View view, @NonNull HttpRequest request, @NonNull HttpResponse response) {
        if (view == null) return;

        Object output = view.output();
        if (output == null) return;

        if (view.rest()) {
            resolveRest(output, request, response);
        } else {
            resolvePath(output, request, response);
        }
    }
1332351
public static Path findWithEnding(Path basePath, String... endings) {
        for (String ending : endings) {
            Path newPath = basePath.resolveSibling(basePath.getFileName() + ending);
            if (Files.exists(newPath)) {
                return newPath;
            }
        }

        return null;
    }