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