org.eclipse.linuxtools.tmf.ui/src/org/eclipse/linuxtools/tmf/ui/views/timechart/TimeChartEvent.java

   1 /*******************************************************************************
   2  * Copyright (c) 2010 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  *   Patrick Tasse - Initial API and implementation
  11  *******************************************************************************/
  12
  13 package org.eclipse.linuxtools.tmf.ui.views.timechart;
  14
  15 import java.util.ArrayList;
  16 import java.util.Iterator;
  17
  18 import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
  19 import org.eclipse.linuxtools.tmf.ui.views.colors.ColorSettingsManager;
  20 import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.model.ITimeEvent;
  21 import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.model.ITimeGraphEntry;
  22
  23 public class TimeChartEvent implements ITimeEvent {
  24
  25     private static final byte TIMESTAMP_SCALE = -9;
  26
  27     private TimeChartAnalysisEntry fParentEntry;
  28     private long fTime;
  29     private long fDuration;
  30     private long fFirstRank;
  31     private long fLastRank;
  32     private RankRangeList fRankRangeList;
  33     private long fNbEvents;
  34     private int fColorSettingPriority;
  35     private boolean fIsBookmark;
  36     private boolean fIsVisible;
  37     private boolean fIsSearchMatch;
  38     private TimeChartAnalysisEntry fItemizedEntry;
  39     private boolean fItemizing;
  40
  41     public TimeChartEvent(TimeChartAnalysisEntry parentEntry, ITmfEvent event, long rank, TimeChartDecorationProvider decorationProvider) {
  42         fParentEntry = parentEntry;
  43         fTime = event.getTimestamp().normalize(0, TIMESTAMP_SCALE).getValue();
  44         fDuration = 0;
  45         fFirstRank = fLastRank = rank;
  46         fRankRangeList = new RankRangeList(rank);
  47         fNbEvents = 1;
  48         fColorSettingPriority = ColorSettingsManager.getColorSettingPriority(event);
  49         fIsBookmark = decorationProvider.isBookmark(rank);
  50         fIsVisible = decorationProvider.isVisible(event);
  51         fIsSearchMatch = decorationProvider.isSearchMatch(event);
  52     }
  53
  54         @Override
  55     public ITimeGraphEntry getEntry() {
  56         return fParentEntry;
  57     }
  58
  59     @Override
  60     public long getTime() {
  61         return fTime;
  62     }
  63
  64     @Override
  65     public long getDuration() {
  66         return fDuration;
  67     }
  68
  69     public long getFirstRank() {
  70         return fFirstRank;
  71     }
  72
  73     public long getLastRank() {
  74         return fLastRank;
  75     }
  76
  77     public RankRangeList getRankRangeList() {
  78         return fRankRangeList;
  79     }
  80
  81     public void merge(TimeChartEvent event) {
  82         mergeDecorations(event);
  83         if (fTime == event.getTime() && fDuration == event.getDuration()) return;
  84         long endTime = Math.max(fTime + fDuration, event.getTime() + event.getDuration());
  85         fTime = Math.min(fTime, event.getTime());
  86         fDuration = endTime - fTime;
  87         fFirstRank = Math.min(fFirstRank, event.fFirstRank);
  88         fLastRank = Math.max(fLastRank, event.fLastRank);
  89         fNbEvents += event.fNbEvents;
  90         fItemizedEntry = null;
  91         synchronized (fRankRangeList) {
  92                 fRankRangeList.merge(event.getRankRangeList());
  93         }
  94     }
  95
  96     public void mergeDecorations(TimeChartEvent event) {
  97         fColorSettingPriority = Math.min(fColorSettingPriority, event.getColorSettingPriority());
  98         fIsBookmark |= event.fIsBookmark;
  99         fIsVisible |= event.fIsVisible;
 100         fIsSearchMatch |= event.fIsSearchMatch;
 101     }
 102
 103     public long getNbEvents() {
 104         return fNbEvents;
 105     }
 106
 107     public int getColorSettingPriority() {
 108         return fColorSettingPriority;
 109     }
 110
 111     public void setColorSettingPriority(int priority) {
 112         fColorSettingPriority = priority;
 113     }
 114
 115     public boolean isBookmarked() {
 116         return fIsBookmark;
 117     }
 118
 119     public void setIsBookmarked(boolean isBookmarked) {
 120         fIsBookmark = isBookmarked;
 121     }
 122
 123     public boolean isVisible() {
 124         return fIsVisible;
 125     }
 126
 127     public void setIsVisible(boolean isVisible) {
 128         fIsVisible = isVisible;
 129     }
 130
 131     public boolean isSearchMatch() {
 132         return fIsSearchMatch;
 133     }
 134
 135     public void setIsSearchMatch(boolean isSearchMatch) {
 136         fIsSearchMatch = isSearchMatch;
 137     }
 138
 139     public void setItemizedEntry(TimeChartAnalysisEntry timeAnalysisEntry) {
 140         fItemizedEntry = timeAnalysisEntry;
 141     }
 142
 143     public TimeChartAnalysisEntry getItemizedEntry() {
 144         return fItemizedEntry;
 145     }
 146
 147     public boolean isItemizing() {
 148         return fItemizing;
 149     }
 150
 151     public void setItemizing(boolean itemizing) {
 152         fItemizing = itemizing;
 153     }
 154
 155     public class RankRange {
 156         private long firstRank;
 157         private long lastRank;
 158
 159         public RankRange(long firstRank, long lastRank) {
 160             this.firstRank = firstRank;
 161             this.lastRank = lastRank;
 162         }
 163
 164         public long getFirstRank() {
 165             return firstRank;
 166         }
 167
 168         public long getLastRank() {
 169             return lastRank;
 170         }
 171
 172         public long distanceFrom(RankRange range) {
 173             if (range.lastRank < fFirstRank) {
 174                 return fFirstRank - range.lastRank;
 175             } else if (range.firstRank > fLastRank) {
 176                 return range.firstRank - fLastRank;
 177             } else {
 178                 return 0;
 179             }
 180         }
 181
 182         @Override
 183         public String toString() {
 184             return "["+firstRank+","+lastRank+"]"; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
 185         }
 186     }
 187
 188     private class RankRangeList extends ArrayList<RankRange> {
 189
 190         private static final long serialVersionUID = 6060485531208535986L;
 191
 192         public RankRangeList(long rank) {
 193             super(1);
 194             add(new RankRange(rank, rank));
 195         }
 196
 197         public void merge(RankRangeList rankRangeList) {
 198             long threshold = fParentEntry.getTrace().getCacheSize();
 199             for (RankRange newRange : rankRangeList) {
 200                 boolean merged = false;
 201                 for (RankRange oldRange : fRankRangeList) {
 202                     if (newRange.distanceFrom(oldRange) <= threshold) {
 203                         oldRange.firstRank = Math.min(oldRange.firstRank, newRange.firstRank);
 204                         oldRange.lastRank = Math.max(oldRange.lastRank, newRange.lastRank);
 205                         merged = true;
 206                         break;
 207                     }
 208                 }
 209                 if (!merged) {
 210                     add(newRange);
 211                 }
 212             }
 213             Iterator<RankRange> iterator = fRankRangeList.iterator();
 214             RankRange previous = null;
 215             while (iterator.hasNext()) {
 216                 RankRange range = iterator.next();
 217                 if (previous != null && range.distanceFrom(previous) <= threshold) {
 218                     previous.firstRank = Math.min(previous.firstRank, range.firstRank);
 219                     previous.lastRank = Math.max(previous.lastRank, range.lastRank);
 220                     iterator.remove();
 221                 }
 222                 previous = range;
 223             }
 224         }
 225     }
 226 }