org.eclipse.linuxtools.tmf.core/src/org/eclipse/linuxtools/tmf/core/ctfadaptor/CtfIterator.java

   1 /*******************************************************************************
   2  * Copyright (c) 2012 Ericsson
   3  *
   4  * All rights reserved. This program and the accompanying materials are made
   5  * 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: Matthew Khouzam - Initial API and implementation
  10  *******************************************************************************/
  11 package org.eclipse.linuxtools.tmf.core.ctfadaptor;
  12
  13 import org.eclipse.linuxtools.ctf.core.trace.CTFTraceReader;
  14 import org.eclipse.linuxtools.ctf.core.trace.StreamInputReader;
  15 import org.eclipse.linuxtools.tmf.core.trace.ITmfContext;
  16 import org.eclipse.linuxtools.tmf.core.trace.ITmfLocation;
  17
  18 /**
  19  * The ctfIterator is the class that will act like a reader for the trace
  20  * it does not have a file handle, so many iterators can be used without worries
  21  * of io errors.
  22  */
  23 public class CtfIterator extends CTFTraceReader implements ITmfContext, Comparable<CtfIterator>, Cloneable {
  24
  25     private final CtfTmfTrace ctfTmfTrace;
  26
  27     final public static CtfLocation NULL_LOCATION = new CtfLocation(
  28             CtfLocation.INVALID_LOCATION);
  29     private CtfLocation curLocation;
  30     private long curRank;
  31
  32     /**
  33      * Create a new CTF trace iterator, which initially points at the first
  34      * event in the trace.
  35      *
  36      * @param trace the trace to iterate over
  37      */
  38     public CtfIterator(final CtfTmfTrace trace) {
  39         super(trace.getCTFTrace());
  40         this.ctfTmfTrace = trace;
  41         if (this.hasMoreEvents()) {
  42
  43             this.curLocation = new CtfLocation(trace.getStartTime());
  44             this.curRank = 0;
  45         } else {
  46             setUnknownLocation();
  47         }
  48     }
  49
  50     /**
  51      *
  52      */
  53     private void setUnknownLocation() {
  54         this.curLocation = NULL_LOCATION;
  55         this.curRank = UNKNOWN_RANK;
  56     }
  57
  58     /**
  59      * Constructor for CtfIterator.
  60      * @param trace CtfTmfTrace the trace
  61      * @param timestampValue long the timestamp in ns of the trace for positioning
  62      * @param rank long the index of the trace for positioning
  63      */
  64     public CtfIterator(final CtfTmfTrace trace, final long timestampValue,
  65             final long rank) {
  66         super(trace.getCTFTrace());
  67
  68         this.ctfTmfTrace = trace;
  69         if (this.hasMoreEvents()) {
  70             this.curLocation = (new CtfLocation(this.getCurrentEvent()
  71                     .getTimestampValue()));
  72             if (this.getCurrentEvent().getTimestampValue() != timestampValue) {
  73                 this.seek(timestampValue);
  74                 this.curRank = rank;
  75             }
  76         } else {
  77             setUnknownLocation();
  78         }
  79
  80     }
  81
  82     /**
  83      * Method getCtfTmfTrace. gets a CtfTmfTrace
  84      * @return CtfTmfTrace
  85      */
  86     public CtfTmfTrace getCtfTmfTrace() {
  87         return ctfTmfTrace;
  88     }
  89
  90     /**
  91      * Method getCurrentEvent. gets the current event
  92      * @return CtfTmfEvent
  93      */
  94     public CtfTmfEvent getCurrentEvent() {
  95         final StreamInputReader top = super.prio.peek();
  96         if (top != null) {
  97             return new CtfTmfEvent(top.getCurrentEvent(), top.getFilename(),
  98                     ctfTmfTrace);
  99         }
 100         return null;
 101     }
 102
 103     /**
 104      * Method seek. Seeks to a given timestamp
 105      * @param timestamp long the timestamp in ns (utc)
 106      * @return boolean
 107      */
 108     @Override
 109     public boolean seek(final long timestamp) {
 110         boolean ret = false;
 111         final long offsetTimestamp = timestamp
 112                 - this.getTrace().getOffset();
 113         if (offsetTimestamp < 0) {
 114             ret = super.seek(timestamp);
 115         } else {
 116             ret = super.seek(offsetTimestamp);
 117         }
 118
 119         if (ret) {
 120             curLocation.setLocation(getCurrentEvent().getTimestampValue());
 121         } else {
 122             curLocation = NULL_LOCATION;
 123         }
 124         return ret;
 125     }
 126
 127     /**
 128      * Method getRank.
 129      * @return long
 130      * @see org.eclipse.linuxtools.tmf.core.trace.ITmfContext#getRank()
 131      */
 132     @Override
 133     public long getRank() {
 134         return curRank;
 135     }
 136
 137     /**
 138      * Method setRank.
 139      * @param rank long
 140      * @see org.eclipse.linuxtools.tmf.core.trace.ITmfContext#setRank(long)
 141      */
 142     @Override
 143     public void setRank(final long rank) {
 144         curRank = rank;
 145     }
 146
 147     /*
 148      * (non-Javadoc)
 149      *
 150      * @see org.eclipse.linuxtools.tmf.core.trace.TmfContext#clone()
 151      */
 152     @Override
 153     public CtfIterator clone() {
 154         CtfIterator clone = null;
 155         clone = new CtfIterator(ctfTmfTrace, this.getCurrentEvent().getTimestampValue(), curRank);
 156         return clone;
 157     }
 158
 159     /**
 160      * Method dispose.
 161      * @see org.eclipse.linuxtools.tmf.core.trace.ITmfContext#dispose()
 162      */
 163     @Override
 164     public void dispose() {
 165         // FIXME add dispose() stuff to CTFTrace and call it here...
 166
 167     }
 168
 169     /**
 170      * Method setLocation.
 171      * @param location ITmfLocation<?>
 172      * @see org.eclipse.linuxtools.tmf.core.trace.ITmfContext#setLocation(ITmfLocation<?>)
 173      */
 174     @Override
 175     public void setLocation(final ITmfLocation<?> location) {
 176         // FIXME alex: isn't there a cleaner way than a cast here?
 177         this.curLocation = (CtfLocation) location;
 178         seek(((CtfLocation) location).getLocation());
 179     }
 180
 181     /**
 182      * Method getLocation.
 183      * @return CtfLocation
 184      * @see org.eclipse.linuxtools.tmf.core.trace.ITmfContext#getLocation()
 185      */
 186     @Override
 187     public CtfLocation getLocation() {
 188         return curLocation;
 189     }
 190
 191     /**
 192      * Method increaseRank.
 193      * @see org.eclipse.linuxtools.tmf.core.trace.ITmfContext#increaseRank()
 194      */
 195     @Override
 196     public void increaseRank() {
 197         /* Only increase the rank if it's valid */
 198         if(hasValidRank()) {
 199             curRank++;
 200         }
 201     }
 202
 203     /**
 204      * Method hasValidRank, if the iterator is valid
 205      * @return boolean
 206      * @see org.eclipse.linuxtools.tmf.core.trace.ITmfContext#hasValidRank()
 207      */
 208     @Override
 209     public boolean hasValidRank() {
 210         return (getRank() >= 0);
 211     }
 212
 213     /**
 214      * Method advance go to the next event
 215      * @return boolean successful or not
 216      */
 217     @Override
 218     public boolean advance() {
 219         boolean ret = super.advance();
 220         if (ret) {
 221             curLocation.setLocation(getCurrentEvent().getTimestampValue());
 222         } else {
 223             curLocation = NULL_LOCATION;
 224         }
 225         return ret;
 226     }
 227
 228     /**
 229      * Method compareTo.
 230      * @param o CtfIterator
 231      * @return int -1, 0, 1
 232      */
 233     @Override
 234     public int compareTo(final CtfIterator o) {
 235         if (this.getRank() < o.getRank()) {
 236             return -1;
 237         } else if (this.getRank() > o.getRank()) {
 238             return 1;
 239         }
 240         return 0;
 241     }
 242
 243     /* (non-Javadoc)
 244      * @see java.lang.Object#hashCode()
 245      */
 246     @Override
 247     public int hashCode() {
 248         final int prime = 31;
 249         int result = super.hashCode();
 250         result = (prime * result)
 251                 + ((ctfTmfTrace == null) ? 0 : ctfTmfTrace.hashCode());
 252         result = (prime * result)
 253                 + ((curLocation == null) ? 0 : curLocation.hashCode());
 254         result = (prime * result) + (int) (curRank ^ (curRank >>> 32));
 255         return result;
 256     }
 257
 258     /* (non-Javadoc)
 259      * @see java.lang.Object#equals(java.lang.Object)
 260      */
 261     @Override
 262     public boolean equals(Object obj) {
 263         if (this == obj) {
 264             return true;
 265         }
 266         if (!super.equals(obj)) {
 267             return false;
 268         }
 269         if (!(obj instanceof CtfIterator)) {
 270             return false;
 271         }
 272         CtfIterator other = (CtfIterator) obj;
 273         if (ctfTmfTrace == null) {
 274             if (other.ctfTmfTrace != null) {
 275                 return false;
 276             }
 277         } else if (!ctfTmfTrace.equals(other.ctfTmfTrace)) {
 278             return false;
 279         }
 280         if (curLocation == null) {
 281             if (other.curLocation != null) {
 282                 return false;
 283             }
 284         } else if (!curLocation.equals(other.curLocation)) {
 285             return false;
 286         }
 287         if (curRank != other.curRank) {
 288             return false;
 289         }
 290         return true;
 291     }
 292 }