Attachment #211659 for bug #366016

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.




/*******************************************************************************
 * Copyright (c) 2000, 2012 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

    public Object[] fetchChildren(Object o, IProgressMonitor monitor) throws TeamException {
        if (!(o instanceof ICVSRemoteFolder))
            return new Object[0];
		try {
			monitor = Policy.monitorFor(monitor);
			monitor.beginTask(NLS.bind(
					CVSUIMessages.RemoteFolderElement_fetchingRemoteChildren,
					new String[] { getLabel(o) }), 150);
			ICVSRemoteFolder folder = (ICVSRemoteFolder) o;
			ICVSRemoteResource[] cachedChildren = CVSUIPlugin
					.getPlugin()
					.getRepositoryManager()
					.getCachedChildrenForTag(folder.getRepository(), folder,
							folder.getTag(), Policy.subMonitorFor(monitor, 50));
			if (cachedChildren.length > 0) {
				return cachedChildren;
			}
			return folder.members(Policy.subMonitorFor(monitor, 100));
		} finally {
			monitor.done();
		}
    }

    public void fetchDeferredChildren(Object o, IElementCollector collector, IProgressMonitor monitor) {

		}
        try {
            monitor = Policy.monitorFor(monitor);
			monitor.beginTask(NLS.bind(
					CVSUIMessages.RemoteFolderElement_fetchingRemoteChildren,
					new String[] { getLabel(o) }), 150);
			ICVSRemoteFolder folder = (ICVSRemoteFolder) o;
			ICVSRemoteResource[] cachedChildren = CVSUIPlugin
					.getPlugin()
					.getRepositoryManager()
					.getCachedChildrenForTag(folder.getRepository(), folder,
							folder.getTag(), Policy.subMonitorFor(monitor, 50));
			if (cachedChildren.length > 0) {
				collector.add(cachedChildren, monitor);
				return;
			}
			FetchMembersOperation operation = new FetchMembersOperation(null, (ICVSRemoteFolder)o, collector);
			operation.run(Policy.subMonitorFor(monitor, 100));
        } catch (InvocationTargetException e) {
            handle(collector, e);
		} catch (InterruptedException e) {
			// Cancelled by the user;
		} catch (CVSException e) {
			 handle(collector, e);
		} finally {
            monitor.done();
        }




/*******************************************************************************
 * Copyright (c) 2000, 2012 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

		Set result = new HashSet();
		RepositoryRoot root = (RepositoryRoot)repositoryRoots.get(location.getLocation(false));
		if (root != null) {
			CVSTag[] tags = root.getAllKnownTags();
			for (int i = 0; i < tags.length; i++) {
				CVSTag tag = tags[i];
				if (tag.getType() == tagType)
					result.add(tag);
					CVSTag tag = tags[j];
					if (tag.getType() == tagType)
						result.add(tag);
				}
			}
		}
		return (CVSTag[])result.toArray(new CVSTag[0]);

			Set result = new HashSet();
			// Get the tags for the location
			RepositoryRoot root = getRepositoryRootFor(location);
			String[] paths = root.getRemoteChildrenForTag(null, tag);
			for (int i = 0; i < paths.length; i++) {
				String path = paths[i];
				ICVSRemoteFolder remote = root.getRemoteFolder(path, tag,
						Policy.subMonitorFor(monitor, 100));
				result.add(remote);
					result.add(remote);
				}
			}
			return (ICVSRemoteResource[])result.toArray(new ICVSRemoteResource[result.size()]);
		} finally {
			monitor.done();
		}
	}

	/**
	 * Returns a list of child resources for given folder that are known to
	 * contain given tag. If the return list is empty than given tag exists
	 * directly in given folder and its children should be retrieved directly
	 * from the repository.
	 * 
	 * @param location
	 *            CVS repository location
	 * @param parentFolder
	 *            folder to check tags for
	 * @param tag
	 * @param monitor
	 * @return a list of remote resources that are known to contain given tag or
	 *         empty list if resources should be retrieved from the repository
	 * @throws CVSException
	 */
	public ICVSRemoteResource[] getCachedChildrenForTag(
			ICVSRepositoryLocation location, ICVSRemoteFolder parentFolder,
			CVSTag tag, IProgressMonitor monitor) throws CVSException {
		if (tag == null || tag.getType() == CVSTag.HEAD
				|| tag.getType() == CVSTag.DATE) {
			// folders are kept in cache only for tags and versions
			return new ICVSRemoteResource[0];
		}
		monitor = Policy.monitorFor(monitor);
		Set result = new HashSet();
		RepositoryRoot root = getRepositoryRootFor(location);
		// if remote folder is null return the subfolders of repository root
		String[] paths = root.getRemoteChildrenForTag(
				parentFolder == null ? null : RepositoryRoot
						.getRemotePathFor(parentFolder), tag);
		monitor.beginTask(NLS
				.bind(CVSUIMessages.RemoteFolderElement_fetchingRemoteChildren,
						new String[] { NLS.bind(
								CVSUIMessages.RemoteFolderElement_nameAndTag,
								new String[] { parentFolder.getName(),
										tag.getName() }) }), 10 * paths.length);
		try {
			for (int i = 0; i < paths.length; i++) {
				String path = paths[i];
				ICVSRemoteFolder remote = root.getRemoteFolder(path, tag,
						Policy.subMonitorFor(monitor, 10));
				result.add(remote);
			}
			return (ICVSRemoteResource[]) result
					.toArray(new ICVSRemoteResource[result.size()]);
		} finally {
			monitor.done();
		}
	}
		
	/*
	 * Fetches tags from auto-refresh files if they exist. Then fetches tags from the user defined auto-refresh file




/*******************************************************************************
 * Copyright (c) 2000, 2012 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

import org.eclipse.team.internal.ccvs.ui.Policy;
import org.eclipse.team.internal.ccvs.ui.operations.RemoteLogOperation;
import org.eclipse.team.internal.ccvs.ui.operations.RemoteLogOperation.LogEntryCache;
import org.eclipse.team.internal.ccvs.ui.tags.TagSource;

public class RepositoryRoot extends PlatformObject {


	
	ICVSRepositoryLocation root;
	String name;
	TagCacheEntry rootTagCacheEntry = new TagCacheEntry(Path.ROOT.toString(),
			null);
	// Map of String (remote folder path) -> Set (file paths that are project relative)
	Map autoRefreshFiles = new HashMap();
	// Map of String (module name) -> ICVSRemoteFolder (that is a defined module)

	List dateTags = new ArrayList();
	
	public static class TagCacheEntry {
		String path;
		// Set of tags found for this path
	    Set tags = new HashSet();
		// String(last path segment) -> TagCacheEntry for child paths
		Map children = new HashMap();
		TagCacheEntry parent;
	    long lastAccessTime;
        private static final int CACHE_LIFESPAN_IN_DAYS = 7;

		public TagCacheEntry(String path, TagCacheEntry parent) {
			this.path = path;
			this.parent = parent;
			accessed();
		}

        public boolean isExpired() {
            long currentTime = System.currentTimeMillis();
            long ms = currentTime - lastAccessTime;

	 * 
	 * It is the responsibility of the caller to ensure that the given remote path is valid.
	 */
	public void addTags(String remotePath, CVSTag[] tags) {
		if (tags.length == 0) {
			return;
		}
		addDateTags(tags);
		addVersionAndBranchTags(remotePath, tags);
	}

		}
	}
	private void addVersionAndBranchTags(String remotePath, CVSTag[] tags) {
		TagCacheEntry entry = getTagCacheEntryFor(remotePath, true);
		entry.accessed();

		// Make sure there is a table for the ancestor that holds the tags
		TagCacheEntry entry = (TagCacheEntry)versionAndBranchTags.get(name);
		if (entry == null) {
		    entry = new TagCacheEntry();
			versionAndBranchTags.put(name, entry);
		} else {
		    entry.accessed();
		}
		
		// Store the tag with the appropriate ancestor
		for (int i = 0; i < tags.length; i++) {
			if (tags[i].getType() != CVSTag.DATE) {
				if (!getAllKnownTagsForParents(entry, true).contains(tags[i])) {
					removeTagFromChildrenChacheEntries(entry, tags[i], false);
					entry.tags.add(tags[i]);
				}
			}
		}
	}

	}

	private void removeVersionAndBranchTags(String remotePath, CVSTag[] tags) {
		TagCacheEntry entry = getTagCacheEntryFor(remotePath, false);
		// remove tags from this path and its children
		if (entry != null) {
			removeTagsFromChildrenChacheEntries(entry, tags, true);
		}

		// remove tags from all parents of this path
		entry = getKnownParentTagCacheEntryFor(remotePath);
		for (int i = 0; i < tags.length; i++) {
			TagCacheEntry currentEntry = entry;
			while (currentEntry != null) {
				if (currentEntry.tags.contains(tags[i])) {
					currentEntry.tags.remove(tags[i]);
					currentEntry.accessed();
					break;
				} else {
					currentEntry = currentEntry.parent;
				}
			}
		}
		cleanEmptyParents(entry);
	}

	private void cleanEmptyParents(TagCacheEntry entry) {
		if (entry.parent == null) {
			// we don't remove the root cache entry
			return;
		}
		if (entry.tags.isEmpty() && entry.children.isEmpty()) {
			entry.parent.children.remove(new Path(entry.path).lastSegment());
			entry.parent.accessed();
			entry.tags.remove(tags[i]);
		}
		cleanEmptyParents(entry.parent);
	}

	/**

	/**
	 * Fetches tags from auto-refresh files.
	 */
	public CVSTag[] refreshDefinedTags(ICVSFolder folder, boolean recurse,
			IProgressMonitor monitor) throws TeamException {
		monitor = Policy.monitorFor(monitor);
		monitor.beginTask(null, recurse ? 210 : 100);
		try {
			CVSTag[] tags = null;
			if (!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 asked to go deep
				// Try using the log command
				tags = fetchTagsUsingLog(folder,
						Policy.subMonitorFor(monitor, 50));
			}
			if (tags != null && tags.length > 0) {
				String remotePath = getRemotePathFor(folder);
				addTags(remotePath, tags);
				return tags;
			}
			if (recurse) {
				folder.fetchChildren(Policy.subMonitorFor(monitor, 10));
				ICVSResource[] children = folder
						.members(ICVSFolder.FOLDER_MEMBERS);
				for (int i = 0; i < children.length; i++) {
					refreshDefinedTags(
							(ICVSFolder) children[i],
							recurse,
							Policy.subMonitorFor(monitor, 100 / children.length));
				}
			}
			return tags;
		} finally {
			monitor.done();
		}
		monitor.done();
		return tags;
	}
	
    private CVSTag[] fetchTagsUsingLog(ICVSFolder folder, IProgressMonitor monitor) throws CVSException {
        LogEntryCache logEntries = new LogEntryCache();
        RemoteLogOperation operation = new RemoteLogOperation(null, new ICVSRemoteResource[] { asRemoteResource(folder) }, null, null, logEntries) {
            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] = Command.DO_NOT_RECURSE;

		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)
	 *
	 * @see TagSource
	 * @see #addTags(String, CVSTag[])
	 *
	 * @param remotePath
	 *            the remote folder path
	 * @return the cache key (path) for the given folder path
	 */
	private String getCachePathFor(String remotePath) {
		return remotePath;
	}

	private TagCacheEntry getTagCacheEntryFor(String remotePath, boolean create) {
		String path = getCachePathFor(remotePath);
		String[] segments = new Path(null, path).segments();
		TagCacheEntry currentTagCacheEntry = rootTagCacheEntry;
		for (int i = 0; i < segments.length; i++) {
			String segment = segments[i];
			if (currentTagCacheEntry.children.containsKey(segment)) {
				currentTagCacheEntry = (TagCacheEntry) currentTagCacheEntry.children
						.get(segment);
				continue;
			}
			if (!create) {
				return null;
			}
			TagCacheEntry newTagCacheEntry = new TagCacheEntry(new Path(null,
					path).removeLastSegments(segments.length - (i + 1))
					.toString(), currentTagCacheEntry);
			currentTagCacheEntry.children.put(segment, newTagCacheEntry);
			currentTagCacheEntry = newTagCacheEntry;
		}
		return currentTagCacheEntry;
	}

	private TagCacheEntry getKnownParentTagCacheEntryFor(String remotePath) {
		String path = getCachePathFor(remotePath);
		String[] segments = new Path(null, path).segments();
		TagCacheEntry currentTagCacheEntry = rootTagCacheEntry;
		for (int i = 0; i < segments.length; i++) {
			String segment = segments[i];
			if (currentTagCacheEntry.children.containsKey(segment)) {
				currentTagCacheEntry = (TagCacheEntry) currentTagCacheEntry.children
						.get(segment);
			} else {
				break; // we reached the last existing parent
			}
		}
		return currentTagCacheEntry;
	}

	private void removeTagsFromChildrenChacheEntries(TagCacheEntry entry,
			CVSTag[] tags, boolean includeThisEntry) {
		for (int i = 0; i < tags.length; i++) {
			removeTagFromChildrenChacheEntries(entry, tags[i], includeThisEntry);
		}
	}

	private void removeTagFromChildrenChacheEntries(TagCacheEntry entry,
			CVSTag tag, boolean includeThisEntry) {
		Iterator childrenIterator = entry.children.values().iterator();
		while (childrenIterator.hasNext()) {
			TagCacheEntry child = (TagCacheEntry) childrenIterator.next();
			removeTagFromChildrenChacheEntries(child, tag, true);
		}
		if (includeThisEntry) {
			entry.tags.remove(tag);
			entry.accessed();
			if (entry.tags.size() == 0 && entry.children.size() == 0
					&& entry.parent != null) {
				// remove this entry when the last tag was removed
				// keep the entry if there are any children that have tags
				Map newParentChildren = new HashMap();
				newParentChildren.putAll(entry.parent.children);
				newParentChildren.remove(new Path(entry.path).lastSegment());
				entry.parent.children = newParentChildren;
			}
		}
	}
	
	/**

				attributes.put(RepositoriesViewContentHandler.TYPE_ATTRIBUTE, RepositoriesViewContentHandler.DEFINED_MODULE_TYPE);
			}
			attributes.put(RepositoriesViewContentHandler.PATH_ATTRIBUTE, name);
			TagCacheEntry entry = (TagCacheEntry) getTagCacheEntryFor(path,
					false);
			boolean writeOutTags = entry != null && !entry.isExpired();
			if (writeOutTags)
			    attributes.put(RepositoriesViewContentHandler.LAST_ACCESS_TIME_ATTRIBUTE, Long.toString(entry.lastAccessTime));

		writer.startAndEndTag(s, attributes, true);
	}

	private Set getAllKnownTagsForParents(TagCacheEntry entry,
			boolean includeThisEntry) {
		Set tags = new HashSet();
		if (entry.parent != null) {
			tags.addAll(getAllKnownTagsForParents(entry.parent, true));
		}
		if (includeThisEntry) {
			tags.addAll(entry.tags);
		}
		return tags;
	}

	private Set getAllKnownTagsForChildren(TagCacheEntry entry,
			boolean includeThisEntry) {
		Set tags = new HashSet();
		Iterator childrenIterator = entry.children.values().iterator();
		while (childrenIterator.hasNext()) {
			TagCacheEntry child = (TagCacheEntry) childrenIterator.next();
			tags.addAll(getAllKnownTagsForChildren(child, true));
		}
		if (includeThisEntry) {
			tags.addAll(entry.tags);
		}
		return tags;
	}

	/**
	 * Method getKnownTags.
	 * @param remotePath
	 * @return CVSTag[]
	 */
	public CVSTag[] getAllKnownTags(String remotePath) {
		Set tags = getAllKnownTagsForParents(
				getKnownParentTagCacheEntryFor(remotePath), true);
		TagCacheEntry entry = getTagCacheEntryFor(remotePath, false);
		if (entry != null) {
			tags.addAll(getAllKnownTagsForChildren(entry, true));
			int len = tags1.length + tags2.length;
			CVSTag[] tags = new CVSTag[len];
			for(int i = 0; i < len; i++){
				if(i < tags1.length){
					tags[i] = tags1[i];
				}else{
					tags[i] = tags2[i-tags1.length];
				}
			}
			return tags;
		}
		return (CVSTag[]) tags.toArray(new CVSTag[tags.size()]);
	}

	public CVSTag[] getAllKnownTags() {
		Set tags = getAllKnownTagsForChildren(rootTagCacheEntry, true);
		return (CVSTag[]) tags.toArray(new CVSTag[tags.size()]);
	}

	public String[] getRemoteChildrenForTag(String remotePath, CVSTag tag) {
		TagCacheEntry entry;
		if (remotePath == null) {
			entry = rootTagCacheEntry;
		} else {
			entry = getTagCacheEntryFor(remotePath, false);
		}
		if (entry == null) {
			return new String[0];
		}

		Set paths = new HashSet();
		Iterator childrenIterator = entry.children.values().iterator();
		while (childrenIterator.hasNext()) {
			TagCacheEntry child = (TagCacheEntry) childrenIterator.next();
			if (getAllKnownTagsForChildren(child, true).contains(tag)) {
				paths.add(child.path);
			}
		}
		return (String[]) paths.toArray(new String[paths.size()]);
	}
	
	private Set getKnownRemotePaths(TagCacheEntry root) {
		Set paths = new HashSet();
		Iterator childrenIterator = root.children.values().iterator();
		while(childrenIterator.hasNext()){
			paths.addAll(getKnownRemotePaths((TagCacheEntry) childrenIterator.next()));
		}
		paths.add(root.path);
		return paths;
		
	}
	public String[] getKnownRemotePaths() {
		Set paths =  getKnownRemotePaths(rootTagCacheEntry);
		paths.addAll(autoRefreshFiles.keySet());
		return (String[]) paths.toArray(new String[paths.size()]);
	}

     * as it was read from the persistent store.
     */
    /* package */ void setLastAccessedTime(String remotePath, long lastAccessTime) {
		TagCacheEntry entry = getTagCacheEntryFor(remotePath, false);
		if(entry != null){
		    entry.lastAccessTime = lastAccessTime;
		}




/*******************************************************************************
 * Copyright (c) 2011, 2012 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


		// create project
		IProject project = getUniqueTestProject("TestBranchSubmoduleChildrenProject");
		buildResources(project, new String[] { "file1.txt" }, true);
		// share project under module
		shareProject(getRepository(), project,
				moduleName + "/" + project.getName(), DEFAULT_MONITOR);
		assertValidCheckout(project);

		// add some files
		addResources(project, new String[] { "file1.txt" }, true);

		// make branch
		CVSTag version = new CVSTag(versionName, CVSTag.VERSION);
		CVSTag branch = new CVSTag(branchName, CVSTag.BRANCH);

		makeBranch(new IResource[] { project }, version, branch, true);
		commitProject(project);

		// refresh branches
		CVSUIPlugin
				.getPlugin()
				.getRepositoryManager()
				.refreshDefinedTags(
						getRepository().getRemoteFolder(moduleName, null),
						true, true, DEFAULT_MONITOR);

		// check if module is the only branch child
		RemoteContentProvider rcp = new RemoteContentProvider();

		Object[] modules = rcp.getChildren(branches[0]);
		assertEquals(1, modules.length);
		assertEquals(moduleName, ((RemoteResource) modules[0]).getName());

		// refresh branches
		CVSUIPlugin
				.getPlugin()
				.getRepositoryManager()
				.refreshDefinedTags(
						getRepository().getRemoteFolder(moduleName, null),
						true, true, DEFAULT_MONITOR);

		// check if after refresh module is still the only branch child
		branches = rcp.getChildren(categories[1]);
		assertEquals(1, branches.length);
		assertEquals(branchName, ((CVSTagElement) (branches[0])).getTag()
				.getName());
		modules = rcp.getChildren(branches[0]);
		assertEquals(1, modules.length);
		assertEquals(moduleName, ((RemoteResource) modules[0]).getName());
	}

	public void testTagSubmoduleChildren() throws TeamException, CoreException {


		// create project
		IProject project = getUniqueTestProject("TestTagSubmoduleChildrenProject");
		buildResources(project, new String[] { "file1.txt" }, true);
		// share project under module
		shareProject(getRepository(), project,
				moduleName + "/" + project.getName(), DEFAULT_MONITOR);
		assertValidCheckout(project);

		// add some files
		addResources(project, new String[] { "file1.txt" }, true);

		// tag project
		CVSTag tag = new CVSTag(versionName, CVSTag.VERSION);

		tagProject(project, tag, true);

		// refresh branches
		CVSUIPlugin
				.getPlugin()
				.getRepositoryManager()
				.refreshDefinedTags(
						getRepository().getRemoteFolder(moduleName, null),
						true, true, DEFAULT_MONITOR);

		RemoteContentProvider rcp = new RemoteContentProvider();
		Object[] categories = rcp.getChildren(getRepositoryRoot());
		assertEquals(4, categories.length);

Return to bug 366016

Lines 1-5 Link Here

(-)a/bundles/org.eclipse.team.cvs.ui/src/org/eclipse/team/internal/ccvs/ui/repo/RepositoryManager.java (-16 / +61 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2007 IBM Corporation and others.	2	* Copyright (c) 2000, 2012 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 142-156 Link Here
142	Set result = new HashSet();	142	Set result = new HashSet();
143	RepositoryRoot root = (RepositoryRoot)repositoryRoots.get(location.getLocation(false));	143	RepositoryRoot root = (RepositoryRoot)repositoryRoots.get(location.getLocation(false));
144	if (root != null) {	144	if (root != null) {
145	String[] paths = root.getKnownRemotePaths();	145	CVSTag[] tags = root.getAllKnownTags();
146	for (int i = 0; i < paths.length; i++) {	146	for (int i = 0; i < tags.length; i++) {
147	String path = paths[i];	147	CVSTag tag = tags[i];
148	CVSTag[] tags = root.getAllKnownTags(path);	148	if (tag.getType() == tagType)
149	for (int j = 0; j < tags.length; j++) {	149	result.add(tag);
150	CVSTag tag = tags[j];
151	if (tag.getType() == tagType)
152	result.add(tag);
153	}
154	}	150	}
155	}	151	}
156	return (CVSTag[])result.toArray(new CVSTag[0]);	152	return (CVSTag[])result.toArray(new CVSTag[0]);
Lines 225-244 Link Here
225	Set result = new HashSet();	221	Set result = new HashSet();
226	// Get the tags for the location	222	// Get the tags for the location
227	RepositoryRoot root = getRepositoryRootFor(location);	223	RepositoryRoot root = getRepositoryRootFor(location);
228	String[] paths = root.getKnownRemotePaths();	224	String[] paths = root.getRemoteChildrenForTag(null, tag);
229	for (int i = 0; i < paths.length; i++) {	225	for (int i = 0; i < paths.length; i++) {
230	String path = paths[i];	226	String path = paths[i];
231	List tags = Arrays.asList(root.getAllKnownTags(path));	227	ICVSRemoteFolder remote = root.getRemoteFolder(path, tag,
232	if (tags.contains(tag)) {	228	Policy.subMonitorFor(monitor, 100));
233	ICVSRemoteFolder remote = root.getRemoteFolder(path, tag, Policy.subMonitorFor(monitor, 100));	229	result.add(remote);
234	result.add(remote);
235	}
236	}	230	}
237	return (ICVSRemoteResource[])result.toArray(new ICVSRemoteResource[result.size()]);	231	return (ICVSRemoteResource[])result.toArray(new ICVSRemoteResource[result.size()]);
238	} finally {	232	} finally {
239	monitor.done();	233	monitor.done();
240	}	234	}
241	}	235	}
		236
		237	/**
		238	* Returns a list of child resources for given folder that are known to
		239	* contain given tag. If the return list is empty than given tag exists
		240	* directly in given folder and its children should be retrieved directly
		241	* from the repository.
		242	*
		243	* @param location
		244	* CVS repository location
		245	* @param parentFolder
		246	* folder to check tags for
		247	* @param tag
		248	* @param monitor
		249	* @return a list of remote resources that are known to contain given tag or
		250	* empty list if resources should be retrieved from the repository
		251	* @throws CVSException
		252	*/
		253	public ICVSRemoteResource[] getCachedChildrenForTag(
		254	ICVSRepositoryLocation location, ICVSRemoteFolder parentFolder,
		255	CVSTag tag, IProgressMonitor monitor) throws CVSException {
		256	if (tag == null \|\| tag.getType() == CVSTag.HEAD
		257	\|\| tag.getType() == CVSTag.DATE) {
		258	// folders are kept in cache only for tags and versions
		259	return new ICVSRemoteResource[0];
		260	}
		261	monitor = Policy.monitorFor(monitor);
		262	Set result = new HashSet();
		263	RepositoryRoot root = getRepositoryRootFor(location);
		264	// if remote folder is null return the subfolders of repository root
		265	String[] paths = root.getRemoteChildrenForTag(
		266	parentFolder == null ? null : RepositoryRoot
		267	.getRemotePathFor(parentFolder), tag);
		268	monitor.beginTask(NLS
		269	.bind(CVSUIMessages.RemoteFolderElement_fetchingRemoteChildren,
		270	new String[] { NLS.bind(
		271	CVSUIMessages.RemoteFolderElement_nameAndTag,
		272	new String[] { parentFolder.getName(),
		273	tag.getName() }) }), 10 * paths.length);
		274	try {
		275	for (int i = 0; i < paths.length; i++) {
		276	String path = paths[i];
		277	ICVSRemoteFolder remote = root.getRemoteFolder(path, tag,
		278	Policy.subMonitorFor(monitor, 10));
		279	result.add(remote);
		280	}
		281	return (ICVSRemoteResource[]) result
		282	.toArray(new ICVSRemoteResource[result.size()]);
		283	} finally {
		284	monitor.done();
		285	}
		286	}
242		287
243	/*	288	/*
244	* Fetches tags from auto-refresh files if they exist. Then fetches tags from the user defined auto-refresh file	289	* Fetches tags from auto-refresh files if they exist. Then fetches tags from the user defined auto-refresh file

Lines 1-5 Link Here

(-)a/tests/org.eclipse.team.tests.cvs.core/src/org/eclipse/team/tests/ccvs/ui/RepositoriesViewTests.java (-14 / +31 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2011 IBM Corporation and others.	2	* Copyright (c) 2011, 2012 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 82-110 Link Here
82		82
83	// create project	83	// create project
84	IProject project = getUniqueTestProject("TestBranchSubmoduleChildrenProject");	84	IProject project = getUniqueTestProject("TestBranchSubmoduleChildrenProject");
85	buildResources(project, new String[] { "file1.txt" }, true);
86	// share project under module	85	// share project under module
87	shareProject(getRepository(), project,	86	shareProject(getRepository(), project,
88	moduleName + "/" + project.getName(), DEFAULT_MONITOR);	87	moduleName + "/" + project.getName(), DEFAULT_MONITOR);
89	assertValidCheckout(project);	88	assertValidCheckout(project);
90		89
91	// make some changes	90	// add some files
92	addResources(project, new String[] { "folder1/c.txt" }, false);	91	addResources(project, new String[] { "file1.txt" }, true);
93		92
94	// make branch	93	// make branch
95	CVSTag version = new CVSTag(versionName, CVSTag.VERSION);	94	CVSTag version = new CVSTag(versionName, CVSTag.VERSION);
96	CVSTag branch = new CVSTag(branchName, CVSTag.BRANCH);	95	CVSTag branch = new CVSTag(branchName, CVSTag.BRANCH);
97		96
98	makeBranch(new IResource[] { project }, version, branch, true);	97	makeBranch(new IResource[] { project }, version, branch, true);
99	commitProject(project);
100
101	// refresh branches
102	CVSUIPlugin
103	.getPlugin()
104	.getRepositoryManager()
105	.refreshDefinedTags(
106	getRepository().getRemoteFolder(moduleName, null),
107	true, true, DEFAULT_MONITOR);
108		98
109	// check if module is the only branch child	99	// check if module is the only branch child
110	RemoteContentProvider rcp = new RemoteContentProvider();	100	RemoteContentProvider rcp = new RemoteContentProvider();
Lines 118-123 Link Here
118	Object[] modules = rcp.getChildren(branches[0]);	108	Object[] modules = rcp.getChildren(branches[0]);
119	assertEquals(1, modules.length);	109	assertEquals(1, modules.length);
120	assertEquals(moduleName, ((RemoteResource) modules[0]).getName());	110	assertEquals(moduleName, ((RemoteResource) modules[0]).getName());
		111
		112	// refresh branches
		113	CVSUIPlugin
		114	.getPlugin()
		115	.getRepositoryManager()
		116	.refreshDefinedTags(
		117	getRepository().getRemoteFolder(moduleName, null),
		118	true, true, DEFAULT_MONITOR);
		119
		120	// check if after refresh module is still the only branch child
		121	branches = rcp.getChildren(categories[1]);
		122	assertEquals(1, branches.length);
		123	assertEquals(branchName, ((CVSTagElement) (branches[0])).getTag()
		124	.getName());
		125	modules = rcp.getChildren(branches[0]);
		126	assertEquals(1, modules.length);
		127	assertEquals(moduleName, ((RemoteResource) modules[0]).getName());
121	}	128	}
122		129
123	public void testTagSubmoduleChildren() throws TeamException, CoreException {	130	public void testTagSubmoduleChildren() throws TeamException, CoreException {
Lines 128-144 Link Here
128		135
129	// create project	136	// create project
130	IProject project = getUniqueTestProject("TestTagSubmoduleChildrenProject");	137	IProject project = getUniqueTestProject("TestTagSubmoduleChildrenProject");
131	buildResources(project, new String[] { "file1.txt" }, true);
132	// share project under module	138	// share project under module
133	shareProject(getRepository(), project,	139	shareProject(getRepository(), project,
134	moduleName + "/" + project.getName(), DEFAULT_MONITOR);	140	moduleName + "/" + project.getName(), DEFAULT_MONITOR);
135	assertValidCheckout(project);	141	assertValidCheckout(project);
136		142
		143	// add some files
		144	addResources(project, new String[] { "file1.txt" }, true);
		145
137	// tag project	146	// tag project
138	CVSTag tag = new CVSTag(versionName, CVSTag.VERSION);	147	CVSTag tag = new CVSTag(versionName, CVSTag.VERSION);
139		148
140	tagProject(project, tag, true);	149	tagProject(project, tag, true);
141		150
		151	// refresh branches
		152	CVSUIPlugin
		153	.getPlugin()
		154	.getRepositoryManager()
		155	.refreshDefinedTags(
		156	getRepository().getRemoteFolder(moduleName, null),
		157	true, true, DEFAULT_MONITOR);
		158
142	RemoteContentProvider rcp = new RemoteContentProvider();	159	RemoteContentProvider rcp = new RemoteContentProvider();
143	Object[] categories = rcp.getChildren(getRepositoryRoot());	160	Object[] categories = rcp.getChildren(getRepositoryRoot());
144	assertEquals(4, categories.length);	161	assertEquals(4, categories.length);