projects / deliverable / tracecompass.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
lttng: Update copyright headers
[deliverable/tracecompass.git] / org.eclipse.linuxtools.tmf.ui / src / org / eclipse / linuxtools / tmf / ui / views / uml2sd / loader / TmfUml2SDSyncLoader.java
CommitLineData
73005152 1/**********************************************************************
df0b8ff4 2 * Copyright (c) 2011, 2012 Ericsson
a55887ca 3 *
73005152
BH		 4 * All rights reserved. This program and the accompanying materials are
5 * made available under the terms of the Eclipse Public License v1.0 which
6 * accompanies this distribution, and is available at
7 * http://www.eclipse.org/legal/epl-v10.html
a55887ca
AM		 8 *
9 * Contributors:
73005152
BH		 10 * Bernd Hufmann - Initial API and implementation
11 **********************************************************************/
df0b8ff4 12package org.eclipse.linuxtools.tmf.ui.views.uml2sd.loader;
73005152
BH		 13
14import java.util.ArrayList;
15import java.util.HashMap;
16import java.util.List;
eb63f5ff 17import java.util.Map;
73005152
BH		 18import java.util.concurrent.CopyOnWriteArrayList;
19import java.util.concurrent.locks.ReentrantLock;
20
21import org.eclipse.core.runtime.IProgressMonitor;
22import org.eclipse.core.runtime.IStatus;
23import org.eclipse.core.runtime.Status;
24import org.eclipse.core.runtime.jobs.Job;
25import org.eclipse.jface.viewers.ISelection;
26import org.eclipse.jface.viewers.StructuredSelection;
8fd82db5 27import org.eclipse.linuxtools.internal.tmf.ui.Activator;
6c13869b 28import org.eclipse.linuxtools.tmf.core.component.TmfComponent;
13e157b1
MK		 29import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
30import org.eclipse.linuxtools.tmf.core.event.ITmfEventField;
6c13869b
FC		 31import org.eclipse.linuxtools.tmf.core.request.ITmfDataRequest;
32import org.eclipse.linuxtools.tmf.core.request.ITmfEventRequest;
33import org.eclipse.linuxtools.tmf.core.request.TmfDataRequest;
34import org.eclipse.linuxtools.tmf.core.request.TmfEventRequest;
6c13869b
FC		 35import org.eclipse.linuxtools.tmf.core.signal.TmfRangeSynchSignal;
36import org.eclipse.linuxtools.tmf.core.signal.TmfSignal;
37import org.eclipse.linuxtools.tmf.core.signal.TmfSignalHandler;
38import org.eclipse.linuxtools.tmf.core.signal.TmfTimeSynchSignal;
faa38350
PT		 39import org.eclipse.linuxtools.tmf.core.signal.TmfTraceClosedSignal;
40import org.eclipse.linuxtools.tmf.core.signal.TmfTraceSelectedSignal;
3bd46eef
AM		 41import org.eclipse.linuxtools.tmf.core.timestamp.ITmfTimestamp;
42import org.eclipse.linuxtools.tmf.core.timestamp.TmfTimeRange;
43import org.eclipse.linuxtools.tmf.core.timestamp.TmfTimestamp;
faa38350 44import org.eclipse.linuxtools.tmf.core.trace.ITmfTrace;
6c13869b
FC		 45import org.eclipse.linuxtools.tmf.core.uml2sd.ITmfSyncSequenceDiagramEvent;
46import org.eclipse.linuxtools.tmf.core.uml2sd.TmfSyncSequenceDiagramEvent;
faa38350 47import org.eclipse.linuxtools.tmf.ui.editors.ITmfTraceEditor;
73005152
BH		 48import org.eclipse.linuxtools.tmf.ui.views.uml2sd.SDView;
49import org.eclipse.linuxtools.tmf.ui.views.uml2sd.core.Frame;
50import org.eclipse.linuxtools.tmf.ui.views.uml2sd.core.GraphNode;
51import org.eclipse.linuxtools.tmf.ui.views.uml2sd.core.Lifeline;
df0b8ff4
BH		 52import org.eclipse.linuxtools.tmf.ui.views.uml2sd.dialogs.Criteria;
53import org.eclipse.linuxtools.tmf.ui.views.uml2sd.dialogs.FilterCriteria;
54import org.eclipse.linuxtools.tmf.ui.views.uml2sd.dialogs.FilterListDialog;
73005152
BH		 55import org.eclipse.linuxtools.tmf.ui.views.uml2sd.handlers.provider.ISDAdvancedPagingProvider;
56import org.eclipse.linuxtools.tmf.ui.views.uml2sd.handlers.provider.ISDFilterProvider;
57import org.eclipse.linuxtools.tmf.ui.views.uml2sd.handlers.provider.ISDFindProvider;
58import org.eclipse.linuxtools.tmf.ui.views.uml2sd.handlers.provider.ISDGraphNodeSupporter;
73005152 59import org.eclipse.linuxtools.tmf.ui.views.uml2sd.load.IUml2SDLoader;
de7ddc02 60import org.eclipse.swt.widgets.Display;
faa38350 61import org.eclipse.ui.IEditorPart;
73005152
BH		 62import org.eclipse.ui.ISelectionListener;
63import org.eclipse.ui.IWorkbenchPart;
526d9026 64import org.eclipse.ui.IWorkbenchWindow;
73005152
BH		 65import org.eclipse.ui.PlatformUI;
66import org.eclipse.ui.progress.IProgressConstants;
67
68/**
73005152 69 * <p>
a55887ca
AM		 70 * This class is a reference implementation of the
71 * <code>org.eclipse.linuxtools.tmf.ui.Uml2SDLoader</code> extension point. It
72 * provides a Sequence Diagram loader for a user space trace with specific trace
73 * content for sending and receiving signals between components. I also includes
74 * a default implementation for the <code>ITmfEvent</code> parsing.
73005152 75 * </p>
a55887ca
AM		 76 *
77 * The class <code>TmfUml2SDSyncLoader</code> analyzes events from type
78 * <code>ITmfEvent</code> and creates events type
79 * <code>ITmfSyncSequenceDiagramEvent</code> if the <code>ITmfEvent</code>
80 * contains all relevant information. The analysis checks that the event type
81 * strings contains either string SEND or RECEIVE. If event type matches these
82 * key words, the analyzer will look for strings sender, receiver and signal in
83 * the event fields of type <code>ITmfEventField</code>. If all the data is
84 * found a sequence diagram event from can be created. Note that Sync Messages
85 * are assumed, which means start and end time are the same. <br>
df0b8ff4 86 * <br>
a55887ca
AM		 87 * The parsing of the <code>ITmfEvent</code> is done in the method
88 * <code>getSequnceDiagramEvent()</code> of class
89 * <code>TmfUml2SDSyncLoader</code>. By extending the class
90 * <code>TmfUml2SDSyncLoader</code> and overwriting
91 * <code>getSequnceDiagramEvent()</code> a customized parsing algorithm can be
92 * implemented.<br>
93 * <br>
94 * Note that combined traces of multiple components, that contain the trace
95 * information about the same interactions are not supported in the class
96 * <code>TmfUml2SDSyncLoader</code>.
97 *
df0b8ff4
BH		 98 * @version 1.0
99 * @author Bernd Hufmann
73005152
BH		 100 */
101public class TmfUml2SDSyncLoader extends TmfComponent implements IUml2SDLoader, ISDFindProvider, ISDFilterProvider, ISDAdvancedPagingProvider, ISelectionListener {
102
103 // ------------------------------------------------------------------------
df0b8ff4 104 // Constants
73005152 105 // ------------------------------------------------------------------------
df0b8ff4
BH		 106 /**
107 * Default title name.
108 */
73005152 109 protected final static String TITLE = Messages.TmfUml2SDSyncLoader_ViewName;
df0b8ff4
BH		 110 /**
111 * Default block size for background request.
112 */
13e157b1 113 protected final static int DEFAULT_BLOCK_SIZE = 50000;
df0b8ff4
BH		 114 /**
115 * Maximum number of messages per page.
116 */
73005152 117 protected final static int MAX_NUM_OF_MSG = 10000;
df0b8ff4
BH		 118
119 // ------------------------------------------------------------------------
120 // Attributes
121 // ------------------------------------------------------------------------
73005152
BH		 122
123 // Experiment attributes
df0b8ff4 124 /**
faa38350
PT		 125 * The TMF trace reference.
126 * @since 2.0
df0b8ff4 127 */
faa38350 128 protected ITmfTrace fTrace = null;
df0b8ff4
BH		 129 /**
130 * The current indexing event request.
131 */
6256d8ad 132 protected ITmfEventRequest fIndexRequest = null;
df0b8ff4
BH		 133 /**
134 * The current request to fill a page.
135 */
6256d8ad 136 protected ITmfEventRequest fPageRequest = null;
df0b8ff4
BH		 137 /**
138 * Flag whether the time range signal was sent by this loader class or not
139 */
73005152 140 volatile protected boolean fIsSignalSent = false;
13e157b1 141
73005152 142 // The view and event attributes
df0b8ff4
BH		 143 /**
144 * The sequence diagram view reference.
145 */
73005152 146 protected SDView fView = null;
df0b8ff4
BH		 147 /**
148 * The current sequence diagram frame reference.
149 */
73005152 150 protected Frame fFrame = null;
df0b8ff4
BH		 151 /**
152 * The list of sequence diagram events of current page.
153 */
73005152
BH		 154 protected List<ITmfSyncSequenceDiagramEvent> fEvents = new ArrayList<ITmfSyncSequenceDiagramEvent>();
155
156 // Checkpoint and page attributes
df0b8ff4
BH		 157 /**
158 * The checkpoints of the whole sequence diagram trace (i.e. start time stamp of each page)
159 */
73005152 160 protected List<TmfTimeRange> fCheckPoints = new ArrayList<TmfTimeRange>(MAX_NUM_OF_MSG);
df0b8ff4
BH		 161 /**
162 * The current page displayed.
163 */
73005152 164 volatile protected int fCurrentPage = 0;
df0b8ff4
BH		 165 /**
166 * The current time selected.
167 */
4df4581d 168 protected ITmfTimestamp fCurrentTime = null;
df0b8ff4
BH		 169 /**
170 * Flag to specify that selection of message is done by selection or by signal.
171 */
a55887ca 172 volatile protected boolean fIsSelect = false;
73005152
BH		 173
174 // Search attributes
df0b8ff4 175 /**
a55887ca 176 * The job for searching across pages.
df0b8ff4 177 */
73005152 178 protected SearchJob fFindJob = null;
df0b8ff4
BH		 179 /**
180 * List of found nodes within a page.
181 */
73005152 182 protected List<GraphNode> fFindResults = new ArrayList<GraphNode>();
df0b8ff4
BH		 183 /**
184 * The current find criteria reference
185 */
73005152 186 protected Criteria fFindCriteria = null;
df0b8ff4
BH		 187 /**
188 * The current find index within the list of found nodes (<code>fFindeResults</code> within a page.
189 */
73005152
BH		 190 volatile protected int fCurrentFindIndex = 0;
191
192 // Filter attributes
df0b8ff4
BH		 193 /**
194 * The list of active filters.
195 */
73005152 196 protected List<FilterCriteria> fFilterCriteria = null;
a55887ca 197
73005152 198 // Thread synchronization
df0b8ff4
BH		 199 /**
200 * The synchronization lock.
201 */
73005152 202 protected ReentrantLock fLock = new ReentrantLock();
a55887ca 203
73005152
BH		 204 // ------------------------------------------------------------------------
205 // Constructors
206 // ------------------------------------------------------------------------
df0b8ff4
BH		 207 /**
208 * Default constructor
209 */
73005152
BH		 210 public TmfUml2SDSyncLoader() {
211 super(TITLE);
212 }
213
df0b8ff4
BH		 214 /**
215 * Constructor
a55887ca 216 *
df0b8ff4
BH		 217 * @param name Name of loader
218 */
73005152
BH		 219 public TmfUml2SDSyncLoader(String name) {
220 super(name);
221 }
222
223 // ------------------------------------------------------------------------
224 // Operations
225 // ------------------------------------------------------------------------
3bd46eef 226
73005152 227 /**
df0b8ff4 228 * Returns the current time if available else null.
a55887ca 229 *
df0b8ff4 230 * @return the current time if available else null
3bd46eef 231 * @since 2.0
73005152 232 */
4df4581d 233 public ITmfTimestamp getCurrentTime() {
a55887ca 234 fLock.lock();
73005152 235 try {
a55887ca 236 if (fCurrentTime != null) {
4593bd5b 237 return fCurrentTime;
73005152
BH		 238 }
239 return null;
240 } finally {
241 fLock.unlock();
242 }
243 }
a55887ca 244
73005152
BH		 245 /**
246 * Waits for the page request to be completed
247 */
248 public void waitForCompletion() {
249 fLock.lock();
6256d8ad 250 ITmfEventRequest request = fPageRequest;
73005152 251 fLock.unlock();
a55887ca
AM		 252 if (request != null) {
253 try {
254 request.waitForCompletion();
255 } catch (InterruptedException e) {
256 // ignore
257 }
73005152
BH		 258 }
259 }
260
261 /**
faa38350 262 * Signal handler for the trace selected signal.
a55887ca 263 *
faa38350 264 * Spawns a request to index the trace (checkpoints creation) as well as it fills
73005152 265 * the first page.
a55887ca 266 *
faa38350
PT		 267 * @param signal The trace selected signal
268 * @since 2.0
73005152 269 */
73005152 270 @TmfSignalHandler
faa38350 271 public void traceSelected(TmfTraceSelectedSignal signal) {
bfc779a0 272
e5d31efe 273 ITmfEventRequest indexRequest = null;
a55887ca 274 fLock.lock();
73005152
BH		 275 try {
276 // Update the trace reference
faa38350
PT		 277 ITmfTrace trace = signal.getTrace();
278 if (!trace.equals(fTrace)) {
279 fTrace = trace;
280 } else {
281 return;
282 }
283
284 final Job job = new IndexingJob("Indexing " + getName() + "..."); //$NON-NLS-1$ //$NON-NLS-2$
285 job.setUser(false);
286 job.schedule();
287
d10e93a2 288 indexRequest = fIndexRequest;
73005152 289
faa38350 290 cancelOngoingRequests();
faa38350 291
a4115405 292 TmfTimeRange window = TmfTimeRange.ETERNITY;
73005152 293
6256d8ad 294 fIndexRequest = new TmfEventRequest(ITmfEvent.class, window, TmfDataRequest.ALL_DATA, DEFAULT_BLOCK_SIZE, ITmfDataRequest.ExecutionType.BACKGROUND) {
73005152 295
4df4581d 296 private ITmfTimestamp fFirstTime = null;
297 private ITmfTimestamp fLastTime = null;
73005152 298 private int fNbSeqEvents = 0;
13e157b1 299 private final List<ITmfSyncSequenceDiagramEvent> fSdEvents = new ArrayList<ITmfSyncSequenceDiagramEvent>(MAX_NUM_OF_MSG);
73005152 300
df0b8ff4
BH		 301 /*
302 * (non-Javadoc)
303 * @see org.eclipse.linuxtools.tmf.core.request.TmfDataRequest#handleData(org.eclipse.linuxtools.tmf.core.event.ITmfEvent)
304 */
73005152 305 @Override
5419a136
AM		 306 public void handleData(ITmfEvent event) {
307 super.handleData(event);
73005152 308
9a43af17 309 ITmfSyncSequenceDiagramEvent sdEvent = getSequenceDiagramEvent(event);
73005152
BH		 310
311 if (sdEvent != null) {
312 ++fNbSeqEvents;
313
314 if (fFirstTime == null) {
4593bd5b 315 fFirstTime = event.getTimestamp();
73005152
BH		 316 }
317
4593bd5b 318 fLastTime = event.getTimestamp();
73005152
BH		 319
320 if ((fNbSeqEvents % MAX_NUM_OF_MSG) == 0) {
321 fLock.lock();
322 try {
323 fCheckPoints.add(new TmfTimeRange(fFirstTime, fLastTime));
324 if (fView != null) {
325 fView.updateCoolBar();
326 }
327 } finally {
328 fLock.unlock();
329 }
330 fFirstTime = null;
13e157b1 331
73005152
BH		 332 }
333
334 if (fNbSeqEvents > MAX_NUM_OF_MSG) {
335 // page is full
336 return;
337 }
338
339 fSdEvents.add(sdEvent);
340
341 if (fNbSeqEvents == MAX_NUM_OF_MSG) {
342 fillCurrentPage(fSdEvents);
343 }
344 }
345 }
346
df0b8ff4
BH		 347 /*
348 * (non-Javadoc)
349 * @see org.eclipse.linuxtools.tmf.core.request.TmfDataRequest#handleSuccess()
350 */
73005152
BH		 351 @Override
352 public void handleSuccess() {
73005152
BH		 353 if ((fFirstTime != null) && (fLastTime != null)) {
354
355 fLock.lock();
356 try {
357 fCheckPoints.add(new TmfTimeRange(fFirstTime, fLastTime));
358 if (fView != null) {
359 fView.updateCoolBar();
360 }
361 } finally {
362 fLock.unlock();
363 }
364 }
365
366 if (fNbSeqEvents <= MAX_NUM_OF_MSG) {
367 fillCurrentPage(fSdEvents);
368 }
369
370 super.handleSuccess();
371 }
372
df0b8ff4
BH		 373 /*
374 * (non-Javadoc)
375 * @see org.eclipse.linuxtools.tmf.core.request.TmfDataRequest#handleCompleted()
376 */
73005152 377 @Override
5419a136 378 public void handleCompleted() {
eb63f5ff 379 if (fEvents.isEmpty()) {
73005152
BH		 380 fFrame = new Frame();
381 fView.setFrameSync(fFrame);
382 }
383 super.handleCompleted();
bfc779a0 384 job.cancel();
73005152
BH		 385 }
386 };
387
73005152
BH		 388 } finally {
389 fLock.unlock();
390 }
d10e93a2
PT		 391 if (indexRequest != null && !indexRequest.isCompleted()) {
392 indexRequest.cancel();
393 }
394 resetLoader();
395 fTrace.sendRequest(fIndexRequest);
a55887ca 396
73005152
BH		 397 }
398
399 /**
faa38350 400 * Signal handler for the trace closed signal.
a55887ca 401 *
faa38350
PT		 402 * @param signal The trace closed signal
403 * @since 2.0
73005152 404 */
13e157b1 405 @TmfSignalHandler
faa38350
PT		 406 public void traceClosed(TmfTraceClosedSignal signal) {
407 if (signal.getTrace() != fTrace) {
828e5592
PT		 408 return;
409 }
e5d31efe 410 ITmfEventRequest indexRequest = null;
13e157b1 411 fLock.lock();
73005152 412 try {
d10e93a2
PT		 413 indexRequest = fIndexRequest;
414 fIndexRequest = null;
73005152
BH		 415
416 cancelOngoingRequests();
417
418 if (fFilterCriteria != null) {
419 fFilterCriteria.clear();
420 }
421
422 FilterListDialog.deactivateSavedGlobalFilters();
73005152 423 } finally {
faa38350 424 fTrace = null;
73005152
BH		 425 fLock.unlock();
426 }
d10e93a2
PT		 427 if (indexRequest != null && !indexRequest.isCompleted()) {
428 indexRequest.cancel();
429 }
430
431 resetLoader();
73005152
BH		 432 }
433
434 /**
435 * Moves to the page that contains the time provided by the signal. The messages will be selected
436 * if the provided time is the time of a message.
13e157b1 437 *
73005152
BH		 438 * @param signal The Time synch signal.
439 */
440 @TmfSignalHandler
441 public void synchToTime(TmfTimeSynchSignal signal) {
442 fLock.lock();
443 try {
aa63fb03 444 if ((signal.getSource() != this) && (fFrame != null) && (fCheckPoints.size() > 0)) {
73005152
BH		 445 fCurrentTime = signal.getCurrentTime();
446 fIsSelect = true;
447 moveToMessage();
448 }
449 } finally {
450 fLock.unlock();
451 }
452 }
453
454 /**
a55887ca
AM		 455 * Moves to the page that contains the current time provided by signal.
456 * No message will be selected however the focus will be set to the message
73005152 457 * if the provided time is the time of a message.
a55887ca 458 *
73005152
BH		 459 * @param signal The time range sync signal
460 */
461 @TmfSignalHandler
462 public void synchToTimeRange(TmfRangeSynchSignal signal) {
463 fLock.lock();
464 try {
aa63fb03 465 if ((signal.getSource() != this) && (fFrame != null) && !fIsSignalSent && (fCheckPoints.size() > 0)) {
73005152 466 TmfTimeRange newTimeRange = signal.getCurrentRange();
73005152
BH		 467
468 fIsSelect = false;
7d1ef69c 469 fCurrentTime = newTimeRange.getStartTime();
73005152
BH		 470
471 moveToMessage();
472 }
473 } finally {
474 fLock.unlock();
475 }
476
477 }
13e157b1 478
73005152
BH		 479 /*
480 * (non-Javadoc)
481 * @see org.eclipse.linuxtools.tmf.ui.views.uml2sd.load.IUml2SDLoader#setViewer(org.eclipse.linuxtools.tmf.ui.views.uml2sd.SDView)
482 */
73005152
BH		 483 @Override
484 public void setViewer(SDView viewer) {
13e157b1
MK		 485
486 fLock.lock();
73005152
BH		 487 try {
488 fView = viewer;
489 PlatformUI.getWorkbench().getActiveWorkbenchWindow().getSelectionService().addPostSelectionListener(this);
490 fView.setSDFindProvider(this);
491 fView.setSDPagingProvider(this);
492 fView.setSDFilterProvider(this);
493
494 resetLoader();
495
f28d404e 496 IEditorPart editor = fView.getSite().getPage().getActiveEditor();
faa38350
PT		 497 if (editor instanceof ITmfTraceEditor) {
498 ITmfTrace trace = ((ITmfTraceEditor) editor).getTrace();
499 if (trace != null) {
500 traceSelected(new TmfTraceSelectedSignal(this, trace));
501 }
73005152
BH		 502 }
503 } finally {
504 fLock.unlock();
505 }
506 }
507
508 /*
509 * (non-Javadoc)
510 * @see org.eclipse.linuxtools.tmf.ui.views.uml2sd.load.IUml2SDLoader#getTitleString()
511 */
512 @Override
513 public String getTitleString() {
514 return getName();
515 }
516
517 /*
518 * (non-Javadoc)
519 * @see org.eclipse.linuxtools.tmf.component.TmfComponent#dispose()
520 */
521 @Override
522 public void dispose() {
523 super.dispose();
e5d31efe 524 ITmfEventRequest indexRequest = null;
13e157b1 525 fLock.lock();
73005152 526 try {
526d9026
BH		 527 IWorkbenchWindow window = PlatformUI.getWorkbench().getActiveWorkbenchWindow();
528 // During Eclipse shutdown the active workbench window is null
529 if (window != null) {
530 window.getSelectionService().removePostSelectionListener(this);
531 }
4b4a1525 532
d10e93a2
PT		 533 indexRequest = fIndexRequest;
534 fIndexRequest = null;
4b4a1525
BH		 535 cancelOngoingRequests();
536
73005152
BH		 537 fView.setSDFindProvider(null);
538 fView.setSDPagingProvider(null);
539 fView.setSDFilterProvider(null);
540 fView = null;
541 } finally {
542 fLock.unlock();
543 }
d10e93a2
PT		 544 if (indexRequest != null && !indexRequest.isCompleted()) {
545 indexRequest.cancel();
546 }
73005152
BH		 547 }
548
549 /*
550 * (non-Javadoc)
551 * @see org.eclipse.hyades.uml2sd.ui.actions.provider.ISDGraphNodeSupporter#isNodeSupported(int)
552 */
553 @Override
554 public boolean isNodeSupported(int nodeType) {
555 switch (nodeType) {
556 case ISDGraphNodeSupporter.LIFELINE:
557 case ISDGraphNodeSupporter.SYNCMESSAGE:
558 return true;
559
560 default:
561 break;
562 }
563 return false;
564 }
565
566 /*
567 * (non-Javadoc)
568 * @see org.eclipse.linuxtools.tmf.ui.views.uml2sd.handlers.provider.ISDGraphNodeSupporter#getNodeName(int, java.lang.String)
569 */
570 @Override
571 public String getNodeName(int nodeType, String loaderClassName) {
572 switch (nodeType) {
573 case ISDGraphNodeSupporter.LIFELINE:
574 return Messages.TmfUml2SDSyncLoader_CategoryLifeline;
575 case ISDGraphNodeSupporter.SYNCMESSAGE:
576 return Messages.TmfUml2SDSyncLoader_CategoryMessage;
abbdd66a
AM		 577 default:
578 break;
73005152
BH		 579 }
580 return ""; //$NON-NLS-1$
581 }
582
583 /*
584 * (non-Javadoc)
585 * @see org.eclipse.ui.ISelectionListener#selectionChanged(org.eclipse.ui.IWorkbenchPart, org.eclipse.jface.viewers.ISelection)
586 */
587 @Override
588 public void selectionChanged(IWorkbenchPart part, ISelection selection) {
589 ISelection sel = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getSelectionService().getSelection();
13e157b1 590 if ((sel != null) && (sel instanceof StructuredSelection)) {
73005152
BH		 591 StructuredSelection stSel = (StructuredSelection) sel;
592 if (stSel.getFirstElement() instanceof TmfSyncMessage) {
593 TmfSyncMessage syncMsg = ((TmfSyncMessage) stSel.getFirstElement());
594 broadcast(new TmfTimeSynchSignal(this, syncMsg.getStartTime()));
595 }
596 }
597 }
598
599 /*
600 * (non-Javadoc)
601 * @see
602 * org.eclipse.hyades.uml2sd.ui.actions.provider.ISDFindProvider#find(org.eclipse.hyades.uml2sd.ui.actions.widgets.Criteria)
603 */
604 @Override
605 public boolean find(Criteria toSearch) {
606 fLock.lock();
607 try {
608 if (fFrame == null) {
609 return false;
610 }
611
13e157b1 612 if ((fFindResults == null) || (fFindCriteria == null) || !fFindCriteria.compareTo(toSearch)) {
73005152
BH		 613 fFindResults = new CopyOnWriteArrayList<GraphNode>();
614 fFindCriteria = toSearch;
615 if (fFindCriteria.isLifeLineSelected()) {
616 for (int i = 0; i < fFrame.lifeLinesCount(); i++) {
617 if (fFindCriteria.matches(fFrame.getLifeline(i).getName())) {
618 fFindResults.add(fFrame.getLifeline(i));
619 }
620 }
621 }
622
623 ArrayList<GraphNode> msgs = new ArrayList<GraphNode>();
624 if (fFindCriteria.isSyncMessageSelected()) {
625 for (int i = 0; i < fFrame.syncMessageCount(); i++) {
626 if (fFindCriteria.matches(fFrame.getSyncMessage(i).getName())) {
627 msgs.add(fFrame.getSyncMessage(i));
628 }
629 }
630 }
631
eb63f5ff 632 if (!msgs.isEmpty()) {
73005152
BH		 633 fFindResults.addAll(msgs);
634 }
635
636 @SuppressWarnings("rawtypes")
637 List selection = fView.getSDWidget().getSelection();
13e157b1 638 if ((selection != null) && (selection.size() == 1)) {
73005152 639 fCurrentFindIndex = fFindResults.indexOf(selection.get(0)) + 1;
13e157b1 640 } else {
73005152 641 fCurrentFindIndex = 0;
13e157b1 642 }
73005152
BH		 643 } else {
644 fCurrentFindIndex++;
645 }
646
647 if (fFindResults.size() > fCurrentFindIndex) {
13e157b1 648 GraphNode current = fFindResults.get(fCurrentFindIndex);
73005152
BH		 649 fView.getSDWidget().moveTo(current);
650 return true;
73005152 651 }
abbdd66a
AM		 652 fFindResults = null;
653 fCurrentFindIndex =0;
654 return findInNextPages(fFindCriteria); // search in other page
73005152
BH		 655 } finally {
656 fLock.unlock();
657 }
658 }
659
660 /*
661 * (non-Javadoc)
662 * @see org.eclipse.linuxtools.tmf.ui.views.uml2sd.handlers.provider.ISDFindProvider#cancel()
663 */
664 @Override
665 public void cancel() {
666 cancelOngoingRequests();
667 }
668
669 /*
670 * (non-Javadoc)
671 * @see org.eclipse.linuxtools.tmf.ui.views.uml2sd.handlers.provider.ISDFilterProvider#filter(java.util.List)
672 */
673 @SuppressWarnings("unchecked")
674 @Override
675 public boolean filter(List<?> filters) {
676 fLock.lock();
677 try {
678 cancelOngoingRequests();
679
1ef1189a
BH		 680 if (filters == null) {
681 fFilterCriteria = new ArrayList<FilterCriteria>();
682 } else {
683 List<FilterCriteria> list = (List<FilterCriteria>)filters;
684 fFilterCriteria = new ArrayList<FilterCriteria>(list);
685 }
73005152
BH		 686
687 fillCurrentPage(fEvents);
688
689 } finally {
690 fLock.unlock();
691 }
692 return true;
693 }
13e157b1 694
73005152
BH		 695 /*
696 * (non-Javadoc)
697 * @see org.eclipse.linuxtools.tmf.ui.views.uml2sd.handlers.provider.ISDPagingProvider#hasNextPage()
698 */
699 @Override
700 public boolean hasNextPage() {
701 fLock.lock();
702 try {
703 int size = fCheckPoints.size();
704 if (size > 0) {
13e157b1 705 return fCurrentPage < (size - 1);
73005152
BH		 706 }
707 } finally {
708 fLock.unlock();
709 }
710 return false;
711 }
712
713 /*
714 * (non-Javadoc)
715 * @see org.eclipse.linuxtools.tmf.ui.views.uml2sd.handlers.provider.ISDPagingProvider#hasPrevPage()
716 */
717 @Override
718 public boolean hasPrevPage() {
719 fLock.lock();
720 try {
721 return fCurrentPage > 0;
722 } finally {
723 fLock.unlock();
724 }
725 }
726
727 /*
728 * (non-Javadoc)
729 * @see org.eclipse.linuxtools.tmf.ui.views.uml2sd.handlers.provider.ISDPagingProvider#nextPage()
730 */
731 @Override
732 public void nextPage() {
733 fLock.lock();
734 try {
735 // Safety check
13e157b1 736 if (fCurrentPage >= (fCheckPoints.size() - 1)) {
73005152 737 return;
13e157b1 738 }
73005152
BH		 739
740 cancelOngoingRequests();
741 fCurrentTime = null;
742 fCurrentPage++;
743 moveToPage();
744 } finally {
745 fLock.unlock();
746 }
747 }
748
749 /*
750 * (non-Javadoc)
751 * @see org.eclipse.linuxtools.tmf.ui.views.uml2sd.handlers.provider.ISDPagingProvider#prevPage()
752 */
753 @Override
754 public void prevPage() {
755 fLock.lock();
756 try {
757 // Safety check
13e157b1 758 if (fCurrentPage <= 0) {
73005152 759 return;
13e157b1 760 }
73005152
BH		 761
762 cancelOngoingRequests();
763 fCurrentTime = null;
764 fCurrentPage--;
765 moveToPage();
766 } finally {
767 fLock.unlock();
768 }
769 }
13e157b1 770
73005152
BH		 771 /*
772 * (non-Javadoc)
773 * @see org.eclipse.linuxtools.tmf.ui.views.uml2sd.handlers.provider.ISDPagingProvider#firstPage()
774 */
775 @Override
776 public void firstPage() {
777 fLock.lock();
778 try {
779
780 cancelOngoingRequests();
781 fCurrentTime = null;
782 fCurrentPage = 0;
783 moveToPage();
784 } finally {
785 fLock.unlock();
786 }
787 }
13e157b1 788
73005152
BH		 789 /*
790 * (non-Javadoc)
791 * @see org.eclipse.linuxtools.tmf.ui.views.uml2sd.handlers.provider.ISDPagingProvider#lastPage()
792 */
793 @Override
794 public void lastPage() {
795 fLock.lock();
796 try {
797 cancelOngoingRequests();
798 fCurrentTime = null;
799 fCurrentPage = fCheckPoints.size() - 1;
800 moveToPage();
801 } finally {
802 fLock.unlock();
803 }
804 }
805
806 /*
807 * (non-Javadoc)
808 * @see org.eclipse.linuxtools.tmf.ui.views.uml2sd.handlers.provider.ISDAdvancedPagingProvider#currentPage()
809 */
810 @Override
811 public int currentPage() {
812 fLock.lock();
813 try {
814 return fCurrentPage;
815 } finally {
816 fLock.unlock();
817 }
818 }
819
820 /*
821 * (non-Javadoc)
822 * @see org.eclipse.linuxtools.tmf.ui.views.uml2sd.handlers.provider.ISDAdvancedPagingProvider#pagesCount()
823 */
824 @Override
825 public int pagesCount() {
826 fLock.lock();
827 try {
828 return fCheckPoints.size();
829 } finally {
830 fLock.unlock();
831 }
832 }
833
834 /*
835 * (non-Javadoc)
836 * @see org.eclipse.linuxtools.tmf.ui.views.uml2sd.handlers.provider.ISDAdvancedPagingProvider#pageNumberChanged(int)
837 */
838 @Override
eb63f5ff
BH		 839 public void pageNumberChanged(int pagenNumber) {
840 int localPageNumber = pagenNumber;
a55887ca 841
73005152
BH		 842 fLock.lock();
843 try {
844 cancelOngoingRequests();
845
eb63f5ff
BH		 846 if (localPageNumber < 0) {
847 localPageNumber = 0;
73005152
BH		 848 }
849 int size = fCheckPoints.size();
eb63f5ff
BH		 850 if (localPageNumber > (size - 1)) {
851 localPageNumber = size - 1;
73005152 852 }
eb63f5ff 853 fCurrentPage = localPageNumber;
73005152
BH		 854 moveToPage();
855 } finally {
856 fLock.unlock();
857 }
858 }
859
860 /*
861 * (non-Javadoc)
862 * @see org.eclipse.linuxtools.tmf.component.TmfComponent#broadcast(org.eclipse.linuxtools.tmf.signal.TmfSignal)
863 */
864 @Override
865 public void broadcast(TmfSignal signal) {
866 fIsSignalSent = true;
867 super.broadcast(signal);
868 fIsSignalSent = false;
869 }
870
871 /**
872 * Cancels any ongoing find operation
873 */
874 protected void cancelOngoingRequests() {
13e157b1 875 fLock.lock();
e5d31efe 876 ITmfEventRequest pageRequest = null;
73005152
BH		 877 try {
878 // Cancel the search thread
879 if (fFindJob != null) {
880 fFindJob.cancel();
881 }
df0b8ff4 882
73005152
BH		 883 fFindResults = null;
884 fFindCriteria = null;
885 fCurrentFindIndex = 0;
886
d10e93a2
PT		 887 pageRequest = fPageRequest;
888 fPageRequest = null;
73005152
BH		 889 } finally {
890 fLock.unlock();
891 }
d10e93a2
PT		 892 if (pageRequest != null && !pageRequest.isCompleted()) {
893 pageRequest.cancel();
894 }
73005152
BH		 895 }
896
897 /**
898 * Resets loader attributes
899 */
900 protected void resetLoader() {
901 fLock.lock();
902 try {
903 fCurrentTime = null;
904 fEvents.clear();
905 fCheckPoints.clear();
906 fCurrentPage = 0;
907 fCurrentFindIndex = 0;
908 fFindCriteria = null;
909 fFindResults = null;
73005152
BH		 910 fView.setFrameSync(new Frame());
911 fFrame = null;
912 }
913 finally {
914 fLock.unlock();
915 }
916
917 }
918
919 /**
920 * Fills current page with sequence diagram content.
a55887ca 921 *
73005152
BH		 922 * @param events sequence diagram events
923 */
924 protected void fillCurrentPage(List<ITmfSyncSequenceDiagramEvent> events) {
925
926 fLock.lock();
927 try {
928 fEvents = new ArrayList<ITmfSyncSequenceDiagramEvent>(events);
faa38350 929 if (fView != null && !events.isEmpty()) {
73005152
BH		 930 fView.toggleWaitCursorAsync(true);
931 }
932 } finally {
933 fLock.unlock();
934 }
13e157b1 935
73005152 936 final Frame frame = new Frame();
73005152 937
eb63f5ff
BH		 938 if (!events.isEmpty()) {
939 Map<String, Lifeline> nodeToLifelineMap = new HashMap<String, Lifeline>();
73005152
BH		 940
941 frame.setName(Messages.TmfUml2SDSyncLoader_FrameName);
942
943 for (int i = 0; i < events.size(); i++) {
944
945 ITmfSyncSequenceDiagramEvent sdEvent = events.get(i);
946
947 if ((nodeToLifelineMap.get(sdEvent.getSender()) == null) && (!filterLifeLine(sdEvent.getSender()))) {
948 Lifeline lifeline = new Lifeline();
949 lifeline.setName(sdEvent.getSender());
950 nodeToLifelineMap.put(sdEvent.getSender(), lifeline);
951 frame.addLifeLine(lifeline);
952 }
953
954 if ((nodeToLifelineMap.get(sdEvent.getReceiver()) == null) && (!filterLifeLine(sdEvent.getReceiver()))) {
955 Lifeline lifeline = new Lifeline();
956 lifeline.setName(sdEvent.getReceiver());
957 nodeToLifelineMap.put(sdEvent.getReceiver(), lifeline);
958 frame.addLifeLine(lifeline);
959 }
960 }
961
962 int eventOccurence = 1;
963
964 for (int i = 0; i < events.size(); i++) {
13e157b1 965 ITmfSyncSequenceDiagramEvent sdEvent = events.get(i);
73005152
BH		 966
967 // Check message filter
968 if (filterMessage(sdEvent)) {
969 continue;
970 }
971
972 // Set the message sender and receiver
13e157b1
MK		 973 Lifeline startLifeline = nodeToLifelineMap.get(sdEvent.getSender());
974 Lifeline endLifeline = nodeToLifelineMap.get(sdEvent.getReceiver());
73005152 975
13e157b1
MK		 976 // Check if any of the lifelines were filtered
977 if ((startLifeline == null) || (endLifeline == null)) {
73005152
BH		 978 continue;
979 }
980
981 int tmp = Math.max(startLifeline.getEventOccurrence(), endLifeline.getEventOccurrence());
982 eventOccurence = Math.max(eventOccurence, tmp);
13e157b1 983
73005152
BH		 984 startLifeline.setCurrentEventOccurrence(eventOccurence);
985 endLifeline.setCurrentEventOccurrence(eventOccurence);
13e157b1 986
73005152 987 TmfSyncMessage message = new TmfSyncMessage(sdEvent, eventOccurence++);
13e157b1 988
73005152
BH		 989 message.setStartLifeline(startLifeline);
990 message.setEndLifeline(endLifeline);
991
992 message.setTime(sdEvent.getStartTime());
993
994 // add the message to the frame
995 frame.addMessage(message);
13e157b1 996
73005152
BH		 997 }
998 fLock.lock();
999 try {
1000 if (!fView.getSDWidget().isDisposed()) {
1001 fView.getSDWidget().getDisplay().asyncExec(new Runnable() {
1002
1003 @Override
1004 public void run() {
1005
1006 fLock.lock();
1007 try {
1008 // check if view was disposed in the meanwhile
1009 if ((fView != null) && (!fView.getSDWidget().isDisposed())) {
1010 fFrame = frame;
1011 fView.setFrame(fFrame);
1012
1013 if (fCurrentTime != null) {
1014 moveToMessageInPage();
1015 }
1016
1017 if (fFindCriteria != null) {
1018 find(fFindCriteria);
1019 }
13e157b1 1020
73005152
BH		 1021 fView.toggleWaitCursorAsync(false);
1022 }
1023 } finally {
1024 fLock.unlock();
1025 }
1026
1027 }
1028 });
1029 }
1030 }
1031 finally {
1032 fLock.unlock();
1033 }
1034 }
1035 }
1036
1037 /**
1038 * Moves to a certain message defined by timestamp (across pages)
1039 */
1040 protected void moveToMessage() {
1041 int page = 0;
1042
1043 fLock.lock();
1044 try {
1045 page = getPage(fCurrentTime);
1046
1047 if (page == fCurrentPage) {
1048 moveToMessageInPage();
1049 return;
1050 }
1051 fCurrentPage = page;
1052 moveToPage(false);
1053 } finally {
1054 fLock.unlock();
1055 }
1056 }
1057
1058 /**
1059 * Moves to a certain message defined by timestamp in current page
1060 */
1061 protected void moveToMessageInPage() {
1062 fLock.lock();
1063 try {
de7ddc02
BH		 1064 if (!fView.getSDWidget().isDisposed()) {
1065 // Check for GUI thread
1066 if(Display.getCurrent() != null) {
1067 // Already in GUI thread - execute directly
1068 TmfSyncMessage prevMessage = null;
1069 TmfSyncMessage syncMessage = null;
1070 boolean isExactTime = false;
1071 for (int i = 0; i < fFrame.syncMessageCount(); i++) {
1072 if (fFrame.getSyncMessage(i) instanceof TmfSyncMessage) {
1073 syncMessage = (TmfSyncMessage) fFrame.getSyncMessage(i);
1074 if (syncMessage.getStartTime().compareTo(fCurrentTime, false) == 0) {
1075 isExactTime = true;
1076 break;
eb63f5ff
BH		 1077 } else if ((syncMessage.getStartTime().compareTo(fCurrentTime, false) > 0) && (prevMessage != null)) {
1078 syncMessage = prevMessage;
1079 break;
de7ddc02
BH		 1080 }
1081 prevMessage = syncMessage;
1082 }
1083 }
1084 if (fIsSelect && isExactTime) {
1085 fView.getSDWidget().moveTo(syncMessage);
1086 }
1087 else {
1088 fView.getSDWidget().ensureVisible(syncMessage);
1089 fView.getSDWidget().clearSelection();
1090 fView.getSDWidget().redraw();
1091 }
1092 }
1093 else {
13e157b1 1094 // Not in GUI thread - queue action in GUI thread.
de7ddc02
BH		 1095 fView.getSDWidget().getDisplay().asyncExec(new Runnable() {
1096 @Override
1097 public void run() {
1098 moveToMessageInPage();
1099 }
1100 });
1101 }
1102 }
73005152
BH		 1103 }
1104 finally {
1105 fLock.unlock();
1106 }
1107 }
13e157b1 1108
73005152
BH		 1109 /**
1110 * Moves to a certain message defined by timestamp (across pages)
1111 */
1112 protected void moveToPage() {
1113 moveToPage(true);
1114 }
1115
1116 /**
1117 * Moves to a certain page.
a55887ca 1118 *
73005152
BH		 1119 * @param notifyAll true to broadcast time range signal to other signal handlers else false
1120 */
1121 protected void moveToPage(boolean notifyAll) {
1122
eb63f5ff 1123 TmfTimeRange window = null;
73005152
BH		 1124
1125 fLock.lock();
1126 try {
1127 // Safety check
1128 if (fCurrentPage > fCheckPoints.size()) {
1129 return;
1130 }
1131 window = fCheckPoints.get(fCurrentPage);
1132 } finally {
1133 fLock.unlock();
1134 }
1135
eb63f5ff
BH		 1136 if (window == null) {
1137 window = TmfTimeRange.ETERNITY;
1138 }
1139
6256d8ad 1140 fPageRequest = new TmfEventRequest(ITmfEvent.class, window, TmfDataRequest.ALL_DATA, 1, ITmfDataRequest.ExecutionType.FOREGROUND) {
13e157b1 1141 private final List<ITmfSyncSequenceDiagramEvent> fSdEvent = new ArrayList<ITmfSyncSequenceDiagramEvent>();
73005152
BH		 1142
1143 @Override
5419a136
AM		 1144 public void handleData(ITmfEvent event) {
1145 super.handleData(event);
73005152 1146
9a43af17 1147 ITmfSyncSequenceDiagramEvent sdEvent = getSequenceDiagramEvent(event);
73005152
BH		 1148
1149 if (sdEvent != null) {
1150 fSdEvent.add(sdEvent);
1151 }
1152 }
1153
1154 @Override
1155 public void handleSuccess() {
1156 fillCurrentPage(fSdEvent);
1157 super.handleSuccess();
1158 }
13e157b1 1159
73005152
BH		 1160 };
1161
faa38350 1162 fTrace.sendRequest(fPageRequest);
73005152
BH		 1163
1164 if (notifyAll) {
1165 TmfTimeRange timeRange = getSignalTimeRange(window.getStartTime());
1166 broadcast(new TmfRangeSynchSignal(this, timeRange, timeRange.getStartTime()));
1167 }
1168 }
1169
1170 /**
1171 * Gets page that contains timestamp
a55887ca 1172 *
73005152
BH		 1173 * @param time The timestamp
1174 * @return page that contains the time
3bd46eef 1175 * @since 2.0
73005152 1176 */
4df4581d 1177 protected int getPage(ITmfTimestamp time) {
73005152
BH		 1178 int page;
1179 int size;
1180 fLock.lock();
1181 try {
1182 size = fCheckPoints.size();
13e157b1 1183 for (page = 0; page < size; page++) {
73005152
BH		 1184 TmfTimeRange timeRange = fCheckPoints.get(page);
1185 if (timeRange.getEndTime().compareTo(time, false) >= 0) {
1186 break;
1187 }
1188 }
1189 if (page >= size) {
1190 page = size - 1;
1191 }
1192 return page;
1193 } finally {
1194 fLock.unlock();
1195 }
1196 }
13e157b1 1197
73005152
BH		 1198 /**
1199 * Background search in trace for expression in criteria.
a55887ca 1200 *
73005152
BH		 1201 * @param findCriteria The find criteria
1202 * @return true if background request was started else false
1203 */
1204 protected boolean findInNextPages(Criteria findCriteria) {
1205 fLock.lock();
1206 try {
1207 if (fFindJob != null) {
1208 return true;
1209 }
1210
1211 int nextPage = fCurrentPage + 1;
1212
1213 if ((nextPage) >= fCheckPoints.size()) {
1214 // we are at the end
1215 return false;
1216 }
1217
4593bd5b 1218 TmfTimeRange window = new TmfTimeRange(fCheckPoints.get(nextPage).getStartTime(), fCheckPoints.get(fCheckPoints.size()-1).getEndTime());
73005152
BH		 1219 fFindJob = new SearchJob(findCriteria, window);
1220 fFindJob.schedule();
1221 fView.toggleWaitCursorAsync(true);
1222 } finally {
1223 fLock.unlock();
1224 }
1225 return true;
1226 }
1227
1228 /**
1229 * Gets time range for time range signal.
a55887ca 1230 *
73005152 1231 * @param startTime The start time of time range.
0d9a6d76 1232 * @return the time range
3bd46eef 1233 * @since 2.0
73005152 1234 */
4df4581d 1235 protected TmfTimeRange getSignalTimeRange(ITmfTimestamp startTime) {
73005152
BH		 1236 fLock.lock();
1237 try {
d7ee91bb
PT		 1238 long offset = fTrace == null ? 0 : fTrace.getCurrentRange().getEndTime().getDelta(fTrace.getCurrentRange().getStartTime()).normalize(0, startTime.getScale()).getValue();
1239 TmfTimestamp initialEndOfWindow = new TmfTimestamp(startTime.getValue() + offset, startTime.getScale(), startTime.getPrecision());
73005152
BH		 1240 return new TmfTimeRange(startTime, initialEndOfWindow);
1241 }
1242 finally {
1243 fLock.unlock();
1244 }
1245 }
1246
1247 /**
13e157b1 1248 * Checks if filter criteria matches the message name in given SD event.
a55887ca 1249 *
73005152
BH		 1250 * @param sdEvent The SD event to check
1251 * @return true if match else false.
1252 */
1253 protected boolean filterMessage(ITmfSyncSequenceDiagramEvent sdEvent) {
1254 fLock.lock();
1255 try {
1256 if (fFilterCriteria != null) {
1257 for(FilterCriteria criteria : fFilterCriteria) {
eb63f5ff
BH		 1258 if (criteria.isActive() && criteria.getCriteria().isSyncMessageSelected() && criteria.getCriteria().matches(sdEvent.getName())) {
1259 return true;
73005152
BH		 1260 }
1261 }
1262 }
1263 } finally {
1264 fLock.unlock();
1265 }
1266 return false;
1267 }
1268
1269 /**
13e157b1 1270 * Checks if filter criteria matches a lifeline name (sender or receiver) in given SD event.
a55887ca 1271 *
0d9a6d76 1272 * @param lifeline the message receiver
73005152
BH		 1273 * @return true if match else false.
1274 */
1275 protected boolean filterLifeLine(String lifeline) {
1276 fLock.lock();
1277 try {
1278 if (fFilterCriteria != null) {
1279 for(FilterCriteria criteria : fFilterCriteria) {
eb63f5ff
BH		 1280 if (criteria.isActive() && criteria.getCriteria().isLifeLineSelected() && criteria.getCriteria().matches(lifeline)) {
1281 return true;
73005152
BH		 1282 }
1283 }
1284 }
1285 } finally {
1286 fLock.unlock();
1287 }
1288 return false;
1289 }
1290
1291 /**
13e157b1 1292 * Job to search in trace for given time range.
73005152
BH		 1293 */
1294 protected class SearchJob extends Job {
1295
df0b8ff4 1296 /**
a55887ca 1297 * The search event request.
df0b8ff4 1298 */
73005152 1299 final protected SearchEventRequest fSearchRequest;
13e157b1 1300
73005152
BH		 1301 /**
1302 * Constructor
13e157b1 1303 *
73005152
BH		 1304 * @param findCriteria The search criteria
1305 * @param window Time range to search in
3bd46eef 1306 * @since 2.0
73005152
BH		 1307 */
1308 public SearchJob(Criteria findCriteria, TmfTimeRange window) {
1309 super(Messages.TmfUml2SDSyncLoader_SearchJobDescrition);
1310 fSearchRequest = new SearchEventRequest(window, TmfDataRequest.ALL_DATA, 1, ITmfDataRequest.ExecutionType.FOREGROUND, findCriteria);
1311 }
1312
1313 /*
1314 * (non-Javadoc)
1315 * @see org.eclipse.core.runtime.jobs.Job#run(org.eclipse.core.runtime.IProgressMonitor)
1316 */
1317 @Override
1318 protected IStatus run(IProgressMonitor monitor) {
1319 fSearchRequest.setMonitor(monitor);
13e157b1 1320
faa38350 1321 fTrace.sendRequest(fSearchRequest);
73005152
BH		 1322
1323 try {
1324 fSearchRequest.waitForCompletion();
1325 } catch (InterruptedException e) {
8fd82db5 1326 Activator.getDefault().logError("Search request interrupted!", e); //$NON-NLS-1$
73005152
BH		 1327 }
1328
13e157b1
MK		 1329 IStatus status = Status.OK_STATUS;
1330 if (fSearchRequest.isFound() && (fSearchRequest.getFoundTime() != null)) {
73005152 1331 fCurrentTime = fSearchRequest.getFoundTime();
13e157b1 1332
73005152
BH		 1333 // Avoid double-selection. Selection will be done when calling find(criteria)
1334 // after moving to relevant page
13e157b1 1335 fIsSelect = false;
73005152
BH		 1336 if (!fView.getSDWidget().isDisposed()) {
1337 fView.getSDWidget().getDisplay().asyncExec(new Runnable() {
1338
1339 @Override
1340 public void run() {
1341 moveToMessage();
1342 }
1343 });
1344 }
1345 }
1346 else {
1347 if (monitor.isCanceled()) {
1348 status = Status.CANCEL_STATUS;
1349 }
1350 else {
1351 // String was not found
abbdd66a 1352 status = new Status(IStatus.WARNING, Activator.PLUGIN_ID, Messages.TmfUml2SDSyncLoader_SearchNotFound);
73005152
BH		 1353 }
1354 setProperty(IProgressConstants.KEEP_PROPERTY, Boolean.TRUE);
1355 }
1356 monitor.done();
1357
1358 fLock.lock();
1359 try {
1360 fView.toggleWaitCursorAsync(false);
1361 fFindJob = null;
1362 } finally {
1363 fLock.unlock();
1364 }
1365
1366 return status;
1367 }
13e157b1 1368
73005152
BH		 1369 /*
1370 * (non-Javadoc)
1371 * @see org.eclipse.core.runtime.jobs.Job#canceling()
1372 */
1373 @Override
1374 protected void canceling() {
1375 fSearchRequest.cancel();
1376 fLock.lock();
1377 try {
1378 fFindJob = null;
1379 } finally {
1380 fLock.unlock();
1381 }
1382 }
1383 }
1384
1385 /**
13e157b1 1386 * TMF event request for searching within trace.
73005152 1387 */
6256d8ad 1388 protected class SearchEventRequest extends TmfEventRequest {
73005152 1389
df0b8ff4
BH		 1390 /**
1391 * The find criteria.
1392 */
73005152 1393 final private Criteria fCriteria;
df0b8ff4
BH		 1394 /**
1395 * A progress monitor
1396 */
73005152 1397 private IProgressMonitor fMonitor;
df0b8ff4
BH		 1398 /**
1399 * Flag to indicate that node was found according the criteria .
1400 */
73005152 1401 private boolean fIsFound = false;
df0b8ff4
BH		 1402 /**
1403 * Time stamp of found item.
1404 */
4df4581d 1405 private ITmfTimestamp fFoundTime = null;
73005152
BH		 1406
1407 /**
13e157b1 1408 * Constructor
73005152
BH		 1409 * @param range @see org.eclipse.linuxtools.tmf.request.TmfEventRequest#TmfEventRequest(...)
1410 * @param nbRequested @see org.eclipse.linuxtools.tmf.request.TmfEventRequest#handleData(...)
1411 * @param blockSize @see org.eclipse.linuxtools.tmf.request.TmfEventRequest#handleData(...)
1412 * @param execType @see org.eclipse.linuxtools.tmf.request.TmfEventRequest#handleData(...)
1413 * @param criteria The search criteria
1414 */
1415 public SearchEventRequest(TmfTimeRange range, int nbRequested, int blockSize, ExecutionType execType, Criteria criteria) {
1416 this(range, nbRequested, blockSize, execType, criteria, null);
1417 }
1418
1419 /**
1420 * Constructor
1421 * @param range @see org.eclipse.linuxtools.tmf.request.TmfEventRequest#TmfEventRequest(...)
13e157b1 1422 * @param nbRequested @see org.eclipse.linuxtools.tmf.request.TmfEventRequest#TmfEventRequest(...)
73005152
BH		 1423 * @param blockSize @see org.eclipse.linuxtools.tmf.request.TmfEventRequest#TmfEventRequest(...)
1424 * @param execType @see org.eclipse.linuxtools.tmf.request.TmfEventRequest#TmfEventRequest(...)
1425 * @param criteria The search criteria
1426 * @param monitor progress monitor
1427 */
1428 public SearchEventRequest(TmfTimeRange range, int nbRequested, int blockSize, ExecutionType execType, Criteria criteria, IProgressMonitor monitor) {
13e157b1 1429 super(ITmfEvent.class, range, nbRequested, blockSize, execType);
73005152
BH		 1430 fCriteria = new Criteria(criteria);
1431 fMonitor = monitor;
1432 }
13e157b1 1433
73005152
BH		 1434 /*
1435 * (non-Javadoc)
1436 * @see org.eclipse.linuxtools.tmf.request.TmfDataRequest#handleData(org.eclipse.linuxtools.tmf.event.TmfData)
1437 */
1438 @Override
5419a136
AM		 1439 public void handleData(ITmfEvent event) {
1440 super.handleData(event);
73005152
BH		 1441
1442 if ((fMonitor!= null) && fMonitor.isCanceled()) {
e6ace8bb 1443 super.cancel();
73005152
BH		 1444 return;
1445 }
1446
9a43af17 1447 ITmfSyncSequenceDiagramEvent sdEvent = getSequenceDiagramEvent(event);
13e157b1 1448
73005152
BH		 1449 if (sdEvent != null) {
1450
1451 if (fCriteria.isLifeLineSelected()) {
1452 if (fCriteria.matches(sdEvent.getSender())) {
4593bd5b 1453 fFoundTime = event.getTimestamp();
73005152
BH		 1454 fIsFound = true;
1455 super.cancel();
1456 }
1457
1458 if (fCriteria.matches(sdEvent.getReceiver())) {
4593bd5b 1459 fFoundTime = event.getTimestamp();
73005152
BH		 1460 fIsFound = true;
1461 super.cancel();
1462 }
1463 }
1464
eb63f5ff 1465 if (fCriteria.isSyncMessageSelected() && fCriteria.matches(sdEvent.getName())) {
4593bd5b 1466 fFoundTime = event.getTimestamp();
eb63f5ff
BH		 1467 fIsFound = true;
1468 super.cancel();
73005152
BH		 1469 }
1470 }
1471 }
1472
73005152
BH		 1473 /**
1474 * Set progress monitor.
a55887ca
AM		 1475 *
1476 * @param monitor The monitor to assign
73005152
BH		 1477 */
1478 public void setMonitor(IProgressMonitor monitor) {
1479 fMonitor = monitor;
1480 }
1481
1482 /**
1483 * Check if find criteria was met.
a55887ca 1484 *
73005152
BH		 1485 * @return true if find criteria was met.
1486 */
1487 public boolean isFound() {
1488 return fIsFound;
1489 }
1490
1491 /**
df0b8ff4 1492 * Returns timestamp of found time.
a55887ca 1493 *
73005152 1494 * @return timestamp of found time.
3bd46eef 1495 * @since 2.0
73005152 1496 */
4df4581d 1497 public ITmfTimestamp getFoundTime() {
73005152
BH		 1498 return fFoundTime;
1499 }
1500 }
1501
3145ec83 1502 /**
a55887ca
AM		 1503 * Job class to provide progress monitor feedback.
1504 *
3145ec83
BH		 1505 * @version 1.0
1506 * @author Bernd Hufmann
1507 *
1508 */
1509 protected static class IndexingJob extends Job {
1510
4b4a1525
BH		 1511 /**
1512 * @param name The job name
1513 */
3145ec83
BH		 1514 public IndexingJob(String name) {
1515 super(name);
1516 }
1517
1518 @Override
1519 protected IStatus run(IProgressMonitor monitor) {
1520 while (!monitor.isCanceled()) {
1521 try {
1522 Thread.sleep(100);
1523 } catch (InterruptedException e) {
1524 return Status.OK_STATUS;
1525 }
1526 }
1527 monitor.done();
1528 return Status.OK_STATUS;
1529 }
1530 }
1531
a55887ca 1532
73005152 1533 /**
df0b8ff4 1534 * Returns sequence diagram event if details in given event are available else null.
a55887ca 1535 *
73005152
BH		 1536 * @param tmfEvent Event to parse for sequence diagram event details
1537 * @return sequence diagram event if details are available else null
9a43af17 1538 * @since 2.0
73005152 1539 */
9a43af17 1540 protected ITmfSyncSequenceDiagramEvent getSequenceDiagramEvent(ITmfEvent tmfEvent){
73005152
BH		 1541 //type = .*RECEIVE.* or .*SEND.*
1542 //content = sender:<sender name>:receiver:<receiver name>,signal:<signal name>
1543 String eventType = tmfEvent.getType().toString();
9a43af17
BH		 1544 if (eventType.contains(Messages.TmfUml2SDSyncLoader_EventTypeSend) || eventType.contains(Messages.TmfUml2SDSyncLoader_EventTypeReceive)) {
1545 Object sender = tmfEvent.getContent().getField(Messages.TmfUml2SDSyncLoader_FieldSender);
1546 Object receiver = tmfEvent.getContent().getField(Messages.TmfUml2SDSyncLoader_FieldReceiver);
1547 Object name = tmfEvent.getContent().getField(Messages.TmfUml2SDSyncLoader_FieldSignal);
13e157b1 1548 if ((sender instanceof ITmfEventField) && (receiver instanceof ITmfEventField) && (name instanceof ITmfEventField)) {
4c564a2d 1549 ITmfSyncSequenceDiagramEvent sdEvent = new TmfSyncSequenceDiagramEvent(tmfEvent,
13e157b1
MK		 1550 ((ITmfEventField) sender).getValue().toString(),
1551 ((ITmfEventField) receiver).getValue().toString(),
1552 ((ITmfEventField) name).getValue().toString());
4c564a2d
FC		 1553
1554 return sdEvent;
1555 }
73005152
BH		 1556 }
1557 return null;
1558 }
1559}
Tracecompass - Deliverables
This page took 0.161744 seconds and 5 git commands to generate.