public Path(String pathString) 
{
    checkPathArg( pathString );
    // We can't use 'new URI(String)' directly, since it assumes things are
    // escaped, which we don't require of Paths. 
    // add a slash in front of paths with Windows drive letters
    if (hasWindowsDrive(pathString, false))
      pathString = "/"+pathString;
    // parse uri components
    String scheme = null;
    String authority = null;
    int start = 0;
    // parse uri scheme, if any
    int colon = pathString.indexOf(':");
    int slash = pathString.indexOf('/");
    if ((colon != -1) &&
        ((slash == -1) || (colon <  slash))) {     // has a scheme
      scheme = pathString.substring(0, colon);
      start = colon+1;
    }
    // parse uri authority, if any
    if (pathString.startsWith("//", start) &&
        (pathString.length()-start  > 2)) {       // has authority
      int nextSlash = pathString.indexOf('/", start+2);
      int authEnd = nextSlash  > 0 ? nextSlash : pathString.length();
      authority = pathString.substring(start+2, authEnd);
      start = authEnd;
    }
    // uri path is the rest of the string -- query & fragment not supported
    String path = pathString.substring(start, pathString.length());
    initialize(scheme, authority, path);
}

Construct a path from a String. Path strings are URIs, but with unescaped elements and some additional normalization.

 public Path(String parent,
    String child) 
{
                                // a hierarchical uri
    this(new Path(parent), new Path(child));
}

Resolve a child path against a parent path.

 public Path(Path parent,
    String child) 
{
    this(parent, new Path(child));
}

Resolve a child path against a parent path.

 public Path(String parent,
    Path child) 
{
    this(new Path(parent), child);
}

Resolve a child path against a parent path.

 public Path(Path parent,
    Path child) 
{
    // Add a slash to parent's path so resolution is compatible with URI's
    URI parentUri = parent.uri;
    String parentPath = parentUri.getPath();
    if (!(parentPath.equals("/") || parentPath.equals("")))
      try {
        parentUri = new URI(parentUri.getScheme(), parentUri.getAuthority(),
                            parentUri.getPath()+"/", null, null);
      } catch (URISyntaxException e) {
        throw new IllegalArgumentException(e);
      }
    URI resolved = parentUri.resolve(child.uri);
    initialize(resolved.getScheme(), resolved.getAuthority(),
               normalizePath(resolved.getPath()));
}

Resolve a child path against a parent path.

 public Path(String scheme,
    String authority,
    String path) 
{
    checkPathArg( path );
    initialize(scheme, authority, path);
}

Construct a Path from components.

 public int compareTo(Object o) 
{
    Path that = (Path)o;
    return this.uri.compareTo(that.uri);
}

 public int depth() 
{
    String path = uri.getPath();
    int depth = 0;
    int slash = path.length()==1 && path.charAt(0)=='/" ? -1 : 0;
    while (slash != -1) {
      depth++;
      slash = path.indexOf(SEPARATOR, slash+1);
    }
    return depth;
}

Return the number of elements in this path.

 public boolean equals(Object o) 
{
    if (!(o instanceof Path)) {
      return false;
    }
    Path that = (Path)o;
    return this.uri.equals(that.uri);
}

 public FileSystem getFileSystem(Configuration conf) throws IOException 
{
    return FileSystem.get(this.toUri(), conf);
}

Return the FileSystem that owns this Path.

 public String getName() 
{
    String path = uri.getPath();
    int slash = path.lastIndexOf(SEPARATOR);
    return path.substring(slash+1);
}

Returns the final component of this path.

 public Path getParent() 
{
    String path = uri.getPath();
    int lastSlash = path.lastIndexOf('/");
    int start = hasWindowsDrive(path, true) ? 3 : 0;
    if ((path.length() == start) ||               // empty path
        (lastSlash == start && path.length() == start+1)) { // at root
      return null;
    }
    String parent;
    if (lastSlash==-1) {
      parent = CUR_DIR;
    } else {
      int end = hasWindowsDrive(path, true) ? 3 : 0;
      parent = path.substring(0, lastSlash==end?end+1:lastSlash);
    }
    return new Path(uri.getScheme(), uri.getAuthority(), parent);
}

Returns the parent of a path or null if at root.

 public int hashCode() 
{
    return uri.hashCode();
}

 public boolean isAbsolute() 
{
    int start = hasWindowsDrive(uri.getPath(), true) ? 3 : 0;
    return uri.getPath().startsWith(SEPARATOR, start);
}

True if the directory of this path is absolute.

 public Path makeQualified(FileSystem fs) 
{
    Path path = this;
    if (!isAbsolute()) {
      path = new Path(fs.getWorkingDirectory(), this);
    }
    URI pathUri = path.toUri();
    URI fsUri = fs.getUri();
    String scheme = pathUri.getScheme();
    String authority = pathUri.getAuthority();
    if (scheme != null &&
        (authority != null || fsUri.getAuthority() == null))
      return path;
    if (scheme == null) {
      scheme = fsUri.getScheme();
    }
    if (authority == null) {
      authority = fsUri.getAuthority();
      if (authority == null) {
        authority = "";
      }
    }
    return new Path(scheme+":"+"//"+authority + pathUri.getPath());
}

Returns a qualified path object.

 public Path suffix(String suffix) 
{
    return new Path(getParent(), getName()+suffix);
}

Adds a suffix to the final name in the path.

 public String toString() 
{
    // we can't use uri.toString(), which escapes everything, because we want
    // illegal characters unescaped in the string, for glob processing, etc.
    StringBuffer buffer = new StringBuffer();
    if (uri.getScheme() != null) {
      buffer.append(uri.getScheme());
      buffer.append(":");
    }
    if (uri.getAuthority() != null) {
      buffer.append("//");
      buffer.append(uri.getAuthority());
    }
    if (uri.getPath() != null) {
      String path = uri.getPath();
      if (path.indexOf('/")==0 &&
          hasWindowsDrive(path, true) &&          // has windows drive
          uri.getScheme() == null &&              // but no scheme
          uri.getAuthority() == null)             // or authority
        path = path.substring(1);                 // remove slash before drive
      buffer.append(path);
    }
    return buffer.toString();
}

 public URI toUri() 
{
 return uri;
}

Convert this to a URI.