Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
Copyright (c) 2000, 2011 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html Contributors: IBM Corporation - initial API and implementation /
 
 package org.eclipse.team.internal.ccvs.ui.repo;
 
 import java.util.*;
 
 
 public class RepositoryRoot extends PlatformObject {
 
 	public static final String[] DEFAULT_AUTO_REFRESH_FILES = { ".project" }; //$NON-NLS-1$ 
 	private static final String DEFINED_MODULE_PREFIX = "module:"//$NON-NLS-1$
 	
 	// Map of String (remote folder path) -> TagCacheEntry
 	// Map of String (remote folder path) -> Set (file paths that are project relative)
 	// Map of String (module name) -> ICVSRemoteFolder (that is a defined module)
 	// List of date tags
 	List dateTags = new ArrayList();
 	
 	public static class TagCacheEntry {
 	    Set tags = new HashSet();
 	    long lastAccessTime;
         private static final int CACHE_LIFESPAN_IN_DAYS = 7;
         public TagCacheEntry() {
             accessed();
         }
         public boolean isExpired() {
             long currentTime = System.currentTimeMillis();
             long ms = currentTime - ;
             int seconds = (int)ms / 1000;
             int hours = seconds / 60 / 60;
             int days = hours / 24;
             return days > ;
         }
         public void accessed() {
              = System.currentTimeMillis();
         }
 	}
 	
 		this. = root;
 	}

Returns the name.

Returns:
String
 
 	public String getName() {
 		return ;
 	}

Method getRemoteFolder.

Parameters:
path
tag
Returns:
ICVSRemoteFolder
 
 	public ICVSRemoteFolder getRemoteFolder(String pathCVSTag tagIProgressMonitor monitor) {
 		if (isDefinedModuleName(path)) {
 			return getDefinedModule(getDefinedModuleName(path), tagmonitor);
 		} else {
 			return .getRemoteFolder(pathtag);
 		}
 	}
 
 	static boolean isDefinedModuleName(String path) {
 	}
 
 	static String getDefinedModuleName(String path) {
 	}
 	
		return  + path;
	}

Method getDefinedModule.

