Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * ====================================================================
   * Copyright (c) 2004-2006 TMate Software Ltd.  All rights reserved.
   *
   * This software is licensed as described in the file COPYING, which
   * you should have received as part of this distribution.  The terms
   * are also available at http://svnkit.com/license.html
   * If newer versions of this license are posted there, you may use a
   * newer version instead, at your option.
  * ====================================================================
  */
 package org.tmatesoft.svn.core.internal.wc.admin;
 
 import java.io.File;
 import java.util.List;
 import java.util.Map;
 

Author(s):
TMate Software Ltd.
Version:
1.1.0
 
 public class SVNWCAccess implements ISVNEventHandler {
     
     public static final int INFINITE_DEPTH = -1;
     
     private ISVNEventHandler myEventHandler;
     private ISVNOptions myOptions;
     private Map myAdminAreas;
 
     private File myAnchor;
 
     public static SVNWCAccess newInstance(ISVNEventHandler eventHandler) {
         return new SVNWCAccess(eventHandler);
     }
     
     private SVNWCAccess(ISVNEventHandler handler) {
          = handler;
     }
     
     public void setEventHandler(ISVNEventHandler handler) {
          = handler;
     }
     
     public ISVNEventHandler getEventHandler() {
         return ;
     }
     
     public void checkCancelled() throws SVNCancelException {
         if ( != null) {
             .checkCancelled();
         }
     }
 
     public void handleEvent(SVNEvent event) {
         handleEvent(event.);
     }
 
     public void handleEvent(SVNEvent eventdouble progress) {
         if ( != null) {
             try {
                 .handleEvent(eventprogress);
             } catch (Throwable th) {
             }
         }
     }
 
     public void setOptions(ISVNOptions options) {
          = options;
     }
 
     public ISVNOptions getOptions() {
         if ( == null) {
              = new DefaultSVNOptions();
         }
         return ;
     }
    
    public void setAnchor(File anchor) {
         = anchor;
    }
    
    public File getAnchor() {
        return ;
    }
    public SVNAdminAreaInfo openAnchor(File pathboolean writeLockint depththrows SVNException {
        File parent = path.getParentFile();
        if (parent == null) {
            SVNAdminArea anchor = open(pathwriteLockdepth);
            return new SVNAdminAreaInfo(thisanchoranchor"");
        }
        String name = path.getName();
        SVNAdminArea parentArea = null;
        SVNAdminArea targetArea = null
        SVNException parentError = null;
        
        try {
            parentArea = open(parentwriteLockfalse, 0);
        } catch (SVNException svne) {
            if (writeLock && svne.getErrorMessage().getErrorCode() == .) {
                try {
                    parentArea = open(parentfalsefalse, 0);
                } catch (SVNException svne2) {
                    throw svne;
                }
                parentError = svne;
            } else if (svne.getErrorMessage().getErrorCode() != .) {
                throw svne;
            }
        }
        
        try {
            targetArea = open(pathwriteLockfalsedepth);
        } catch (SVNException svne) {
            if (parentArea == null || svne.getErrorMessage().getErrorCode() != .) {
                try {
                    close();
                } catch (SVNException svne2) {
                    //
                }
                throw svne;
            }
        }
        
        if (parentArea != null && targetArea != null) {
            SVNEntry parentEntry = null;
            SVNEntry targetEntry = null;
            SVNEntry targetInParent = null;
            try {
                targetInParent = parentArea.getEntry(namefalse);
                targetEntry = targetArea.getEntry(targetArea.getThisDirName(), false);
                parentEntry = parentArea.getEntry(parentArea.getThisDirName(), false);
            } catch (SVNException svne) {
                try {
                    close();
                } catch (SVNException svne2) {
                    //
                }
                throw svne;
            }
            
            SVNURL parentURL = parentEntry.getSVNURL();
            SVNURL targetURL = targetEntry.getSVNURL();
            String encodedName = SVNEncodingUtil.uriEncode(name);
            if (targetInParent == null || (parentURL != null && targetURL != null && 
                    (!parentURL.equals(targetURL.removePathTail()) || !encodedName.equals(SVNPathUtil.tail(targetURL.getPath()))))) {
                if ( != null) {
                    .remove(parent);
                }
                try {
                    doClose(parentAreafalse);
                } catch (SVNException svne) {
                    try {
                        close();
                    } catch (SVNException svne2) {
                        //
                    }
                    throw svne;
                }
                parentArea = null;
            }
        }
        
        if (parentArea != null) {
            if (parentError != null && targetArea != null) {
                try {
                    close();
                } catch (SVNException svne) {
                    //
                }
                throw parentError;
            }
        }
        if (targetArea == null) {
            SVNEntry targetEntry = null;
            try {
                targetEntry = parentArea.getEntry(namefalse); 
            } catch (SVNException svne) {
                try {
                    close();
                } catch (SVNException svne2) {
                    //
                }
                throw svne;
            }
            if (targetEntry != null && targetEntry.isDirectory()) {
                if ( != null) {
                    .put(pathnull);
                }
            }
        }
        SVNAdminArea anchor = parentArea != null ? parentArea : targetArea;
        SVNAdminArea target = targetArea != null ? targetArea : parentArea;
        return new SVNAdminAreaInfo(thisanchortargetparentArea == null ? "" : name);
    }
    public SVNAdminArea open(File pathboolean writeLockint depththrows SVNException {
        return open(pathwriteLockfalsedepth);
    }
    
    public SVNAdminArea open(File pathboolean writeLockboolean stealLockint depththrows SVNException {
        Map tmp = new HashMap();
        SVNAdminArea area;
        try {
            area = doOpen(pathwriteLockstealLockdepthtmp);
        } finally {
            for(Iterator paths = tmp.keySet().iterator(); paths.hasNext();) {
                Object childPath = paths.next();
                SVNAdminArea childArea = (SVNAdminAreatmp.get(childPath);
                .put(childPathchildArea);
            }
        }
        return area;
    }
    
    public SVNAdminArea probeOpen(File pathboolean writeLockint depththrows SVNException {
        File dir = probe(path);
        if (!path.equals(dir)) {
            depth = 0;
        }
        SVNAdminArea adminArea = null;
        try {
            adminArea = open(dirwriteLockfalsedepth);
        } catch (SVNException svne) {
            SVNFileType childKind = SVNFileType.getType(path);
            SVNErrorCode errCode = svne.getErrorMessage().getErrorCode(); 
            if (!path.equals(dir) && childKind == . && errCode == .) {
                SVNErrorMessage err = SVNErrorMessage.create(."''{0}'' is not a working copy"path);
                SVNErrorManager.error(err);
            } else {
                throw svne;
            }
        }
        return adminArea;
    }
    
    public SVNAdminArea probeTry(File pathboolean writeLockint depththrows SVNException {
        SVNAdminArea adminArea = null;
        try {
            adminArea = probeRetrieve(path);
        } catch (SVNException svne) {
            if (svne.getErrorMessage().getErrorCode() == .) {
                try {
                    adminArea = probeOpen(pathwriteLockdepth);
                } catch (SVNException svne2) {
                    if (svne2.getErrorMessage().getErrorCode() != .) {
                        throw svne2
                    }
                }
            } else {
                throw svne;
            }
        }
        return adminArea;
    }
    
    public void close() throws SVNException {
        if ( != null) {
            doClose(false);
            .clear();
        }
    }
    
    public void closeAdminArea(File paththrows SVNException {
        if ( != null) {
            SVNAdminArea area = (SVNAdminArea.get(path);
            if (area != null) {
                doClose(areafalse);
                .remove(path);
            }
        }
    }
    
    private SVNAdminArea doOpen(File pathboolean writeLockboolean stealLockint depthMap tmpthrows SVNException {
        // no support for 'under consturction here' - it will go to adminAreaFactory.
        tmp = tmp == null ? new HashMap() : tmp
        if ( != null) {
            SVNAdminArea existing = (SVNAdminArea.get(path);
            if (.containsKey(path) && existing != null) {
                SVNErrorMessage error = SVNErrorMessage.create(."Working copy ''{0}'' locked"path);
                SVNErrorManager.error(error);
            }
        } else {
             = new HashMap();
        }
        
        SVNAdminArea area = SVNAdminAreaFactory.open(path);
        area.setWCAccess(this);
        
        if (writeLock) {
            area.lock(stealLock);
            area = SVNAdminAreaFactory.upgrade(area);
        }
        tmp.put(patharea);
        
        if (depth != 0) {
            if (depth > 0) {
                depth--;
            }
            for(Iterator entries = area.entries(false); entries.hasNext();) {
                try {
                    checkCancelled(); 
                } catch (SVNCancelException e) {
                    doClose(tmpfalse);
                    throw e;
                }
                
                SVNEntry entry = (SVNEntryentries.next();
                if (entry.getKind() != .  || area.getThisDirName().equals(entry.getName())) {
                    continue;
                }
                File childPath = new File(pathentry.getName());
                try {
                    // this method will put created area into our map.
                    doOpen(childPathwriteLockstealLockdepthtmp);
                } catch (SVNException e) {
                    if (e.getErrorMessage().getErrorCode() != .) {
                        doClose(tmpfalse);
                        throw e;
                    }
                    // only for missing!
                    tmp.put(childPathnull);
                    continue;
                }
            }
        }
        return area;
    }
    
    private void doClose(Map adminAreasboolean preserveLocksthrows SVNException {
        for (Iterator paths = adminAreas.keySet().iterator(); paths.hasNext();) {
            File path = (Filepaths.next();
            SVNAdminArea adminArea = (SVNAdminAreaadminAreas.get(path);
            if (adminArea == null) {
                paths.remove();
                continue;
            }
            doClose(adminAreapreserveLocks);
            paths.remove();
        }
    }
    private void doClose(SVNAdminArea adminAreaboolean preserveLocksthrows SVNException {
        if (adminArea == null) {
            return;
        }
        if (!preserveLocks && adminArea.isLocked()) {
            adminArea.unlock();
        }
    }
    public SVNAdminArea probeRetrieve(File paththrows SVNException {
        File dir = probe(path);
        return retrieve(dir);
    }
    
    public boolean isMissing(File path) {
        if ( != null) {
            return .containsKey(path) && .get(path) == null;
        }
        return false;
    }
    public boolean isLocked(File paththrows SVNException {
        File lockFile = new File(path, SVNFileUtil.getAdminDirectoryName());
        lockFile = new File(lockFile"lock");
        if (SVNFileType.getType(lockFile) == .) {
            return true;
        } else if (SVNFileType.getType(lockFile) == .) {
            return false;
        }
        SVNErrorMessage err = SVNErrorMessage.create(."Lock file ''{0}'' is not a regular file"lockFile);
        SVNErrorManager.error(err);
        return false;
    }
    
    public boolean isWCRoot(File paththrows SVNException {
        SVNEntry entry = getEntry(pathfalse);
        SVNAdminArea parentArea = getAdminArea(path.getParentFile());
        if (parentArea == null) {
            try {
                parentArea = probeOpen(path.getParentFile(), false, 0);
            } catch (SVNException svne) {
                return true;
            }
        }
        
        SVNEntry parentEntry = getEntry(path.getParentFile(), false);
        if (parentEntry == null) {
            return true;
        }
        
        if (parentEntry.getURL() == null) {
            SVNErrorMessage err = SVNErrorMessage.create(."''{0}'' has no ancestry information"path.getParentFile());
            SVNErrorManager.error(err);
        }
        
        // what about switched paths?
        /*
        if (entry != null && entry.getURL() != null) {
            if (!entry.getURL().equals(SVNPathUtil.append(parentEntry.getURL(), SVNEncodingUtil.uriEncode(path.getName())))) {
                return true;
            }
        }*/
        entry = parentArea.getEntry(path.getName(), false);
        if (entry == null) {
            return true;
        }
        return false;
    }
    
    public SVNEntry getEntry(File pathboolean showHiddenthrows SVNException {
        SVNAdminArea adminArea = getAdminArea(path);
        String entryName = null;
        if (adminArea == null) {
            adminArea = getAdminArea(path.getParentFile());
            entryName = path.getName();
        } else {
            entryName = adminArea.getThisDirName();
        }
        
        if (adminArea != null) {
            return adminArea.getEntry(entryNameshowHidden);
        }
        return null;
    }
    
    public void setRepositoryRoot(File pathSVNURL reposRootthrows SVNException {
        SVNEntry entry = getEntry(pathfalse);
        if (entry == null) {
            return;
        }
        SVNAdminArea adminArea = null;
        String name = null;
        if (entry.isFile()) {
            adminArea = getAdminArea(path.getParentFile());
            name = path.getName();
        } else {
            adminArea = getAdminArea(path);
            name = adminArea != null ? adminArea.getThisDirName() : null;
        }
        
        if (adminArea == null) {
            return;
        }
        if (adminArea.tweakEntry(namenullreposRoot.toString(), -1, false)) {
            adminArea.saveEntries(false);
        }
    }
    
    public SVNAdminArea[] getAdminAreas() {
        if ( != null) {
            return (SVNAdminArea[]) .values().toArray(new SVNAdminArea[.size()]);
        }
        return new SVNAdminArea[0];
    }
    
    public SVNAdminArea retrieve(File paththrows SVNException {
        SVNAdminArea adminArea = getAdminArea(path);
        if (adminArea == null) {
            SVNEntry subEntry = null;
            try {
                SVNAdminArea dirAdminArea = getAdminArea(path.getParentFile());
                if (dirAdminArea != null) {
                    subEntry = dirAdminArea.getEntry(path.getName(), true);
                }
            } catch (SVNException svne) {
                subEntry = null;
            }
            SVNFileType type = SVNFileType.getType(path);
            if (subEntry != null) {
                if (subEntry.getKind() == . && type == .) {
                    SVNErrorMessage err = SVNErrorMessage.create(."Expected ''{0}'' to be a directory but found a file"path);
                    SVNErrorManager.error(err);
                } else if (subEntry.getKind() == . && type == .) {
                    SVNErrorMessage err = SVNErrorMessage.create(."Expected ''{0}'' to be a file but found a directory"path);
                    SVNErrorManager.error(err);
                }
            }
            File adminDir = new File(path, SVNFileUtil.getAdminDirectoryName());
            SVNFileType wcType = SVNFileType.getType(adminDir);
            
            if (type == .) {
                SVNErrorMessage err = SVNErrorMessage.create(."Directory ''{0}'' is missing"path);
                SVNErrorManager.error(err);
            } else if (type == . && wcType == .) {
                SVNErrorMessage err = SVNErrorMessage.create(."Directory ''{0}'' containing working copy admin area is missing"adminDir);
                SVNErrorManager.error(err);
            } else if (type == . && wcType == .) {
                SVNErrorMessage err = SVNErrorMessage.create(."Unable to lock ''{0}''"path);
                SVNErrorManager.error(err);
            }
            SVNErrorMessage err = SVNErrorMessage.create(."Working copy ''{0}'' is not locked"path);
            SVNErrorManager.error(err);
        }
        return adminArea;
    }
    public static SVNExternalInfo[] parseExternals(String rootPathString externals) {
        Collection result = new ArrayList();
        if (externals == null) {
            return (SVNExternalInfo[]) result.toArray(new SVNExternalInfo[result.size()]);
        }
        for (StringTokenizer lines = new StringTokenizer(externals"\n\r"); lines.hasMoreTokens();) {
            String line = lines.nextToken().trim();
            if (line.length() == 0 || line.startsWith("#")) {
                continue;
            }
            String url = null;
            String path;
            long rev = -1;
            List parts = new ArrayList(4);
            for (StringTokenizer tokens = new StringTokenizer(line" \t"); tokens
                    .hasMoreTokens();) {
                String token = tokens.nextToken().trim();
                parts.add(token);
            }
            if (parts.size() < 2) {
                continue;
            }
            path = SVNPathUtil.append(rootPath, (Stringparts.get(0));
            if (path.endsWith("/")) {
                path = path.substring(0, path.length() - 1);
            }
            if (parts.size() == 2) {
                url = (Stringparts.get(1);
            } else if (parts.size() == 3 && parts.get(1).toString().startsWith("-r")) {
                String revStr = parts.get(1).toString();
                revStr = revStr.substring("-r".length());
                if (!"HEAD".equals(revStr)) {
                    try {
                        rev = Long.parseLong(revStr);
                    } catch (NumberFormatException nfe) {
                        continue;
                    }
                }
                url = (Stringparts.get(2);
            } else if (parts.size() == 4 && "-r".equals(parts.get(1))) {
                String revStr = parts.get(2).toString();
                if (!"HEAD".equals(revStr)) {
                    try {
                        rev = Long.parseLong(revStr);
                    } catch (NumberFormatException nfe) {
                        continue;
                    }
                }
                url = (Stringparts.get(3);
            }
            if (path != null && url != null) {
                if ("".equals(rootPath) && ((Stringparts.get(0)).startsWith("/")) {
                    path = "/" + path;
                }
                try {
                    url = SVNURL.parseURIEncoded(url).toString();
                } catch (SVNException e) {
                    continue;
                }
                
                try {
                    SVNExternalInfo info = new SVNExternalInfo(""nullpath, SVNURL.parseURIEncoded(url), rev);
                    result.add(info);
                } catch (SVNException e) {
                }
            }
        }
        return (SVNExternalInfo[]) result.toArray(new SVNExternalInfo[result.size()]);
    }
    //analogous to retrieve_internal
    public SVNAdminArea getAdminArea(File path) {
        //internal retrieve
        SVNAdminArea adminArea = null
        if ( != null) {
            adminArea = (SVNAdminArea.get(path);
        }
        return adminArea;
    }
    
    private File probe(File paththrows SVNException {
        int wcFormat = -1;
        SVNFileType type = SVNFileType.getType(path);
        if (type == .) {
            wcFormat = SVNAdminAreaFactory.checkWC(pathtrue);
        } else {
            wcFormat = 0;
        }
        
        //non wc
        if (type != . || wcFormat == 0) {
            if ("..".equals(path.getName()) || ".".equals(path.getName())) {
                SVNErrorMessage err = SVNErrorMessage.create(."Path ''{0}'' ends in ''{1}'', which is unsupported for this operation"new Object[]{pathpath.getName()});
                SVNErrorManager.error(err);
            }
            path = path.getParentFile();
        } 
        return path;
    }
New to GrepCode? Check out our FAQ X