Given a {@code String} path, returns an equivalent Alluxio path.

@param path the path to parse
@return a valid Alluxio path
487097
public static String getAlluxioFileName(String path) {
    if (path.isEmpty()) {
      return AlluxioURI.SEPARATOR;
    }

    while (path.contains(":")) {
      int index = path.indexOf(":");
      path = path.substring(index + 1);
    }

    while (!path.startsWith(AlluxioURI.SEPARATOR)) {
      path = path.substring(1);
    }

    return path;
  }
199215
static public List<String> interpretPath(String path) throws Exception {
		if( null == path ) {
			throw new Exception("path parameter should not be null");
		}
		if( path.codePointAt(0) == '/' ) {
			throw new Exception("absolute path is not acceptable");
		}

		// Verify path
		List<String> pathFragments = new Vector<String>();
		{
			String[] pathFrags = path.split("/");
			for(String pathFrag : pathFrags){
				if( ".".equals(pathFrag) ){
					// ignore
				} else if( "..".equals(pathFrag) ){
					throw new Exception("Parent references (..) not allowed");
				} else if( "".equals(pathFrag) ){
					// ignore
				} else {
					pathFragments.add(pathFrag);
				}
			}
		}
		
		return pathFragments;
	}
1082372
public static final String posixString(Path path)
    {
        String prefix = path.isAbsolute() ? "/" : "";
        String suffix = Files.isDirectory(path) ? "/" : "";
        return StreamSupport.stream(path.spliterator(), false)
                .map((p)->p.toString())
                .collect(Collectors.joining("/", prefix, suffix));
    }
386829
public AlluxioConfiguration getPathConf(AlluxioURI path) {
    return new SpecificPathConfiguration(mClientContext.getConf(), mClientContext.getPathConf(),
        path);
  }
372603
public static final String normalizePath(String path) {
		String normalizedPath = path.replaceAll("//", JawrConstant.URL_SEPARATOR);
		StringTokenizer tk = new StringTokenizer(normalizedPath, JawrConstant.URL_SEPARATOR);
		StringBuilder sb = new StringBuilder();
		while (tk.hasMoreTokens()) {
			sb.append(tk.nextToken());
			if (tk.hasMoreTokens())
				sb.append(JawrConstant.URL_SEPARATOR);
		}
		return sb.toString();

	}
989737
public Set<String> getResourcePaths(String path) {

		Set<String> result = new HashSet<String>();
		path = path.replace('/', File.separatorChar);
		File resource = new File(baseDir, path);

		// If the path is not valid throw an exception
		String[] resArray = resource.list();
		if (null == resArray)
			return result;

		// Make the returned dirs end with '/', to match a servletcontext
		// behavior.
		for (int i = 0; i < resArray.length; i++) {

			resArray[i] = path + resArray[i];
			if (isDirectory(resArray[i]))
				resArray[i] += '/';
		}
		result.addAll(Arrays.asList(resArray));

		return result;
	}
653965
public AbstractCharSequenceAssert<?, String> jsonPathAsString(String path) {
        return Assertions.assertThat(actual.read(path, String.class));
    }
868217
@Override
	public boolean matchPath(String path) {

		boolean match = false;
		if (StringUtils.isNotEmpty(path)) {
			match = path.startsWith(prefix);
		}
		return match;
	}
749343
public static String decodePath(String path) {
        URI tmp;

        try {
            tmp = new URI("scheme://host/" + path);
        } catch (URISyntaxException e) {
            throw new IllegalStateException(e);
        }
        return tmp.getPath().substring(1);
    }
1142076
private static String getTrimmedPath(String path) {
        String result = path;
        if (result.endsWith("/")) {
            result = result.substring(0, result.length() - 1);
        }
        return result;
    }
527728
public HttpMessage path(final String path) {
        header(HttpMessageHeaders.HTTP_REQUEST_URI, path);
        header(DynamicEndpointUriResolver.REQUEST_PATH_HEADER_NAME, path);
        return this;
    }
1005447
private List<String> splitPath(String path) {

        List<String> result = new ArrayList<String>();
        for (String token : path.split("/")) {
            if ("".equals(token)) {
                continue;
            }
            result.add(token);
        }
        return result;
    }
1188948
public static List<String> parsePath(String pPath) {
        // Special cases which simply implies 'no path'
        if (pPath == null || pPath.equals("") || pPath.equals("/")) {
            return null;
        }
        return replaceWildcardsWithNull(split(pPath, PATH_ESCAPE, "/"));
    }
1374473
public String getAlias(String path)
    {
        if (m_allPathsAliased && m_attributePath.lastIndexOf(path) != -1)
        {
            return m_name;
        }
        Object retObj = m_mapping.get(path);
        if (retObj != null)
        {
            return (String) retObj;
        }
        return null;
    }
594347
private static Path qualified(Path rootPath, Path path) {
        URI rootUri = rootPath.toUri();
        return path.makeQualified(rootUri, new Path(rootUri.getPath()));
    }
48714
@SuppressWarnings("unchecked")
  public <T> T get(String... path) {
    ExtensionAware root = searchRoot;
    for (String name : path) {
      ExtensionContainer children = root.getExtensions();
      root = (ExtensionAware) children.getByName(name);
    }
    return (T) root; // this is potentially unchecked.
  }
964938
public static List<String> split(String path)
    {
        PathUtils.validatePath(path);
        return PATH_SPLITTER.splitToList(path);
    }