org.eclipse.linuxtools.lttng/src/org/eclipse/linuxtools/lttng/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.event;
  14
  15 import org.eclipse.linuxtools.tmf.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");
 114                 } else if (ns < 100) {
 115                         temp.append("0000000");
 116                 } else if (ns < 1000) {
 117                         temp.append("000000");
 118                 } else if (ns < 10000) {
 119                         temp.append("00000");
 120                 } else if (ns < 100000) {
 121                         temp.append("0000");
 122                 } else if (ns < 1000000) {
 123                         temp.append("000");
 124                 } else if (ns < 10000000) {
 125                         temp.append("00");
 126                 } else if (ns < 100000000) {
 127                         temp.append("0");
 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         public String toString() {
 142
 143         // If we are dealing with units of seconds (or higher),
 144         // use the plain formatter
 145         if (fScale >= 0) {
 146             Double value = fValue * Math.pow(10, fScale);
 147             return value.toString();
 148         }
 149
 150         // Define a format string
 151         String format = String.format("%%1d.%%0%dd", -fScale);
 152
 153         // And format the timestamp value
 154         double scale = Math.pow(10, fScale);
 155         long seconds = (long) (fValue * scale);
 156         long fracts  = fValue - (long) ((double) seconds / scale);
 157         String result = String.format(format, seconds, fracts);
 158
 159         return result;
 160     }
 161
 162     @Override
 163     public LttngTimestamp clone() {
 164         return (LttngTimestamp) super.clone();
 165     }
 166
 167 }