org.eclipse.linuxtools.tmf.ui/src/org/eclipse/linuxtools/tmf/ui/widgets/timegraph/widgets/TimeDataProviderCyclesConverter.java

   1 /*******************************************************************************
   2  * Copyright (c) 2014 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.widgets.timegraph.widgets;
  14
  15 import org.eclipse.jdt.annotation.NonNull;
  16 import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.widgets.Utils.TimeFormat;
  17
  18 /**
  19  * Time Data Provider wrapper that converts nanoseconds to cycles.
  20  *
  21  * The user of the wrapper uses cycles, the wrapped provider uses nanoseconds.
  22  * @since 3.2
  23  *
  24  */
  25 public class TimeDataProviderCyclesConverter implements ITimeDataProviderConverter {
  26
  27     private static final long GIGAHERTZ = 1000000000L;
  28
  29     private final @NonNull ITimeDataProvider fProvider;
  30     private final long fFreq;
  31
  32     /**
  33      * Constructor
  34      *
  35      * @param provider
  36      *            the original time data provider
  37      * @param clockFrequency
  38      *            the clock frequency in Hz
  39      */
  40     public TimeDataProviderCyclesConverter(@NonNull ITimeDataProvider provider, long clockFrequency) {
  41         fProvider = provider;
  42         fFreq = clockFrequency;
  43     }
  44
  45     /**
  46      * Convert nanoseconds to cycles
  47      *
  48      * @param nanos
  49      *            time in nanoseconds
  50      * @return time in cycles
  51      */
  52     public long toCycles(long nanos) {
  53         return Math.round(nanos * ((double) fFreq / GIGAHERTZ));
  54     }
  55
  56     /**
  57      * Convert cycles to nanoseconds
  58      *
  59      * @param cycles
  60      *            time in cycles
  61      * @return time in nanoseconds
  62      */
  63     public long toNanos(long cycles) {
  64         return Math.round(cycles * ((double) GIGAHERTZ / fFreq));
  65     }
  66
  67     @Override
  68     public long convertTime(long time) {
  69         return toCycles(time);
  70     }
  71
  72     @Override
  73     public void setSelectionRangeNotify(long beginTime, long endTime) {
  74         fProvider.setSelectionRangeNotify(toNanos(beginTime), toNanos(endTime));
  75     }
  76
  77     @Override
  78     public void setSelectionRange(long beginTime, long endTime) {
  79         fProvider.setSelectionRange(toNanos(beginTime), toNanos(endTime));
  80     }
  81
  82     @Override
  83     public long getSelectionBegin() {
  84         return toCycles(fProvider.getSelectionBegin());
  85     }
  86
  87     @Override
  88     public long getSelectionEnd() {
  89         return toCycles(fProvider.getSelectionEnd());
  90     }
  91
  92     @Override
  93     public long getBeginTime() {
  94         return toCycles(fProvider.getBeginTime());
  95     }
  96
  97     @Override
  98     public long getEndTime() {
  99         return toCycles(fProvider.getEndTime());
 100     }
 101
 102     @Override
 103     public long getMinTime() {
 104         return toCycles(fProvider.getMinTime());
 105     }
 106
 107     @Override
 108     public long getMaxTime() {
 109         return toCycles(fProvider.getMaxTime());
 110     }
 111
 112     @Override
 113     public long getTime0() {
 114         return toCycles(fProvider.getTime0());
 115     }
 116
 117     @Override
 118     public long getTime1() {
 119         return toCycles(fProvider.getTime1());
 120     }
 121
 122     @Override
 123     public long getMinTimeInterval() {
 124         // do not convert: this is in integer units
 125         return fProvider.getMinTimeInterval();
 126     }
 127
 128     @Override
 129     public void setStartFinishTimeNotify(long time0, long time1) {
 130         fProvider.setStartFinishTimeNotify(toNanos(time0), toNanos(time1));
 131     }
 132
 133     @Override
 134     public void setStartFinishTime(long time0, long time1) {
 135         fProvider.setStartFinishTime(toNanos(time0), toNanos(time1));
 136     }
 137
 138     @Override
 139     public void notifyStartFinishTime() {
 140         fProvider.notifyStartFinishTime();
 141     }
 142
 143     @Override
 144     public void setSelectedTimeNotify(long time, boolean ensureVisible) {
 145         fProvider.setSelectedTimeNotify(toNanos(time), ensureVisible);
 146     }
 147
 148     @Override
 149     public void setSelectedTime(long time, boolean ensureVisible) {
 150         fProvider.setSelectedTime(toNanos(time), ensureVisible);
 151     }
 152
 153     @Override
 154     public void resetStartFinishTime() {
 155         fProvider.resetStartFinishTime();
 156     }
 157
 158     @Override
 159     public int getNameSpace() {
 160         return fProvider.getNameSpace();
 161     }
 162
 163     @Override
 164     public void setNameSpace(int width) {
 165         fProvider.setNameSpace(width);
 166     }
 167
 168     @Override
 169     public int getTimeSpace() {
 170         return fProvider.getTimeSpace();
 171     }
 172
 173     @Override
 174     public TimeFormat getTimeFormat() {
 175         return fProvider.getTimeFormat();
 176     }
 177
 178 }