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.svn;
 
 
 import java.net.URI;
 import java.util.Date;
 import java.util.List;
 
 public class SvnNode extends Node {
     private final SvnRoot root;
     private final String path;
 
     public SvnNode(SvnRoot rootString path) {
         super();
         this. = root;
         this. = path;
     }
 
     @Override
     public URI getURI() {
         return URI.create(.getFilesystem().getScheme() + ":" + getSvnurl().toString());
     }
 
     @Override
     public SvnRoot getRoot() {
         return ;
     }
 
     @Override
     public SvnNode getParent() {
         return (SvnNodedoGetParent();
     }
 
     @Override
     public SvnNode join(String ... paths) {
         return (SvnNodedoJoin(paths);
     }
 
     @Override
     public SvnNode join(List<Stringpaths) {
         return (SvnNodedoJoin(paths);
     }
 
     @Override
     public String getPath() {
         return ;
     }
 
     @Override
     public List<SvnNodelist() throws ListException {
         List<SVNDirEntrylst;
         List<SvnNoderesult;
         SVNRepository repository;
         SvnNode child;
         SVNNodeKind kind;
        repository = .getRepository();
        try {
            kind = repository.checkPath(, -1);
            if (kind == .) {
                lst = new ArrayList<SVNDirEntry>();
                repository.getDir(, -1, falselst);
                result = new ArrayList<SvnNode>(lst.size());
                for (SVNDirEntry entry : lst) {
                    child = new SvnNode(doJoin(entry.getRelativePath()));
                    result.add(child);
                }
                return result;
            } else if (kind == .) {
                return null;
            } else {
                throw new ListException(thisnew IOException("not a directory"));
            }
        } catch (SVNException e) {
            throw new ListException(thise);
        }
    }
    public long getLatestRevision() throws SVNException {
        List<Longrevs;
        SVNDirEntry dir;
        if (.getRepository().checkPath(, -1) == .) {
            dir = .getRepository().getDir(, -1, falsenew ArrayList<Object>());
            return dir.getRevision();
        } else {
            revs = getRevisions();
            return revs.get(revs.size() - 1);
        }
    }
    public List<LonggetRevisions() throws SVNException {
        return getRevisions(0);
    }
    public List<LonggetRevisions(long startthrows SVNException {
        return getRevisions(start.getRepository().getLatestRevision());
    }
    public List<LonggetRevisions(long startlong endthrows SVNException {
        Collection<SVNFileRevisionrevisions;
        List<Longresult;
        revisions = (Collection<SVNFileRevision>) .getRepository().getFileRevisions(nullstartend);
        result = new ArrayList<Long>();
        for (SVNFileRevision rev : revisions) {
            result.add(rev.getRevision());
        }
        return result;
    }
    @Override
    public int getMode() {
        throw unsupported("getMode()");
    }
    @Override
    public void setMode(int mode) {
        throw unsupported("setMode()");
    }
    @Override
    public int getUid() {
        throw unsupported("getUid()");
    }
    @Override
    public void setUid(int uid) {
        throw unsupported("setUid()");
    }
    @Override
    public int getGid() {
        throw unsupported("getGid()");
    }
    @Override
    public void setGid(int gid) {
        throw unsupported("setGid()");
    }
    @Override
    public InputStream createInputStream() throws IOException {
        FileNode tmp;
        OutputStream dest;
        tmp = getWorld().getTemp().createTempFile();
        dest = tmp.createOutputStream();
        try {
            load(dest);
        } catch (SVNException e) {
            throw new IOException("svn failure"e);
        }
        dest.close();
        return tmp.createInputStream();
    }
    @Override
    public OutputStream createOutputStream(boolean appendthrows IOException {
        byte[] add;
        if (append) {
            try {
                add = readBytes();
            } catch (FileNotFoundException e) {
                add = null;
            }
        } else {
            add = null;
        }
        return new CheckedByteArrayOutputStream(add) {
            @Override
            public void close() throws IOException {
                super.close();
                try {
                    save(toByteArray(), .getComment());
                } catch (SVNException e) {
                    throw new IOException("close failed"e);
                }
            }
        };
    }
    @Override
    public SvnNode delete() throws DeleteException {
        try {
            if (!exists()) {
                throw new DeleteException(thisnew FileNotFoundException());
            }
            delete("sushi delete");
        } catch (ExistsException e) {
            throw new DeleteException(thise);
        } catch (SVNException e) {
            throw new DeleteException(thise);
        }
        return this;
    }

    

Returns:
revision
    public long delete(String commentthrows SVNException {
        SVNCommitClient client;
        SVNCommitInfo info;
        client = .getClientMananger().getCommitClient();
        info = client.doDelete(new SVNURL[] { getSvnurl() }, comment);
        return info.getNewRevision();
    }
    @Override
    public Node mkdir() throws MkdirException {
        SVNCommitClient client;
        try {
            client = .getClientMananger().getCommitClient();
            client.doMkDir(new SVNURL[] { getSvnurl() }, .getComment());
            return this;
        } catch (SVNException e) {
            throw new MkdirException(thise);
        }
    }
    @Override
    public void mklink(String target) {
        throw unsupported("mklink()");
    }
    @Override
    public String readLink() {
        throw unsupported("readLink()");
    }
    public long load(OutputStream destthrows SVNExceptionFileNotFoundException {
        return load(.getRepository().getLatestRevision(), dest);
    }
    public long load(long revisionOutputStream destthrows FileNotFoundExceptionSVNException {
        SVNRepository repository;
        repository = .getRepository();
        if (repository.checkPath(revision) != .) {
            throw new FileNotFoundException("no such file: " +  + ", revision " + revision);
        }
        return repository.getFile(revisionnulldest);
    }
    @Override
    public boolean exists() throws ExistsException {
        try {
            return exists(.getRepository().getLatestRevision());
        } catch (SVNException e) {
            throw new ExistsException(thise);
        }
    }
    public boolean exists(long revisionthrows SVNException {
        SVNNodeKind kind;
        kind = .getRepository().checkPath(revision);
        return kind == . || kind == .;
    }
    @Override
    public long length() throws LengthException {
        SVNDirEntry entry;
        try {
            entry = .getRepository().info(, -1);
            if (entry == null || entry.getKind() != .) {
                throw new LengthException(thisnew IOException("file expected"));
            }
            return entry.getSize();
        } catch (SVNException e) {
            throw new LengthException(thise);
        }
    }
    @Override
    public boolean isFile() throws ExistsException {
        return kind() == .;
    }
    @Override
    public boolean isDirectory() throws ExistsException {
        return kind() == .;
    }
    @Override
    public boolean isLink() {
    	return false;
    }
    private SVNNodeKind kind() throws ExistsException {
        SVNRepository repository;
        repository = .getRepository();
        try {
            return repository.checkPath(repository.getLatestRevision());
        } catch (SVNException e) {
            throw new ExistsException(thise);
        }
    }
    @Override
    public long getLastModified() throws GetLastModifiedException {
        return getLastModified(-1).getTime();
    }
    public Date getLastModified(long revisionthrows GetLastModifiedException {
        try {
            if (!exists()) {
                throw new GetLastModifiedException(thisnull);
            }
        } catch (ExistsException e) {
            throw new GetLastModifiedException(thise);
        }
        try {
            return .getRepository().info(revision).getDate();
        } catch (SVNException e) {
            throw new GetLastModifiedException(thise);
        }
    }
    @Override
    public void setLastModified(long millisthrows SetLastModifiedException {
        throw new SetLastModifiedException(this);
    }


    

Returns:
revision
    public long save(byte[] contentString commentthrows SVNException {
        return save(new ByteArrayInputStream(content), comment);
    }

    

Returns:
revision
    public long save(InputStream contentString commentthrows SVNException {
    	// does NOT use the CommitClient, because the commit client needs a physical file
        boolean exists;
        ISVNEditor editor;
        SVNCommitInfo info;
        SVNDeltaGenerator deltaGenerator;
        String checksum;
        SVNRepository repository;
        repository = .getRepository();
        try {
            exists = exists();
        } catch (ExistsException e) {
            throw (SVNExceptione.getCause();
        }
        editor = repository.getCommitEditor(commentnull);
        editor.openRoot(-1);
        editor.openDir(SVNPathUtil.removeTail(), -1);
        if (exists) {
            editor.openFile(, -1);
        } else {
            editor.addFile(null, -1);
        }
        editor.applyTextDelta(null);
        deltaGenerator = new SVNDeltaGenerator();
        checksum = deltaGenerator.sendDelta(contenteditortrue);
        editor.closeFile(checksum);
        editor.closeDir();
        info = editor.closeEdit();
        return info.getNewRevision();
    }
    //--
    // TODO
    private String doJoin(String leftString right) {
        if (left.length() == 0) {
            return right;
        }
        return left + .getFilesystem().getSeparator() + right;
    }
    public long export(Node destthrows IOExceptionSVNException {
        long latest;
        latest = getLatestRevision();
        export(destlatest);
        return latest;
    }
    public void export(Node destlong revisionthrows IOExceptionSVNException {
        Exporter exporter;
        SVNRepository sub;
        SVNRepository repository;
        repository = .getRepository();
        this.checkDirectory();
        dest.checkDirectory();
        exporter = new Exporter(revisiondest);
        if (.length() == 0) {
            sub = repository;
        } else {
            // repository updates has a target to restrict the result, but it supports
            // only one segment. So I have to create a new repository ...
            sub = SvnFilesystem.repository(getSvnurl().toString(), nullnull); // TODO: auth
        }
        sub.update(revision""trueexporterexporter);
    }
    public SVNURL getSvnurl() {
        try {
            return .getRepository().getLocation().appendPath(false);
        } catch (SVNException e) {
            throw new IllegalStateException(e);
        }
    }
    public static SvnNode fromWorkspace(FileNode workspacethrows IOException {
        return (SvnNodeworkspace.getWorld().validNode("svn:" + urlFromWorkspace(workspace));
    }
    public static String urlFromWorkspace(FileNode workspacethrows IOException {
        workspace.join(".svn").checkExists();
        return extract(workspace.exec("svn""info"), "URL:");
    }
    private static String extract(String strString keythrows IOException {
        int start;
        int end;
        start = str.indexOf(key);
        if (start == - 1) {
            throw new IOException("missing " + key + " in " + str);
        }
        start += key.length();
        end = str.indexOf('\n'start);
        if (end == -1) {
            throw new IOException("missing newline in " + str);
        }
        return str.substring(startend).trim();
    }
New to GrepCode? Check out our FAQ X