public FilterFileSystem(FileSystem fs) 
{
    this.fs = fs;
}

 protected  void checkPath(Path path) 
{
    fs.checkPath(path);
}

Check that a Path belongs to this FileSystem.

 public  void close() throws IOException 
{
    super.close();
    fs.close();
}

 public  void completeLocalOutput(Path fsOutputFile,
    Path tmpLocalFile) throws IOException 
{
    fs.completeLocalOutput(fsOutputFile, tmpLocalFile);
}

Called when we're all done writing to the target. A local FS will do nothing, because we've written to exactly the right place. A remote FS will copy the contents of tmpLocalFile to the correct target at fsOutputFile.

 public  void copyFromLocalFile(boolean delSrc,
    Path src,
    Path dst) throws IOException 
{
    fs.copyFromLocalFile(delSrc, src, dst);
}

The src file is on the local disk. Add it to FS at the given dst name. delSrc indicates if the source should be removed

 public  void copyToLocalFile(boolean delSrc,
    Path src,
    Path dst) throws IOException 
{
    fs.copyToLocalFile(delSrc, src, dst);
}

The src file is under FS, and the dst is on the local disk. Copy it from FS control to the local dst name. delSrc indicates if the src will be removed or not.

 public FSDataOutputStream create(Path f,
    boolean overwrite,
    int bufferSize,
    short replication,
    long blockSize,
    Progressable progress) throws IOException 
{
    return fs.create(f, overwrite, bufferSize, replication, blockSize, progress);
}

Opens an FSDataOutputStream at the indicated Path with write-progress reporting.

 public boolean delete(Path f) throws IOException 
{
    return fs.delete(f);
}

Delete a file

 public boolean exists(Path f) throws IOException 
{
    return fs.exists(f);
}

Check if exists.

 public Configuration getConf() 
{
    return fs.getConf();
}

 public long getDefaultBlockSize() 
{
    return fs.getDefaultBlockSize();
}

Return the number of bytes that large input files should be optimally be split into to minimize i/o time.

 public short getDefaultReplication() 
{
    return fs.getDefaultReplication();
}

Get the default replication.

 public String[][] getFileCacheHints(Path f,
    long start,
    long len) throws IOException 
{
    return fs.getFileCacheHints(f, start, len);
}

Return a 2D array of size 1x1 or greater, containing hostnames where portions of the given file can be found. For a nonexistent file or regions, null will be returned. This call is most helpful with DFS, where it returns hostnames of machines that contain the given file. The FileSystem will simply return an elt containing 'localhost'.

 public FileStatus getFileStatus(Path f) throws IOException 
{
    return fs.getFileStatus(f);
}

Get file status.

 public String getName() 
{
    return fs.getName();
}

 public URI getUri() 
{
    return fs.getUri();
}

Returns a URI whose scheme and authority identify this FileSystem.

 public Path getWorkingDirectory() 
{
    return fs.getWorkingDirectory();
}

Get the current working directory for the given file system

 public  void initialize(URI name,
    Configuration conf) throws IOException 
{
    fs.initialize(name, conf);
}

Called after a new FileSystem instance is constructed.

 public Path[] listPaths(Path f) throws IOException 
{
    return fs.listPaths(f);
}

List files in a directory.

 public  void lock(Path f,
    boolean shared) throws IOException 
{
    fs.lock(f, shared);
}

Obtain a lock on the given Path

 public Path makeQualified(Path path) 
{
    return fs.makeQualified(path);
}

Make sure that a path specifies a FileSystem.

 public boolean mkdirs(Path f) throws IOException 
{
    return fs.mkdirs(f);
}

Make the given file and all non-existent parents into directories. Has the semantics of Unix 'mkdir -p'. Existence of the directory hierarchy is not an error.

 public FSDataInputStream open(Path f,
    int bufferSize) throws IOException 
{
    return fs.open(f, bufferSize);
}

Opens an FSDataInputStream at the indicated Path.

 public  void release(Path f) throws IOException 
{
    fs.release(f);
}

Release the lock

 public boolean rename(Path src,
    Path dst) throws IOException 
{
    return fs.rename(src, dst);
}

Renames Path src to Path dst. Can take place on local fs or remote DFS.

 public boolean setReplication(Path src,
    short replication) throws IOException 
{
    return fs.setReplication(src, replication);
}

Set replication for an existing file.

 public  void setWorkingDirectory(Path newDir) 
{
    fs.setWorkingDirectory(newDir);
}

Set the current working directory for the given file system. All relative paths will be resolved relative to it.

 public Path startLocalOutput(Path fsOutputFile,
    Path tmpLocalFile) throws IOException 
{
    return fs.startLocalOutput(fsOutputFile, tmpLocalFile);
}

Returns a local File that the user can write output to. The caller provides both the eventual FS target name and the local working file. If the FS is local, we write directly into the target. If the FS is remote, we write into the tmp local area.