org.eclipse.linuxtools.lttng.core/src/org/eclipse/linuxtools/lttng/core/event/LttngTimestamp.java

   1 /*******************************************************************************
   2  * Copyright (c) 2009 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  *   William Bourque (wbourque@gmail.com) - Initial API and implementation
  11  *******************************************************************************/
  12
  13 package org.eclipse.linuxtools.lttng.core.event;
  14
  15 import org.eclipse.linuxtools.tmf.core.event.TmfTimestamp;
  16
  17 /**
  18  * <b><u>LttngTimestamp</u></b><p>
  19  *
  20  * Lttng specific implementation of the TmfTimestamp.<p>
  21  *
  22  * The Lttng implementation is the same as the basic Tmf Implementation but allow construction with a TmfTimestamp or a long.
  23  */
  24 public class LttngTimestamp extends TmfTimestamp {
  25
  26     // Required by Serializable
  27         private static final long serialVersionUID = -7016853105162491273L;
  28
  29     /**
  30      * Default Constructor.<p>
  31      *
  32      */
  33         public LttngTimestamp() {
  34             super(Long.MIN_VALUE, (byte) -9);
  35         }
  36
  37         /**
  38      * Constructor with parameters.<p>
  39      *
  40      * @param newEventTime    Time as long, unit expected to be nanoseconds
  41      */
  42     public LttngTimestamp(long newEventTime) {
  43         super(newEventTime, (byte) -9);
  44     }
  45
  46     /**
  47      * Copy Constructor.<p>
  48      *
  49      * @param oldEventTime    The timestamp object we want to copy from
  50      */
  51     public LttngTimestamp(TmfTimestamp oldEventTime) {
  52         this(oldEventTime.getValue());
  53     }
  54
  55     @Override
  56     public long getValue() {
  57         return fValue;
  58     }
  59
  60     public void setValue(long newValue) {
  61         fValue = newValue;
  62     }
  63
  64         /**
  65          * Get the second part in timestamp.<p>
  66          *
  67          * Note : We do not use scale and assumes contents to be in nano seconds.
  68          *
  69          * @return Seconds in the object, in string.
  70          */
  71         public String getSeconds() {
  72                 return formatSecs(fValue);
  73         }
  74
  75         /**
  76      * Get the nanosecond part in timestamp.<p>
  77      *
  78      * Note : We do not use scale and assumes contents to be in nanoseconds.
  79          *
  80          * @return Seconds in the object, in string.
  81          */
  82         public String getNanoSeconds() {
  83                 return formatNs(fValue);
  84         }
  85
  86         /*
  87          * Use the exponent to format the second in the correct format.
  88          */
  89         private String formatSecs(long time) {
  90                 long sec = (long) (time * 1E-9);
  91                 return String.valueOf(sec);
  92         }
  93
  94         /*
  95          * Obtains the remainder fraction on unit Seconds of the entered value in
  96          * nanoseconds. e.g. input: 1241207054171080214 ns.
  97          * The number of fraction seconds can be obtained by removing the last 9 digits:
  98          * In 1241207054, the fractional portion of seconds, expressed in ns is: 171080214
  99          */
 100         private String formatNs(long time) {
 101                 boolean neg = time < 0;
 102                 if (neg) {
 103                         time = -time;
 104                 }
 105                 // The following approach could be used although performance
 106                 // decreases in half.
 107                 // String strVal = String.format("%09d", time);
 108                 // String tmp = strVal.substring(strVal.length() - 9)
 109                 StringBuffer temp = new StringBuffer();
 110                 long ns = time;
 111                 ns %= 1000000000;
 112                 if (ns < 10) {
 113                         temp.append("00000000"); //$NON-NLS-1$
 114                 } else if (ns < 100) {
 115                         temp.append("0000000"); //$NON-NLS-1$
 116                 } else if (ns < 1000) {
 117                         temp.append("000000"); //$NON-NLS-1$
 118                 } else if (ns < 10000) {
 119                         temp.append("00000"); //$NON-NLS-1$
 120                 } else if (ns < 100000) {
 121                         temp.append("0000"); //$NON-NLS-1$
 122                 } else if (ns < 1000000) {
 123                         temp.append("000"); //$NON-NLS-1$
 124                 } else if (ns < 10000000) {
 125                         temp.append("00"); //$NON-NLS-1$
 126                 } else if (ns < 100000000) {
 127                         temp.append("0"); //$NON-NLS-1$
 128                 }
 129
 130                 temp.append(ns);
 131                 return temp.toString();
 132         }
 133
 134
 135     /**
 136      * toString() method.
 137      *
 138      * @return timestamp, as string
 139      */
 140     @Override
 141     @SuppressWarnings("nls")
 142         public String toString() {
 143
 144         long value = fValue;
 145         if (fValue < 0) {
 146             value = -fValue;
 147         }
 148
 149         StringBuilder sb = new StringBuilder(String.valueOf(value));
 150
 151         // Prepend the correct number of "0" so we can insert a "." at the right location
 152         int nbZeroes = (-fScale) - sb.length() + 1;
 153         for (int i = 0; i < nbZeroes; i++) {
 154             sb.insert(i, "0");
 155         }
 156         sb.insert(sb.length() + fScale, ".");
 157
 158         // Prepend "-" if negative
 159         if (fValue < 0) {
 160             sb.insert(0, "-");
 161         }
 162
 163         return sb.toString();
 164     }
 165
 166     @Override
 167     public LttngTimestamp clone() {
 168         return (LttngTimestamp) super.clone();
 169     }
 170
 171     /**
 172      * Compute the delta between two timestamps (adjusted to scale of current timestamp).
 173      *
 174      * @param reference the reference timestamp to synchronize with
 175      * @return the delta timestamp
 176      * @throws ArithmeticException
 177      */
 178     @Override
 179     public LttngTimestamp getDelta(TmfTimestamp other) throws ArithmeticException {
 180         TmfTimestamp delta = super.getDelta(other);
 181         return new LttngTimestamp(delta);
 182     }
 183 }