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