blob: f72362c6a4acf059a485ebbbaa4381d849ea5a5d (
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
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
|
/*******************************************************************************
* Copyright (c) 2000, 2017 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 java.util.*;
import org.eclipse.core.runtime.*;
/**
* An abstract class that managers a collection of change sets.
*/
public abstract class ChangeSetManager {
private ListenerList<IChangeSetChangeListener> listeners = new ListenerList<IChangeSetChangeListener>(ListenerList.IDENTITY);
private Set<ChangeSet> sets;
private boolean initializing;
/**
* Return the list of listeners registered with this change set manager.
* @return the list of listeners registered with this change set manager
*/
protected Object[] getListeners() {
return listeners.getListeners();
}
/**
* Method that can be invoked by subclasses when the name of
* a managed change set changes.
* @param set the set whose title has changed
*/
protected void fireNameChangedEvent(final ChangeSet set) {
if (initializing)
return;
if (contains(set)) {
Object[] listeners = getListeners();
for (int i = 0; i < listeners.length; i++) {
final IChangeSetChangeListener listener = (IChangeSetChangeListener)listeners[i];
SafeRunner.run(new ISafeRunnable() {
@Override
public void handleException(Throwable exception) {
// Exceptions are logged by the platform
}
@Override
public void run() throws Exception {
listener.nameChanged(set);
}
});
}
}
}
/**
* Method which allows subclasses to notify listeners that the default
* set has changed.
* @param oldSet the previous default
* @param defaultSet the new default
*/
protected void fireDefaultChangedEvent(final ChangeSet oldSet, final ChangeSet defaultSet) {
if (initializing)
return;
Object[] listeners = getListeners();
for (int i = 0; i < listeners.length; i++) {
final IChangeSetChangeListener listener = (IChangeSetChangeListener)listeners[i];
SafeRunner.run(new ISafeRunnable() {
@Override
public void handleException(Throwable exception) {
// Exceptions are logged by the platform
}
@Override
public void run() throws Exception {
listener.defaultSetChanged(oldSet, defaultSet);
}
});
}
}
/**
* Add the set to the list of active sets.
* @param set the set to be added
*/
public void add(final ChangeSet set) {
if (!contains(set)) {
internalGetSets().add(set);
handleSetAdded(set);
}
}
/**
* Handle the set addition by notifying listeners.
* @param set the added set
*/
protected void handleSetAdded(final ChangeSet set) {
if (initializing)
return;
Object[] listeners = getListeners();
for (int i = 0; i < listeners.length; i++) {
final IChangeSetChangeListener listener = (IChangeSetChangeListener)listeners[i];
SafeRunner.run(new ISafeRunnable() {
@Override
public void handleException(Throwable exception) {
// Exceptions are logged by the platform
}
@Override
public void run() throws Exception {
listener.setAdded(set);
}
});
}
}
/**
* Remove the set from the list of active sets.
* @param set the set to be removed
*/
public void remove(final ChangeSet set) {
if (contains(set)) {
internalGetSets().remove(set);
handleSetRemoved(set);
}
}
/**
* Handle the set removal by notifying listeners.
* @param set the removed set
*/
protected void handleSetRemoved(final ChangeSet set) {
if (initializing)
return;
Object[] listeners = getListeners();
for (int i = 0; i < listeners.length; i++) {
final IChangeSetChangeListener listener = (IChangeSetChangeListener)listeners[i];
SafeRunner.run(new ISafeRunnable() {
@Override
public void handleException(Throwable exception) {
// Exceptions are logged by the platform
}
@Override
public void run() throws Exception {
listener.setRemoved(set);
}
});
}
}
/**
* Return whether the manager contains the given commit set
* @param set the commit set being tested
* @return whether the set is contained in the manager's list of active sets
*/
public boolean contains(ChangeSet set) {
return internalGetSets().contains(set);
}
/**
* Add the listener to the set of registered listeners.
* @param listener the listener to be added
*/
public void addListener(IChangeSetChangeListener listener) {
listeners.add(listener);
}
/**
* Remove the listener from the set of registered listeners.
* @param listener the listener to remove
*/
public void removeListener(IChangeSetChangeListener listener) {
listeners.remove(listener);
}
/**
* Return the list of active commit sets.
* @return the list of active commit sets
*/
public ChangeSet[] getSets() {
Set<ChangeSet> sets = internalGetSets();
return sets.toArray(new ChangeSet[sets.size()]);
}
/**
* Dispose of any resources maintained by the manager
*/
public void dispose() {
// Nothing to do
}
/**
* Fire resource change notifications to the listeners.
* @param changeSet
* @param allAffectedResources
*/
protected void fireResourcesChangedEvent(final ChangeSet changeSet, final IPath[] allAffectedResources) {
if (initializing)
return;
Object[] listeners = getListeners();
for (int i = 0; i < listeners.length; i++) {
final IChangeSetChangeListener listener = (IChangeSetChangeListener)listeners[i];
SafeRunner.run(new ISafeRunnable() {
@Override
public void handleException(Throwable exception) {
// Exceptions are logged by the platform
}
@Override
public void run() throws Exception {
listener.resourcesChanged(changeSet, allAffectedResources);
}
});
}
}
private Set<ChangeSet> internalGetSets() {
if (sets == null) {
sets = Collections.synchronizedSet(new HashSet<>());
try {
initializing = true;
initializeSets();
} finally {
initializing = false;
}
}
return sets;
}
/**
* Initialize the sets contained in this manager.
* This method is called the first time the sets are accessed.
*/
protected abstract void initializeSets();
public boolean isInitialized() {
return sets != null;
}
}
|
