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
|
/*******************************************************************************
* Copyright (c) 2006, 2017 IBM Corporation and others.
*
* This program and the accompanying materials
* are made available under the terms of the Eclipse Public License 2.0
* which accompanies this distribution, and is available at
* https://www.eclipse.org/legal/epl-2.0/
*
* SPDX-License-Identifier: EPL-2.0
*
* Contributors:
* IBM Corporation - initial API and implementation
* Eugene Kuleshov (eu@md.pp.ru) - Bug 138152 Improve sync job status reporting
*******************************************************************************/
package org.eclipse.team.internal.ui.synchronize;
import java.util.HashMap;
import java.util.Map;
import org.eclipse.core.resources.mapping.ResourceMapping;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.team.core.diff.IDiff;
import org.eclipse.team.core.diff.IDiffChangeEvent;
import org.eclipse.team.core.diff.IDiffChangeListener;
import org.eclipse.team.core.diff.IDiffTree;
import org.eclipse.team.core.diff.IThreeWayDiff;
import org.eclipse.team.core.mapping.IResourceDiffTree;
import org.eclipse.team.core.mapping.ISynchronizationContext;
import org.eclipse.team.internal.core.mapping.GroupProgressMonitor;
import org.eclipse.team.ui.synchronize.ISynchronizeParticipant;
import org.eclipse.team.ui.synchronize.ModelSynchronizeParticipant;
public class RefreshModelParticipantJob extends RefreshParticipantJob {
private final ResourceMapping[] mappings;
private IProgressMonitor group;
private int groupTicks;
public class ChangeDescription implements IChangeDescription, IDiffChangeListener {
Map<IPath, IDiff> changes = new HashMap<>();
@Override
public int getChangeCount() {
return changes.size();
}
@Override
public void diffsChanged(IDiffChangeEvent event, IProgressMonitor monitor) {
IDiff[] additions = event.getAdditions();
for (int i = 0; i < additions.length; i++) {
IDiff node = additions[i];
changes.put(node.getPath(), node);
}
IDiff[] changed = event.getChanges();
for (int i = 0; i < changed.length; i++) {
IDiff node = changed[i];
changes.put(node.getPath(), node);
}
}
@Override
public void propertyChanged(IDiffTree tree, int property, IPath[] paths) {
// Do nothing
}
}
public RefreshModelParticipantJob(ISynchronizeParticipant participant, String jobName, String taskName, ResourceMapping[] mappings, IRefreshSubscriberListener listener) {
super(participant, jobName, taskName, listener);
this.mappings = mappings;
}
@Override
protected void doRefresh(IChangeDescription changeListener,
IProgressMonitor monitor) throws CoreException {
ISynchronizationContext context = ((ModelSynchronizeParticipant)getParticipant()).getContext();
try {
context.getDiffTree().addDiffChangeListener((ChangeDescription)changeListener);
// TODO: finer grained refresh
context.refresh(mappings, monitor);
// Wait for any asynchronous updating to complete
try {
Job.getJobManager().join(context, monitor);
} catch (InterruptedException e) {
// Ignore
}
} finally {
context.getDiffTree().removeDiffChangeListener((ChangeDescription)changeListener);
}
}
@Override
protected int getChangeCount() {
return ((ModelSynchronizeParticipant)getParticipant()).getContext().getDiffTree().size();
}
@Override
protected int getIncomingChangeCount() {
IResourceDiffTree diffTree = ((ModelSynchronizeParticipant)getParticipant()).getContext().getDiffTree();
return (int) diffTree.countFor(IThreeWayDiff.INCOMING, IThreeWayDiff.DIRECTION_MASK);
}
@Override
protected int getOutgoingChangeCount() {
IResourceDiffTree diffTree = ((ModelSynchronizeParticipant)getParticipant()).getContext().getDiffTree();
return (int) diffTree.countFor(IThreeWayDiff.OUTGOING, IThreeWayDiff.DIRECTION_MASK);
}
@Override
protected void handleProgressGroupSet(IProgressMonitor group, int ticks) {
this.group = group;
this.groupTicks = ticks;
}
@Override
protected IChangeDescription createChangeDescription() {
return new ChangeDescription();
}
@Override
public boolean belongsTo(Object family) {
if (family instanceof RefreshModelParticipantJob) {
RefreshModelParticipantJob rmpj = (RefreshModelParticipantJob) family;
return rmpj.getParticipant() == getParticipant();
}
if (family == getParticipant())
return true;
return super.belongsTo(family);
}
@Override
public IStatus run(IProgressMonitor monitor) {
if (group != null)
monitor = wrapMonitorWithGroup(monitor);
return super.run(monitor);
}
private IProgressMonitor wrapMonitorWithGroup(IProgressMonitor monitor) {
return new GroupProgressMonitor(monitor, group, groupTicks);
}
}
|
