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