Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright 1&1 Internet AG, http://www.1and1.org
   *
   * This program is free software; you can redistribute it and/or modify
   * it under the terms of the GNU Lesser General Public License as published by
   * the Free Software Foundation; either version 2 of the License,
   * or (at your option) any later version.
   *
   * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  * See the GNU Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 package net.sf.beezle.sushi.fs.file;
 
 
 import java.io.File;
 import java.net.URI;
 import java.util.List;

File, directory, symlink or something not yet created. Replacement for java.world.File.

 
 public class FileNode extends Node {
     private final FileRoot root;

    
never null and always absolute.
 
     private final File file;
 
     public FileNode(FileRoot rootFile file) {
         if (!file.isAbsolute()) {
             throw new IllegalArgumentException(file.toString());
         }
         if (file.getPath().endsWith(.) && file.getParent() != null) {
             throw new IllegalArgumentException("should not happen because java.world.File normalizes paths: " + file.getPath());
         }
         this. = root;
         this. = file;
     }
 
     @Override
     public FileRoot getRoot() {
         return ;
     }
 
     @Override
     public FileNode getParent() {
         return (FileNodedoGetParent();
     }
 
     @Override
     public FileNode join(String ... paths) {
         return (FileNodedoJoin(paths);
     }
 
     @Override
     public FileNode join(List<Stringpaths) {
         return (FileNodedoJoin(paths);
     }
 
     @Override
     public URI getURI() {
         return .toURI();
     }

    
Avoid calling this method, should be used to interact with 'legacy' code only
 
     public File getFile() {
         return ;
     }
    @Override
    public String getPath() {
        return .getPath().substring(getRoot().getId().length());
    }
    public String getAbsolute() {
        return .getAbsolutePath();
    }
    //--
    @Override
    public boolean exists() {
        return .exists() || isNoneExistingBrokenLink();
    }
    @Override
    public boolean isFile() {
        return .isFile();
    }
    @Override
    public boolean isDirectory() {
        return .isDirectory();
    }
    public boolean canWrite() {
        return .canWrite();
    }
    public boolean canRead() {
        return .canRead();
    }
    //--
    public ZipNode openZip() throws IOException {
        return ((ZipFilesystemgetWorld().getFilesystem("zip")).node(this"");
    }
    public ZipNode openJar() throws IOException {
        return ((ZipFilesystemgetWorld().getFilesystem("jar")).node(this"");
    }

    

Returns:
dest
    public Node unzip(Node destthrows IOException {
        openZip().copyDirectory(dest);
        return this;
    }
    public Node unjar(Node destthrows IOException {
        openJar().copyDirectory(dest);
        return this;
    }
    @Override
    public long length() throws LengthException {
        if (!.isFile()) {
            throw new LengthException(thisnew IOException("file expected"));
        }
        return .length();
    }
    @Override
    public long getLastModified() throws GetLastModifiedException {
        long result;
        result = .lastModified();
        if (result == 0 && !exists()) {
            throw new GetLastModifiedException(thisnew ExistsException(thisnull));
        }
        return result;
    }
    @Override
    public void setLastModified(long timethrows SetLastModifiedException {
        if (!.setLastModified(time)) {
            throw new SetLastModifiedException(this);
        }
    }
    //-- locating


    

Returns:
null when called for a file; non-null otherwise
    @Override
    public List<FileNodelist() throws ListException {
        File[] children;
        List<FileNoderesult;
        children = .listFiles();
        if (children == null) {
            if (!.exists()) {
                throw new ListException(thisnew FileNotFoundException(getPath()));
            }
            if (!.canRead()) {
                try {
                    if (isLink()) {
                        // TODO: check link target
                        throw new ListException(thisnew IOException("broken link"));
                    }
                } catch (IOException e) {
                    // fall through
                }
                throw new ListException(thisnew IOException("permission denied"));
            } else {
                return null;
            }
        }
        result = new ArrayList<FileNode>(children.length);
        for (File child : children) {
            result.add(new FileNode(child));
        }
        return result;
    }
    //-- read and writeBytes
    @Override
    public FileInputStream createInputStream() throws IOException {
        return new FileInputStream();
    }
    @Override
    public FileOutputStream createOutputStream(boolean appendthrows IOException {
        return new FileOutputStream(append);
    }
    //-- create

    
calls createNewFile
    @Override
    public FileNode mkfile() throws MkfileException {
    	try {
			if (!.createNewFile()) {
			    throw new MkfileException(this);
			}
catch (IOException e) {
			throw new MkfileException(thise);
		}
        return this;
    }
    @Override
    public FileNode mkdir() throws MkdirException {
        if (!.mkdir()) {
            throw new MkdirException(this);
        }
        return this;
    }
    @Override
    public void mklink(String targetthrows LinkException {
        FileNode parent;
        try {
            checkNotExists();
            parent = getParent();
            parent.checkDirectory();
            new Program(parent"ln""-s"targetgetName()).execNoOutput();
        } catch (IOException e) {
            throw new LinkException(thise);
        }
    }
    @Override
    public String readLink() throws ReadLinkException {
    	try {
		    return getWorld().getTemp().exec("readlink".getAbsolutePath()).trim();
catch (IOException e) {
			throw new ReadLinkException(thise);
		}
    }
    @Override
    public boolean isLink() throws ExistsException {
    	try {
    		return isLink();
    	} catch (IOException e) {
    		throw new ExistsException(thise);
    	}
    }
    private static boolean isLink(File filethrows IOException {
        String name;
        File parent;
        File canonical;
        name = file.getName();
        parent = file.getAbsoluteFile().getParentFile();
        if (parent == null) {
            // file is the root directory
            return false;
        }
        canonical = new File(parent.getCanonicalPath(), name);
        return !canonical.getAbsolutePath().equals(canonical.getCanonicalPath()) ||  isBrokenLink(file);
    }
    private static boolean isBrokenLink(File link) {
    	return link.exists() ? false : isNoneExistingBrokenLink(link);
    }
    private static boolean isNoneExistingBrokenLink(File link) {
        FilenameFilter filter;
        final String expected;
        File parent;
        parent = link.getParentFile();
        if (!parent.isDirectory()) {
            return false;
        }
    	expected = link.getName();
    	filter = new FilenameFilter() {
			public boolean accept(File dirString name) {
				return name.equals(expected);
			}
    	};
    	return parent.listFiles(filter).length == 1;
    }
    //-- move

    

Returns:
dest
    @Override
    public FileNode move(Node destNodethrows MoveException {
    	FileNode dest;
        Program p;
        String output;
        if (!(destNode instanceof FileNode)) {
        	throw new MoveException(thisdestNode"cannot move to none-file-node");
        }
        dest = (FileNodedestNode;
      	try {
      		dest.checkNotExists();
      	} catch (IOException e) {
      		throw new MoveException(thisdest"dest exists"e);
      	}
        if (getWorld(). == .) {
            p = new Program(dest.getParent(), "cmd""/C""move");
        } else {
            p = new Program(dest.getParent(), "mv");
        }
        p.add(getAbsolute(), dest.getName());
        try {
			output = p.exec();
catch (IOException e) {
			throw new MoveException(thisdest"os command failed"e);
		}
        if (output.length() > 0 && getWorld(). != .) {
            throw new MoveException(thisdest"unexpected output: " + output);
        }
        return dest;
    }
    //-- rename
    public void rename(FileNode targetthrows IOException {
        if (target.exists()) {
            throw new IOException("target exists: " + target);
        }
        rename(target.file);
    }
    private static void rename(File srcFile targetthrows IOException {
        if (!src.exists()) {
            throw new FileNotFoundException("" + src);
        }
        // the target may exist, it will be overwritten!
        File parent = target.getAbsoluteFile().getParentFile();
        if (parent != null && !parent.isDirectory()) {
            throw new IOException("not a directory: " + parent);
        }
        if (!src.renameTo(target)) {
            throw new IOException("Failed to rename " + src + " to " + target);
        }
    }
    //-- delete

    
Deletes a file or directory. Directories are deleted recursively. Handles Links.

Throws:
java.io.IOException if a file cannot be deleted
    @Override
    public FileNode delete() throws DeleteException {
        try {
            delete(getWorld(), );
        } catch (IOException e) {
            throw new DeleteException(thise);
        }
        return this;
    }
    protected static void delete(World worldFile filethrows IOException {
        File[] files;
        if (isLink(file)) {
            deleteLink(worldfile);
            return;
        }
        files = file.listFiles();
        if (files != null) {
            for (File child : files) {
                delete(worldchild);
            }
        } else {
            // not a directory
        }
        if (!file.delete()) {
            throw new FileNotFoundException("cannot delete file " + file);
        }
    }
    private static void deleteLink(World ioFile linkthrows IOException {
        File target// where the link point to
        File dir;
        File renamed;
        boolean wasDeleted;
        if (!link.exists()) {
        	// broken link
        	new Program(io.getTemp(), "rm"link.getAbsolutePath()).execNoOutput();
        } else {
        	target = link.getCanonicalFile();
        	dir = target.getAbsoluteFile().getParentFile();
        	renamed = File.createTempFile("link"".tmp"dir);
        	delete(iorenamed);
        	try {
        		rename(targetrenamed);
        	} catch (IOException e) {
        		throw new IOException("Cannot delete link " + link + ": rename target " + target + " -> " + renamed
                    + " failed: " + e.getMessage());
        	}
        	wasDeleted = link.delete();
        	try {
        		rename(renamedtarget);
        	} catch (IOException e) {
        		throw new IOException("Couldn't return target " + renamed + " to its original name " + target
                                  + ":\n THE RESOURCE'S NAME ON DISK HAS BEEN CHANGED BY THIS ERROR!\n" + e);
        	}
        	if (!wasDeleted) {
        		throw new IOException("Couldn't delete link: " + link + " (was it a real file? is this not a UNIX system?)");
        	}
        }
    }
    //--
    @Override
    public boolean diff(Node rightBuffer rightBufferthrows IOException {
        if (right instanceof FileNode) {
            if (length() != right.length()) {
                return true;
            }
        }
        return super.diff(rightrightBuffer);
    }
    //--

    
Executes the specified program in this directory. Convenience Method. Don't forget to check the output.
    public String exec(String ... argsthrows IOException {
        return new Program(thisargs).exec();
    }
    public void execNoOutput(String ... argsthrows IOException {
        new Program(thisargs).execNoOutput();
    }
    //--
    @Override
    public int getMode() throws IOException {
        return stat(.., 8) & 0777;
    }
    @Override
    public void setMode(int modethrows IOException {
        ch("chmod", Integer.toOctalString(mode));
    }
    @Override
    public int getUid() throws IOException {
        return stat(.., 10);
    }
    @Override
    public void setUid(int uidthrows IOException {
        ch("chown", Integer.toString(uid));
    }
    @Override
    public int getGid() throws IOException {
        return stat(.., 10);
    }
    @Override
    public void setGid(int gidthrows IOException {
        ch("chgrp", Integer.toString(gid));
    }
    private void ch(String cmdString nthrows IOException {
        new Program(getParent(), cmdngetAbsolute()).execNoOutput();
    }
    private int stat(String[] argsint radixthrows IOException {
        Program stat;
        stat = new Program(getParent(), "stat");
        stat.add(args);
        stat.add(getAbsolute());
        return Integer.parseInt(stat.exec().trim(), radix);
    }
    //--
    public FileNode createTempFile() throws IOException {
        return OnShutdown.get().createFile(this);
    }
    public FileNode createTempDirectory() throws IOException {
        return OnShutdown.get().createDirectory(this);
    }
New to GrepCode? Check out our FAQ X