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()
 156                 .getTimestampValue(), curRank);
 157         return clone;
 158     }
 159
 160     /**
 161      * Method dispose.
 162      * @see org.eclipse.linuxtools.tmf.core.trace.ITmfContext#dispose()
 163      */
 164     @Override
 165     public void dispose() {
 166         // FIXME add dispose() stuff to CTFTrace and call it here...
 167
 168     }
 169
 170     /**
 171      * Method setLocation.
 172      * @param location ITmfLocation<?>
 173      * @see org.eclipse.linuxtools.tmf.core.trace.ITmfContext#setLocation(ITmfLocation<?>)
 174      */
 175     @Override
 176     public void setLocation(final ITmfLocation<?> location) {
 177         // FIXME alex: isn't there a cleaner way than a cast here?
 178         this.curLocation = (CtfLocation) location;
 179         seek(((CtfLocation) location).getLocation());
 180     }
 181
 182     /**
 183      * Method getLocation.
 184      * @return CtfLocation
 185      * @see org.eclipse.linuxtools.tmf.core.trace.ITmfContext#getLocation()
 186      */
 187     @Override
 188     public CtfLocation getLocation() {
 189         return curLocation;
 190     }
 191
 192     /**
 193      * Method increaseRank.
 194      * @see org.eclipse.linuxtools.tmf.core.trace.ITmfContext#increaseRank()
 195      */
 196     @Override
 197     public void increaseRank() {
 198         curRank++;
 199     }
 200
 201     /**
 202      * Method hasValidRank, if the iterator is valid
 203      * @return boolean
 204      * @see org.eclipse.linuxtools.tmf.core.trace.ITmfContext#hasValidRank()
 205      */
 206     @Override
 207     public boolean hasValidRank() {
 208         return (getRank() >= 0);
 209     }
 210
 211     /**
 212      * Method advance go to the next event
 213      * @return boolean successful or not
 214      */
 215     @Override
 216     public boolean advance() {
 217         boolean ret = super.advance();
 218         if (ret) {
 219             curLocation.setLocation(getCurrentEvent().getTimestampValue());
 220         } else {
 221             curLocation = NULL_LOCATION;
 222         }
 223         return ret;
 224     }
 225
 226     /**
 227      * Method compareTo.
 228      * @param o CtfIterator
 229      * @return int -1, 0, 1
 230      */
 231     @Override
 232     public int compareTo(final CtfIterator o) {
 233         if (this.getRank() < o.getRank()) {
 234             return -1;
 235         } else if (this.getRank() > o.getRank()) {
 236             return 1;
 237         }
 238         return 0;
 239     }
 240     /* (non-Javadoc)
 241      * @see java.lang.Object#hashCode()
 242      */
 243     @Override
 244     public int hashCode() {
 245         final int prime = 31;
 246         int result = super.hashCode();
 247         result = (prime * result)
 248                 + ((ctfTmfTrace == null) ? 0 : ctfTmfTrace.hashCode());
 249         result = (prime * result)
 250                 + ((curLocation == null) ? 0 : curLocation.hashCode());
 251         result = (prime * result) + (int) (curRank ^ (curRank >>> 32));
 252         return result;
 253     }
 254
 255     /* (non-Javadoc)
 256      * @see java.lang.Object#equals(java.lang.Object)
 257      */
 258     @Override
 259     public boolean equals(Object obj) {
 260         if (this == obj) {
 261             return true;
 262         }
 263         if (!super.equals(obj)) {
 264             return false;
 265         }
 266         if (!(obj instanceof CtfIterator)) {
 267             return false;
 268         }
 269         CtfIterator other = (CtfIterator) obj;
 270         if (ctfTmfTrace == null) {
 271             if (other.ctfTmfTrace != null) {
 272                 return false;
 273             }
 274         } else if (!ctfTmfTrace.equals(other.ctfTmfTrace)) {
 275             return false;
 276         }
 277         if (curLocation == null) {
 278             if (other.curLocation != null) {
 279                 return false;
 280             }
 281         } else if (!curLocation.equals(other.curLocation)) {
 282             return false;
 283         }
 284         if (curRank != other.curRank) {
 285             return false;
 286         }
 287         return true;
 288     }
 289 }