Parameters:
path
tag
monitor
Returns:
ICVSRemoteFolder
	private ICVSRemoteFolder getDefinedModule(String pathCVSTag tagIProgressMonitor monitor) {
		Map cache = getDefinedModulesCache(tagmonitor);
		ICVSRemoteFolder folder = (ICVSRemoteFolder)cache.get(path);
		if (folder != null) {
			folder = (ICVSRemoteFolder)folder.forTag(tag);
		}
		return folder;
	}
	private Map getDefinedModulesCache(CVSTag tagIProgressMonitor monitor) {
		if ( == null) {
			try {
				// Fetch the modules before locking the cache (to avoid deadlock)
				ICVSRemoteResource[] folders = .members(.truemonitor);
				synchronized() {
					for (int i = 0; i < folders.lengthi++) {
						ICVSRemoteResource resource = folders[i];
						.put(resource.getName(), resource);
					}
				}
catch (CVSException e) {
				// we could't fetch the modules. Log the problem and continue
				CVSUIPlugin.log(e);
				// Return an empty map but don't save it so the fetching of 
				// the modules will occur again
				return new HashMap();
			}
		}
		return ;
	}
		Map cache = getDefinedModulesCache(tagmonitor);
		return (ICVSRemoteResource[]) cache.values().toArray(new ICVSRemoteResource[cache.size()]);
	}
	public static String getRemotePathFor(ICVSResource resourcethrows CVSException {
		if (resource.isFolder()) {
			if (resource instanceof ICVSRemoteFolder) {
				ICVSRemoteFolder remoteFolder = (ICVSRemoteFolderresource;
				if (remoteFolder.isDefinedModule()) {
					return asDefinedModulePath(remoteFolder.getName());
				}
			}
			if (info == null)
				throw new CVSException(NLS.bind(.new String[] { resource.getName() })); 
			return info.getRepository();
else {
			if (info == null)
			String path = new Path(nullinfo.getRepository()).append(resource.getName()).toString();
			return path;
		}
	}

Returns the root.

Returns:
ICVSRepositoryLocation
		return ;
	}

Sets the name.

Parameters:
name The name to set
	public void setName(String name) {
		this. = name;
	}

Accept the tags for any remote path that represents a folder. However, for the time being, the given version tags are added to the list of known tags for the remote ancestor of the resource that is a direct child of the remote root. It is the responsibility of the caller to ensure that the given remote path is valid.
	public void addTags(String remotePathCVSTag[] tags) {	
		addVersionAndBranchTags(remotePathtags);
	}
	private void addDateTags(CVSTag[] tags){
		for(int i = 0; i < tags.lengthi++){
			if(tags[i].getType() == .){
				.add(tags[i]);
			}
		}
	}
	private void addVersionAndBranchTags(String remotePathCVSTag[] tags) {
		// Get the name to cache the version tags with
		String name = getCachePathFor(remotePath);
		// Make sure there is a table for the ancestor that holds the tags
		if (entry == null) {
		    entry = new TagCacheEntry();
else {
		    entry.accessed();
		}
		// Store the tag with the appropriate ancestor
		for (int i = 0; i < tags.lengthi++) {
			if(tags[i].getType() != .){
				entry.tags.add(tags[i]);
			}
		}
	}

Add the given date tag to the list of date tags associated with the repository.

Parameters:
tag a date tag
	public void addDateTag(CVSTag tag) {
		if (!.contains(tag)) {
		}
	}
	public void removeDateTag(CVSTag tag) {
		if (.contains(tag)) {
		}
	}
Return the list of date tags associated with the repository.

Returns:
the list of date tags
	public CVSTag[] getDateTags() {
		return (CVSTag[]) .toArray(new CVSTag[.size()]);
	}

Remove the given tags from the receiver

Parameters:
remotePath
tags
	public void removeTags(String remotePathCVSTag[] tags) {
		removeVersionAndBranchTags(remotePathtags);
	}
	private void removeDateTags(CVSTag[] tags) {		
		if(.isEmpty())return;
		// Store the tag with the appropriate ancestor
		for (int i = 0; i < tags.lengthi++) {
			.remove(tags[i]);
		}
	}
	private void removeVersionAndBranchTags(String remotePathCVSTag[] tags) {
		// Get the name to cache the version tags with
		String name = getCachePathFor(remotePath);
		// Make sure there is a table for the ancestor that holds the tags
		if (entry == null) {
			return;
		}
		// Store the tag with the appropriate ancestor
		for (int i = 0; i < tags.lengthi++) {
			entry.tags.remove(tags[i]);
		}
		entry.accessed();
	}

Returns the absolute paths of the auto refresh files relative to the repository.

Returns:
String[]
	public String[] getAutoRefreshFiles(String remotePath) {
		String name = getCachePathFor(remotePath);
		Set files = (Set).get(name);
		if (files == null || files.isEmpty()) {
			// convert the default relative file paths to full paths
			if (isDefinedModuleName(remotePath)) {
				return new String[0];
			}
			List result = new ArrayList();
			for (int i = 0; i < .i++) {
				String relativePath = [i];
				result.add(new Path(nullremotePath).append(relativePath).toString());
			}
			return (String[]) result.toArray(new String[result.size()]);
else {
			return (String[]) files.toArray(new String[files.size()]);
		}
	}

Sets the auto refresh files for the given remote path to the given string values which are absolute file paths (relative to the receiver).

Parameters:
autoRefreshFiles The autoRefreshFiles to set
	public void setAutoRefreshFiles(String remotePathString[] autoRefreshFiles) {
		Set newFiles = new HashSet(Arrays.asList(autoRefreshFiles));
		// Check to see if the auto-refresh files are the default files
		if (autoRefreshFiles.length == .) {
			boolean isDefault = true;
			for (int i = 0; i < .i++) {
				if (!newFiles.contains(new Path(nullremotePath).append(filePath).toString())) {
					isDefault = false;
					break;
				}
			}
			if (isDefault) {
				return;
			}
		}
		this..put(getCachePathFor(remotePath), newFiles);
	}

Fetches tags from auto-refresh files.
	public CVSTag[] refreshDefinedTags(ICVSFolder folderboolean recurseIProgressMonitor monitorthrows TeamException {
		monitor = Policy.monitorFor(monitor);
	    monitor.beginTask(null, 100);
	    CVSTag[] tags = null;
	    if (!recurse && !folder.getFolderSyncInfo().isVirtualDirectory()) {
	        // Only try the auto-refresh file(s) if we are not recursing into sub-folders
	        tags = fetchTagsUsingAutoRefreshFiles(folder, Policy.subMonitorFor(monitor, 50));
	    }
        if (tags == null || tags.length == 0) {
            // There we're no tags found on the auto-refresh files or we we're aksed to go deep
            // Try using the log command
            tags = fetchTagsUsingLog(folderrecurse, Policy.subMonitorFor(monitor, 50));
        }
		if (tags != null && tags.length > 0) {
		    String remotePath = getRemotePathFor(folder);
			addTags(remotePathtags);
		}
		monitor.done();
		return tags;
	}
    private CVSTag[] fetchTagsUsingLog(ICVSFolder folderfinal boolean recurseIProgressMonitor monitorthrows CVSException {
        LogEntryCache logEntries = new LogEntryCache();
        RemoteLogOperation operation = new RemoteLogOperation(nullnew ICVSRemoteResource[] { asRemoteResource(folder) }, nullnulllogEntries) {
            protected Command.LocalOption[] getLocalOptions(CVSTag tag1,CVSTag tag2) {
                Command.LocalOption[] options = new Command.LocalOption[] {};
                if (recurse
                    return options;
                Command.LocalOption[] newOptions = new Command.LocalOption[options.length + 1];
                System.arraycopy(options, 0, newOptions, 0, options.length);
                newOptions[options.length] = .;
                return newOptions;
            }
        };
        try {
            operation.run(monitor);
        } catch (InvocationTargetException e) {
            throw CVSException.wrapException(e);
        } catch (InterruptedException e) {
            // Ignore;
        }
        String[] keys = logEntries.getCachedFilePaths();
        Set tags = new HashSet();
        for (int i = 0; i < keys.lengthi++) {
            String key = keys[i];
            ILogEntry[] entries = logEntries.getLogEntries(key);
            for (int j = 0; j < entries.lengthj++) {
                ILogEntry entry = entries[j];
                tags.addAll(Arrays.asList(entry.getTags()));
            }
        }
        return (CVSTag[]) tags.toArray(new CVSTag[tags.size()]);
    }
    private ICVSRemoteResource asRemoteResource(ICVSFolder folderthrows CVSException {
        if (folder instanceof ICVSRemoteResource) {
            return (ICVSRemoteResource)folder;
        }
        return CVSWorkspaceRoot.getRemoteResourceFor(folder);
    }

    
Fetches tags from auto-refresh files.
	    String remotePath = getRemotePathFor(folder);
		String[] filesToRefresh = getAutoRefreshFiles(remotePath);
		try {
			monitor.beginTask(nullfilesToRefresh.length * 10); 
			List tags = new ArrayList();
			for (int i = 0; i < filesToRefresh.lengthi++) {
				ICVSRemoteFile file = .getRemoteFile(filesToRefresh[i], .);
				try {
                    tags.addAll(Arrays.asList(fetchTags(file, Policy.subMonitorFor(monitor, 5))));
        		} catch (TeamException e) {
        			IStatus status = e.getStatus();
        			boolean doesNotExist = false;
        			if (status.getCode() == . && status.isMultiStatus()) {
        				IStatus[] children = status.getChildren();
        				if (children.length == 1 && children[0].getCode() == .) {
        				    // Don't throw an exception if the file does no exist
        					doesNotExist = true;
        				}
        			}
        			if (!doesNotExist) {
        			    throw e;
        			}
                }
			}
			return (CVSTag[]) tags.toArray(new CVSTag[tags.size()]);
finally {
			monitor.done();
		}
	}

Returns Branch and Version tags for the given files
	private CVSTag[] fetchTags(ICVSRemoteFile fileIProgressMonitor monitorthrows TeamException {
		Set tagSet = new HashSet();
		ILogEntry[] entries = file.getLogEntries(monitor);
		for (int j = 0; j < entries.lengthj++) {
			CVSTag[] tags = entries[j].getTags();
			for (int k = 0; k < tags.lengthk++) {
				tagSet.add(tags[k]);
			}
		}
		return (CVSTag[])tagSet.toArray(new CVSTag[0]);
	}
	/*
	 * Return the cache key (path) for the given folder path.
	 * This has been changed to cache the tags directly 
	 * with the folder to better support non-root projects.
	 * However, resources in the local workspace use the folder
	 * the project is mapped to as the tag source (see TagSource)
	 */
	private String getCachePathFor(String remotePath) {
		return remotePath;
	}

Write out the state of the receiver as XML on the given XMLWriter.

Parameters:
writer
Throws:
java.io.IOException
	public void writeState(XMLWriter writer) {
		HashMap attributes = new HashMap();
		attributes.clear();
		if ( != null) {
		}
		//put date tag under repository
			while(iter.hasNext()){
				CVSTag tag = (CVSTag)iter.next();
			}
		}
		// Gather all the modules that have tags and/or auto-refresh files
		// for each module, write the moduel, tags and auto-refresh files.
		for (int i = 0; i < paths.lengthi++) {
			String path = paths[i];
			attributes.clear();
			String name = path;
			if (isDefinedModuleName(path)) {
				name = getDefinedModuleName(path);
			}
			boolean writeOutTags = entry != null && !entry.isExpired();
			if (writeOutTags)
			    attributes.put(., Long.toString(entry.lastAccessTime));
			if (writeOutTags) {
				Iterator tagIt = entry.tags.iterator();
				while (tagIt.hasNext()) {
					CVSTag tag = (CVSTag)tagIt.next();
					writeATag(writerattributestag.);
				}
			}
			Set refreshSet = (Set).get(path);
			if (refreshSet != null) {
				Iterator filenameIt = refreshSet.iterator();
				while (filenameIt.hasNext()) {
					String filename = (String)filenameIt.next();
					attributes.clear();
				}
			}
		}
	}
    private void writeATag(XMLWriter writerHashMap attributesCVSTag tagString s) {
		attributes.clear();
		writer.startAndEndTag(sattributestrue);
	}

Method getKnownTags.

Parameters:
remotePath
Returns:
CVSTag[]
	public CVSTag[] getAllKnownTags(String remotePath) {
		if(entry != null){
		    entry.accessed();
			CVSTag [] tags1 = (CVSTag[]) entry.tags.toArray(new CVSTag[entry.tags.size()]);
			CVSTag[] tags2 = getDateTags();
			int len = tags1.length + tags2.length;
			CVSTag[] tags = new CVSTag[len];
			for(int i = 0; i < leni++){
				if(i < tags1.length){
					tags[i] = tags1[i];
				}else{
					tags[i] = tags2[i-tags1.length];
				}
			}
			return tags;
		}
		return getDateTags();
	}
		Set paths = new HashSet();
		return (String[]) paths.toArray(new String[paths.size()]);
	}
	public Object getAdapter(Class adapter) {
		if (ICVSRepositoryLocation.class.equals(adapter)) return getRoot();
		return super.getAdapter(adapter);
	}

Method tagIsKnown.

Parameters:
remoteResource
Returns:
boolean
	public boolean tagIsKnown(ICVSRemoteResource remoteResource) {
		if (remoteResource instanceof ICVSRemoteFolder) {
			ICVSRemoteFolder folder = (ICVSRemoteFolderremoteResource;
			CVSTag[] tags = getAllKnownTags(path);
			CVSTag tag = folder.getTag();
			for (int i = 0; i < tags.lengthi++) {
				CVSTag knownTag = tags[i];
				if (knownTag.equals(tag)) return true;
			}
		}
		return false;
	}

This method is invoked whenever the refresh button in the RepositoriesView is pressed.
	void clearCache() {
		synchronized() {
			if ( != null)
				 = null;
		}
	}

Sets the root.

Parameters:
root The root to set
		this. = root;
	}
    /*
     * Set the last access time of the cache entry for the given path
     * as it was read from the persistent store.
     */
    /* package */ void setLastAccessedTime(String remotePathlong lastAccessTime) {
		if(entry != null){
		    entry.lastAccessTime = lastAccessTime;
		}
    }
New to GrepCode? Check out our FAQ X