<pre>
* the destination path
</pre>

<code>optional string dstPath = 2;</code>
327603
public java.lang.String getDstPath() {
    java.lang.Object ref = dstPath_;
    if (ref instanceof java.lang.String) {
      return (java.lang.String) ref;
    } else {
      com.google.protobuf.ByteString bs = 
          (com.google.protobuf.ByteString) ref;
      java.lang.String s = bs.toStringUtf8();
      if (bs.isValidUtf8()) {
        dstPath_ = s;
      }
      return s;
    }
  }
885845
@SuppressWarnings("unchecked")
  public String path(T target, Object... params) {
    if (params.length == 0) return path(target, Collections.emptyMap());

    if (params.length == 1 && params[0] instanceof Map<?, ?>) return pathMap(target, (Map<Object, Object>) params[0]);

    if (params.length % 2 == 1) throw new RuntimeException("Missing value for param: " + params[params.length - 1]);

    final Map<Object, Object> map = new HashMap<Object, Object>();
    for (int i = 0; i < params.length; i += 2) {
      final String key   = params[i].toString();
      final String value = params[i + 1].toString();
      map.put(key, value);
    }
    return pathMap(target, map);
  }
529184
public static String decodePath(String path, int offset, int length) {
        try {
            Utf8StringBuilder builder = null;
            int end = offset + length;
            for (int i = offset; i < end; i++) {
                char c = path.charAt(i);
                switch (c) {
                    case '%':
                        if (builder == null) {
                            builder = new Utf8StringBuilder(path.length());
                            builder.append(path, offset, i - offset);
                        }
                        if ((i + 2) < end) {
                            char u = path.charAt(i + 1);
                            if (u == 'u') {
                                // TODO this is wrong. This is a codepoint not a char
                                builder.append((char) (0xffff & TypeUtils.parseInt(path, i + 2, 4, 16)));
                                i += 5;
                            } else {
                                builder.append((byte) (0xff & (TypeUtils.convertHexDigit(u) * 16 + TypeUtils.convertHexDigit(path.charAt(i + 2)))));
                                i += 2;
                            }
                        } else {
                            throw new IllegalArgumentException("Bad URI % encoding");
                        }

                        break;

                    case ';':
                        if (builder == null) {
                            builder = new Utf8StringBuilder(path.length());
                            builder.append(path, offset, i - offset);
                        }

                        while (++i < end) {
                            if (path.charAt(i) == '/') {
                                builder.append('/');
                                break;
                            }
                        }

                        break;

                    default:
                        if (builder != null)
                            builder.append(c);
                        break;
                }
            }

            if (builder != null)
                return builder.toString();
            if (offset == 0 && length == path.length())
                return path;
            return path.substring(offset, end);
        } catch (NotUtf8Exception e) {
            System.err.println(path.substring(offset, offset + length) + " " + e);
            return decodeISO88591Path(path, offset, length);
        }
    }
635425
public static String path(String path, int offset, int length) {
        try {
            Utf8StringBuilder builder = null;
            int end = offset + length;
            for (int i = offset; i < end; i++) {
                char c = path.charAt(i);
                switch (c) {
                    case '%':
                        if (builder == null) {
                            builder = new Utf8StringBuilder(path.length());
                            builder.append(path, offset, i - offset);
                        }
                        if ((i + 2) < end) {
                            char u = path.charAt(i + 1);
                            if (u == 'u') {
                                // TODO this is wrong. This is a codepoint not a char
                                builder.append((char) (0xffff & TypeUtil.parseInt(path, i + 2, 4, 16)));
                                i += 5;
                            } else {
                                builder.append((byte) (0xff & (TypeUtil.convertHexDigit(u) * 16
                                    + TypeUtil.convertHexDigit(path.charAt(i + 2)))));
                                i += 2;
                            }
                        } else {
                            throw new IllegalArgumentException("Bad URI % encoding");
                        }

                        break;

                    case ';':
                        if (builder == null) {
                            builder = new Utf8StringBuilder(path.length());
                            builder.append(path, offset, i - offset);
                        }

                        while (++i < end) {
                            if (path.charAt(i) == '/') {
                                builder.append('/');
                                break;
                            }
                        }

                        break;

                    default:
                        if (builder != null) {
                            builder.append(c);
                        }
                        break;
                }
            }

            if (builder != null) {
                return builder.toString();
            }
            if (offset == 0 && length == path.length()) {
                return path;
            }
            return path.substring(offset, end);
        } catch (Utf8Appendable.NotUtf8Exception e) {
            return decodeISO88591Path(path, offset, length);
        }
    }
654576
public static String pathElement(final int index,
                                   final String path) {
    final String[] paths = path.split("/");

    int idx = index;

    if ((paths[0] == null) || (paths[0].length() == 0)) {
      // skip empty first part - leading "/"
      idx++;
    }

    if (idx >= paths.length) {
      return null;
    }

    return paths[idx];
  }
