blob: 9c71fc2a295e064337ea918e6d13a5e2e2402bec (
plain) (
blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
|
/*******************************************************************************
* 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.core.subscribers;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IWorkspaceRunnable;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.team.core.synchronize.*;
/**
* This collector maintains a {@link SyncInfoSet} for a particular team subscriber keeping
* it up-to-date with both incoming changes and outgoing changes as they occur for
* resources in the workspace. The collector can be configured to consider all the subscriber's
* roots or only a subset.
* <p>
* The advantage of this collector is that it processes both resource and team
* subscriber deltas in a background thread.
* </p>
* @since 3.0
*/
public final class WorkingSetFilteredSyncInfoCollector {
private WorkingSetSyncSetInput workingSetInput;
private SyncSetInputFromSyncSet filteredInput;
private SubscriberEventHandler eventHandler;
/**
* Create a collector that collects out-of-sync resources that are children of
* the given roots. If the roots are <code>null</code>, then all out-of-sync resources
* from the subscriber are collected. An empty array of roots will cause no resources
* to be collected. The <code>start()</code> method must be called after creation
* to rpime the collector's sync sets.
* @param collector the subscriber's collector
* @param roots the roots of the out-of-sync resources to be collected
*/
public WorkingSetFilteredSyncInfoCollector(SubscriberSyncInfoCollector collector, IResource[] roots) {
this.eventHandler = collector.getEventHandler();
// TODO: optimize and don't use working set if no roots are passed in
workingSetInput = new WorkingSetSyncSetInput((SubscriberSyncInfoSet)collector.getSyncInfoSet(), getEventHandler());
filteredInput = new SyncSetInputFromSyncSet(workingSetInput.getSyncSet(), getEventHandler());
filteredInput.setFilter(new SyncInfoFilter() {
public boolean select(SyncInfo info, IProgressMonitor monitor) {
return true;
}
});
}
/**
* Return the set that provides access to the out-of-sync resources for the collector's
* subscriber that are descendants of the roots for the collector,
* are in the collector's working set and match the collectors filter.
* @return a SyncInfoSet containing out-of-sync resources
*/
public SyncInfoTree getSyncInfoTree() {
return filteredInput.getSyncSet();
}
/**
* Clears this collector's sync info sets and causes them to be recreated from the
* associated <code>Subscriber</code>. The reset will occur in the background. If the
* caller wishes to wait for the reset to complete, they should call
* waitForCollector(IProgressMonitor).
*/
public void reset() {
workingSetInput.reset();
}
/**
* Disposes of the background job associated with this collector and deregisters
* all it's listeners. This method must be called when the collector is no longer
* referenced and could be garbage collected.
*/
public void dispose() {
workingSetInput.disconnect();
if(filteredInput != null) {
filteredInput.disconnect();
}
}
/**
* Return the event handler that performs the background processing for this collector.
* The event handler also serves the purpose of serializing the modifications and adjustments
* to the collector's sync sets in order to ensure that the state of the sets is kept
* consistent.
* @return Returns the eventHandler.
*/
protected SubscriberEventHandler getEventHandler() {
return eventHandler;
}
/**
* Set the filter for this collector. Only elements that match the filter will
* be in the out sync info set.
* @param filter the sync info filter
*/
public void setFilter(SyncInfoFilter filter) {
filteredInput.setFilter(filter);
filteredInput.reset();
}
/**
* Return a <code>SyncInfoSet</code> that contains the out-of-sync elements
* from the subsciber sync info set filtered
* by the working set resources but not the collector's <code>SyncInfoFilter</code>.
* @return a <code>SyncInfoSet</code>
*/
public SyncInfoSet getWorkingSetSyncInfoSet() {
return workingSetInput.getSyncSet();
}
/**
* Run the given runnable in the event handler of the collector
* @param runnable a runnable
*/
public void run(IWorkspaceRunnable runnable) {
eventHandler.run(runnable, true /* front of queue */);
}
}
|
