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         /* Only increase the rank if it's valid */
 199         if(hasValidRank()) {
 200             curRank++;
 201         }
 202     }
 203
 204     /**
 205      * Method hasValidRank, if the iterator is valid
 206      * @return boolean
 207      * @see org.eclipse.linuxtools.tmf.core.trace.ITmfContext#hasValidRank()
 208      */
 209     @Override
 210     public boolean hasValidRank() {
 211         return (getRank() >= 0);
 212     }
 213
 214     /**
 215      * Method advance go to the next event
 216      * @return boolean successful or not
 217      */
 218     @Override
 219     public boolean advance() {
 220         boolean ret = super.advance();
 221         if (ret) {
 222             curLocation.setLocation(getCurrentEvent().getTimestampValue());
 223         } else {
 224             curLocation = NULL_LOCATION;
 225         }
 226         return ret;
 227     }
 228
 229     /**
 230      * Method compareTo.
 231      * @param o CtfIterator
 232      * @return int -1, 0, 1
 233      */
 234     @Override
 235     public int compareTo(final CtfIterator o) {
 236         if (this.getRank() < o.getRank()) {
 237             return -1;
 238         } else if (this.getRank() > o.getRank()) {
 239             return 1;
 240         }
 241         return 0;
 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 }