174333
@Override
  public PathImpl schemeWalk(String userPath,
                         Map<String,Object> attributes,
                         String filePath,
                         int offset)
  {
    int p = filePath.indexOf('!', offset);
    String backingPath;
    String jarPath;

    if (p > 0) {
      backingPath = filePath.substring(offset, p);
      jarPath = filePath.substring(p + 1);
    }
    else {
      backingPath = filePath.substring(offset);
      jarPath = "";
    }

    PathImpl backing = VfsOld.lookup(backingPath);

    return JarPath.create(backing).lookup(jarPath);
  }
539323
@StompService(destination = "/destination-2")
    public String destination2(final String body) throws IOException {
        final String now = new SimpleDateFormat("HH:mm:ss").format(new Date());
        return String.format("%s - value '%s' returned from method mapped to /destination-2", now, body);
    }
1147370
@javax.annotation.Nonnull
    public java.util.Optional<String> optionalFilePath() {
        return java.util.Optional.ofNullable(mFilePath);
    }
294832
public Optional<Map<String,String>> values(String path) {
		Map<String,String> result = paths.get(path);
		if (result == null) {
			return Optional.empty();
		}
		return Optional.of(Collections.unmodifiableMap(result));
	}
172574
public static String getCurrentAbsolutPathWithoutDotAndSlash()
	{
		final File currentAbsolutPath = new File(".");
		return currentAbsolutPath.getAbsolutePath().substring(0,
			currentAbsolutPath.getAbsolutePath().length() - 2);
	}
493863
static String path2absoluteSlashSeparatedString(final Path path) {
        final String pathAsAStringBefore = path.toString();
        String pathAsAStringAfter = pathAsAStringBefore;
        String separator = FileSystems.getDefault().getSeparator();
        if ( pathAsAStringAfter != null
             &&
             ( pathAsAStringAfter.length() == 0
               ||
               !(
                  pathAsAStringAfter.startsWith("\\") ||
                  pathAsAStringAfter.startsWith("/")
               )
             )
           ) {
            pathAsAStringAfter = separator + pathAsAStringAfter;
        }
        // why M$ Windows ? why ?
        if (separator.equals("\\")) {
            pathAsAStringAfter = pathAsAStringAfter.replaceAll("\\\\", "/");
        }

        if (pathAsAStringBefore.equals(pathAsAStringAfter)) {
            log.trace("Path parameter '{}' transformed to '{}'", pathAsAStringBefore, pathAsAStringAfter);
        }

        return pathAsAStringAfter;
    }
767027
public static String createFolderPath(String path) {

        String[] pathParts = path.split("\\.");
        String path2 = "";
        for (String part : pathParts) {
            if (path2.equals("")) {
                path2 = part;
            } else {
                path2 = path2 + File.separator
                        + changeFirstLetterToLowerCase(createClassName(part));
            }
        }

        return path2;
    }
113640
@Override
  public PathImpl schemeWalk(String userPath,
                         Map<String,Object> attributes,
                         String filePath,
                         int offset)
  {
    if (! isWindows()) {
      return super.schemeWalk(userPath, attributes, filePath, offset);
    }

    String canonicalPath;

    if (filePath.length() < offset + 2) {
      return super.schemeWalk(userPath, attributes, filePath, offset);
    }

    char ch1 = filePath.charAt(offset + 1);
    char ch2 = filePath.charAt(offset);

    if ((ch2 == '/' || ch2 == _separatorChar)
        && (ch1 == '/' || ch1 == _separatorChar))
      return super.schemeWalk(userPath, attributes,
                              convertFromWindowsPath(filePath.substring(offset)), 0);
    else
      return super.schemeWalk(userPath, attributes, filePath, offset);
  }
483885
private String resolvePathVariables(String inputPath) {
        if (PathUtil.containsSymbol(inputPath)) {
            return locationService.resolveString(inputPath);
        } else {
            return inputPath;
        }
    }
199905
public PactDslRequestWithPath path(String path) {
        return new PactDslRequestWithPath(consumerPactBuilder, consumerName, providerName, pactDslWithState.state,
          description, path, requestMethod, requestHeaders, query, requestBody, requestMatchers, requestGenerators,
          defaultRequestValues, defaultResponseValues);
    }
665046
public Optional<Path> getPath(String key) {
        Optional<String> property = getString(key);
        if (property.isPresent()) {
            return Optional.of(Paths.get(property.get()));
        } else {
            return Optional.empty();
        }
    }
329928
public static Path copy(Path sourcePath, Path destinationPath,
            CopyOption... options) {
        return operate(sourcePath, destinationPath, "copy", finalPath -> {
            try {
                return Files.copy(sourcePath, finalPath, options);
            } catch (Exception e) {
                return JMExceptionManager.handleExceptionAndReturnNull(log, e,
                        "copy", sourcePath, destinationPath, options);
            }
        });
    }