Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
Copyright (c) 2000, 2006 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.subscriber;
 
 import java.util.Date;
 
Collector that fetches the log for incoming CVS change sets
 
 
     /*
      * Constant used to add the collector to the configuration of a page so
      * it can be accessed by the CVS custom actions
      */
     public static final String CVS_CHECKED_IN_COLLECTOR = . + ".CVSCheckedInCollector"//$NON-NLS-1$
     
     /*
      * Constant used to store the log entry handler in the configuration so it can
      * be kept around over layout changes
      */
     private static final String LOG_ENTRY_HANDLER = . + ".LogEntryHandler"//$NON-NLS-1$
     
     
     boolean disposed = false;
 
     private LogEntryCache logEntryCache;
     
 	/* *****************************************************************************
 	 * Special sync info that has its kind already calculated.
 	 */
 	public class CVSUpdatableSyncInfo extends CVSSyncInfo {
 		public int kind;
 		public CVSUpdatableSyncInfo(int kindIResource localIResourceVariant baseIResourceVariant remoteSubscriber s) {
 			super(localbaseremotes);
 			this. = kind;
 		}
 
 		protected int calculateKind() throws TeamException {
 			return ;
 		}
 	}
 	
 	private class DefaultCheckedInChangeSet extends CheckedInChangeSet {
 
 	    private Date date = new Date();
 	    
         public DefaultCheckedInChangeSet(String name) {
             setName(name);
         }
         /* (non-Javadoc)
          * @see org.eclipse.team.core.subscribers.CheckedInChangeSet#getAuthor()
          */
         public String getAuthor() {
             return ""//$NON-NLS-1$
         }
 
         /* (non-Javadoc)
          * @see org.eclipse.team.core.subscribers.CheckedInChangeSet#getDate()
          */
         public Date getDate() {
             return ;
         }
 
         /* (non-Javadoc)
          * @see org.eclipse.team.core.subscribers.ChangeSet#getComment()
         */
        public String getComment() {
            return ""//$NON-NLS-1$
        }
	    
	}
	private class CVSCheckedInChangeSet extends CheckedInChangeSet {
        private final ILogEntry entry;
        public CVSCheckedInChangeSet(ILogEntry entry) {
            this. = entry;
    		Date date = entry.getDate();
    		String comment = Util.flattenText(entry.getComment());
    		if (date == null) {
    			setName("["+entry.getAuthor()+ "] " + comment); //$NON-NLS-1$ //$NON-NLS-2$
    		} else {
    			String dateString = DateFormat.getDateTimeInstance().format(date);
	    		setName("["+entry.getAuthor()+ "] (" + dateString +") " + comment); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ 
    		}
        }
        
        /* (non-Javadoc)
         * @see org.eclipse.team.core.subscribers.CheckedInChangeSet#getAuthor()
         */
        public String getAuthor() {
            return .getAuthor();
        }
        /* (non-Javadoc)
         * @see org.eclipse.team.core.subscribers.CheckedInChangeSet#getDate()
         */
        public Date getDate() {
            return .getDate();
        }
        /* (non-Javadoc)
         * @see org.eclipse.team.core.subscribers.ChangeSet#getComment()
         */
        public String getComment() {
            return .getComment();
        }
	}
    public CVSChangeSetCollector(ISynchronizePageConfiguration configuration) {
        super(configuration);
        configuration.setProperty(.this);
    }
    public synchronized LogEntryCacheUpdateHandler getLogEntryHandler() {
        if (handler == null) {
            handler = initializeLogEntryHandler(getConfiguration());
        }
        handler.setListener(this);
        return handler;
    }
    
    /*
     * Initialize the log entry handler and place it in the configuration
     */
        final LogEntryCacheUpdateHandler logEntryHandler = new LogEntryCacheUpdateHandler(configuration);
        configuration.setProperty(logEntryHandler);
        // Use an action group to get notified when the configuration is disposed
        configuration.addActionContribution(new SynchronizePageActionGroup() {
            public void dispose() {
                super.dispose();
                LogEntryCacheUpdateHandler handler = (LogEntryCacheUpdateHandler)configuration.getProperty();
                if (handler != null) {
                    handler.shutdown();
                    configuration.setProperty(null);
                }
            }
        });
        // It is possible that the configuration has been disposed concurrently by another thread
        // TODO
        return logEntryHandler;
    }
    /* (non-Javadoc)
     * @see org.eclipse.team.core.subscribers.SyncInfoSetChangeSetCollector#add(org.eclipse.team.core.synchronize.SyncInfo[])
     */
    protected void add(SyncInfo[] infos) {
        LogEntryCacheUpdateHandler handler = getLogEntryHandler();
        if (handler != null)
            try {
                handler.fetch(infos);
            } catch (CVSException e) {
                getConfiguration().getSyncInfoSet().addError(new TeamStatus(.., 0, e.getMessage(), enull));
            }
    }
    /* (non-Javadoc)
     * @see org.eclipse.team.ui.synchronize.SyncInfoSetChangeSetCollector#reset(org.eclipse.team.core.synchronize.SyncInfoSet)
     */
    public void reset(SyncInfoSet seedSet) {
        // Notify that handler to stop any fetches in progress
        LogEntryCacheUpdateHandler handler = getLogEntryHandler();
        if (handler != null) {
            handler.stopFetching();
        }
        super.reset(seedSet);
    }
	/* (non-Javadoc)
	 * @see org.eclipse.team.ui.synchronize.views.HierarchicalModelProvider#dispose()
	 */
	public void dispose() {
	    // No longer listen for log entry changes
	    // (The handler is disposed with the page)
	     = true;
        LogEntryCacheUpdateHandler handler = getLogEntryHandler();
        if (handler != nullhandler.setListener(null);
		 = null;
		super.dispose();
	}

Fetch the log histories for the remote changes and use this information to add each resource to an appropriate commit set.
    private void handleRemoteChanges(final SyncInfo[] infosfinal LogEntryCache logEntriesfinal IProgressMonitor monitor) {
        performUpdate(new IWorkspaceRunnable() {
            public void run(IProgressMonitor monitor) {
                addLogEntries(infoslogEntriesmonitor);
            }
        }, true  /* preserver expansion */monitor);
    }
    /*
	 * Add the following sync info elements to the viewer. It is assumed that these elements have associated
	 * log entries cached in the log operation.
	 */
	private void addLogEntries(SyncInfo[] commentInfosLogEntryCache logsIProgressMonitor monitor) {
		try {
			monitor.beginTask(nullcommentInfos.length * 10);
			if (logs != null) {
				for (int i = 0; i < commentInfos.lengthi++) {
					addSyncInfoToCommentNode(commentInfos[i], logs);
					monitor.worked(10);
				}
			}
finally {
			monitor.done();
		}
	}
	/*
	 * Create a node for the given sync info object. The logs should contain the log for this info.
	 * 
	 * @param info the info for which to create a node in the model
	 * @param log the cvs log for this node
	 */
	private void addSyncInfoToCommentNode(SyncInfo infoLogEntryCache logs) {
	    if (handler != null) {
			ICVSRemoteResource remoteResource = handler.getRemoteResource(info);
			if(handler.getSubscriber() instanceof CVSCompareSubscriber && remoteResource != null) {
				addMultipleRevisions(infologsremoteResource);
else {
				addSingleRevision(infologsremoteResource);
			}
	    }
	}
	/*
	 * Add a single log entry to the model.
	 * 
	 * @param info
	 * @param logs
	 * @param remoteResource
	 */
	private void addSingleRevision(SyncInfo infoLogEntryCache logsICVSRemoteResource remoteResource) {
		ILogEntry logEntry = logs.getLogEntry(remoteResource);
	    if (remoteResource != null && !remoteResource.isFolder()) {
			// For incoming deletions grab the comment for the latest on the same branch
			// which is now in the attic.
			try {
				String remoteRevision = ((ICVSRemoteFileremoteResource).getRevision();
				if (isDeletedRemotely(info)) {
					ILogEntry[] logEntries = logs.getLogEntries(remoteResource);
					for (int i = 0; i < logEntries.lengthi++) {
						ILogEntry entry = logEntries[i];
						String revision = entry.getRevision();
						if (entry.isDeletion() && ResourceSyncInfo.isLaterRevision(revisionremoteRevision)) {
							logEntry = entry;
						}
					}
				}
catch (TeamException e) {
				// continue and skip deletion checks
			}
	    }
		addRemoteChange(inforemoteResourcelogEntry);
	}
    /*
	 * Add multiple log entries to the model.
	 * 
	 * @param info
	 * @param logs
	 * @param remoteResource
	 */
	private void addMultipleRevisions(SyncInfo infoLogEntryCache logsICVSRemoteResource remoteResource) {
		ILogEntry[] logEntries = logs.getLogEntries(remoteResource);
		if(logEntries == null || logEntries.length == 0) {
			// If for some reason we don't have a log entry, try the latest
			// remote.
			addRemoteChange(infonullnull);
else {
			for (int i = 0; i < logEntries.lengthi++) {
				ILogEntry entry = logEntries[i];
				addRemoteChange(inforemoteResourceentry);
			}
		}
	}
	private boolean isDeletedRemotely(SyncInfo info) {
		int kind = info.getKind();
		if(kind == (. | .)) return true;
		if(SyncInfo.getDirection(kind) == . && info.getRemote() == nullreturn true;
		return false;
	}
    /*
     * Add the remote change to an incoming commit set
     */
    private void addRemoteChange(SyncInfo infoICVSRemoteResource remoteResourceILogEntry logEntry) {
        if (return;
        LogEntryCacheUpdateHandler handler = getLogEntryHandler();
        if(handler != null && remoteResource != null && logEntry != null && handler.isRemoteChange(info)) {
	        if(requiresCustomSyncInfo(inforemoteResourcelogEntry)) {
	        	info = new CVSUpdatableSyncInfo(info.getKind(), info.getLocal(), info.getBase(), (RemoteResource)logEntry.getRemoteFile(), ((CVSSyncInfo)info).getSubscriber());
	        	try {
	        		info.init();
	        	} catch (TeamException e) {
	        		// this shouldn't happen, we've provided our own calculate kind
	        	}
	        }
	        // Only add the info if the base and remote differ
	        IResourceVariant base = info.getBase();
	        IResourceVariant remote = info.getRemote();
	        if ((base == null && remote != null) || (remote == null && base != null) || (remote != null && base != null && !base.equals(remote))) {
	            synchronized(this) {
			        CheckedInChangeSet set = getChangeSetFor(logEntry);
			        if (set == null) {
			            set = createChangeSetFor(logEntry);
			        	add(set);
			        }
			        set.add(info);
	            }
	        }
        } else {
            // The info was not retrieved for the remote change for some reason.
            // Add the node to the root
            addToDefaultSet(info);
        }
    }
    
    private void addToDefaultSet(String nameSyncInfo info) {
        CheckedInChangeSet set;
        synchronized(this) {
	        set = getChangeSetFor(name);
	        if (set == null) {
	            set = createDefaultChangeSet(name);
	        	add(set);
	        }
	        set.add(info);
        }
    }
    
        return new DefaultCheckedInChangeSet(name);
    }
    private CheckedInChangeSet createChangeSetFor(ILogEntry logEntry) {
        return new CVSCheckedInChangeSet(logEntry);
    }
    private CheckedInChangeSet getChangeSetFor(ILogEntry logEntry) {
    	ChangeSet[] sets = getSets();
        for (int i = 0; i < sets.lengthi++) {
        	ChangeSet set = sets[i];
            if (set instanceof CheckedInChangeSet &&
                    set.getComment().equals(logEntry.getComment()) &&
                    ((CheckedInChangeSet)set).getAuthor().equals(logEntry.getAuthor())) {
                return (CheckedInChangeSet)set;
            }
        }
        return null;
    }
    private CheckedInChangeSet getChangeSetFor(String name) {
        ChangeSet[] sets = getSets();
        for (int i = 0; i < sets.lengthi++) {
            ChangeSet set = sets[i];
            if (set.getName().equals(name)) {
                return (CheckedInChangeSet)set;
            }
        }
        return null;
    }
    
    private boolean requiresCustomSyncInfo(SyncInfo infoICVSRemoteResource remoteResourceILogEntry logEntry) {
		// Only interested in non-deletions
		if (logEntry.isDeletion() || !(info instanceof CVSSyncInfo)) return false;
		// Only require a custom sync info if the remote of the sync info
		// differs from the remote in the log entry
		IResourceVariant remote = info.getRemote();
		if (remote == nullreturn true;
		return !remote.equals(remoteResource);
	}
    
    /* (non-Javadoc)
     * @see org.eclipse.team.ui.synchronize.SyncInfoSetChangeSetCollector#waitUntilDone(org.eclipse.core.runtime.IProgressMonitor)
     */
    public void waitUntilDone(IProgressMonitor monitor) {
        super.waitUntilDone(monitor);
		monitor.worked(1);
		// wait for the event handler to process changes.
        LogEntryCacheUpdateHandler handler = getLogEntryHandler();
        if (handler != null) {
			while(handler.getEventHandlerJob().getState() != .) {
				monitor.worked(1);
				try {
					Thread.sleep(10);		
catch (InterruptedException e) {
				}
				Policy.checkCanceled(monitor);
			}
        }
		monitor.worked(1);
    }
    /* (non-Javadoc)
     * @see org.eclipse.team.internal.ccvs.ui.subscriber.LogEntryCacheUpdateHandler.ILogsFetchedListener#logEntriesFetched(org.eclipse.team.core.synchronize.SyncInfoSet, org.eclipse.core.runtime.IProgressMonitor)
     */
    public void logEntriesFetched(SyncInfoSet setLogEntryCache logEntryCacheIProgressMonitor monitor) {
        if (return;
        // Hold on to the cache so we can use it while commit sets are visible
        this. = logEntryCache;
        handleRemoteChanges(set.getSyncInfos(), logEntryCachemonitor);
    }
        if ( != null)
            return .getImmediatePredecessor(file);
        return null;
    }
	protected void initializeSets() {
		// Nothing to do
	}
New to GrepCode? Check out our FAQ X