org.eclipse.linuxtools.tmf.core.tests/stubs/org/eclipse/linuxtools/tmf/tests/stubs/trace/TmfTraceStub.java

   1 /*******************************************************************************
   2  * Copyright (c) 2009, 2010 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  *   Francois Chouinard - Initial API and implementation
  11  *******************************************************************************/
  12
  13 package org.eclipse.linuxtools.tmf.tests.stubs.trace;
  14
  15 import java.io.FileNotFoundException;
  16 import java.io.IOException;
  17 import java.io.RandomAccessFile;
  18 import java.util.concurrent.locks.ReentrantLock;
  19
  20 import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
  21 import org.eclipse.linuxtools.tmf.core.event.ITmfTimestamp;
  22 import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
  23 import org.eclipse.linuxtools.tmf.core.event.TmfTimeRange;
  24 import org.eclipse.linuxtools.tmf.core.parser.ITmfEventParser;
  25 import org.eclipse.linuxtools.tmf.core.trace.ITmfContext;
  26 import org.eclipse.linuxtools.tmf.core.trace.ITmfLocation;
  27 import org.eclipse.linuxtools.tmf.core.trace.TmfContext;
  28 import org.eclipse.linuxtools.tmf.core.trace.TmfLocation;
  29 import org.eclipse.linuxtools.tmf.core.trace.TmfTrace;
  30
  31 /**
  32  * <b><u>TmfTraceStub</u></b>
  33  * <p>
  34  * Dummy test trace. Use in conjunction with TmfEventParserStub.
  35  */
  36 @SuppressWarnings("nls")
  37 public class TmfTraceStub extends TmfTrace<TmfEvent> {
  38
  39     // ------------------------------------------------------------------------
  40     // Attributes
  41     // ------------------------------------------------------------------------
  42
  43     // The actual stream
  44     private RandomAccessFile fTrace;
  45
  46     // The associated event parser
  47     private ITmfEventParser<TmfEvent> fParser;
  48
  49     // The synchronization lock
  50     private ReentrantLock fLock = new ReentrantLock();
  51
  52     // ------------------------------------------------------------------------
  53     // Constructors
  54     // ------------------------------------------------------------------------
  55
  56     /**
  57      * @param path
  58      * @throws FileNotFoundException
  59      */
  60     public TmfTraceStub(String path) throws FileNotFoundException {
  61         this(path, DEFAULT_INDEX_PAGE_SIZE, false);
  62     }
  63
  64     /**
  65      * @param path
  66      * @param cacheSize
  67      * @throws FileNotFoundException
  68      */
  69     public TmfTraceStub(String path, int cacheSize) throws FileNotFoundException {
  70         this(path, cacheSize, false);
  71     }
  72
  73     /**
  74      * @param path
  75      * @param waitForCompletion
  76      * @throws FileNotFoundException
  77      */
  78     public TmfTraceStub(String path, boolean waitForCompletion) throws FileNotFoundException {
  79         this(path, DEFAULT_INDEX_PAGE_SIZE, waitForCompletion);
  80     }
  81
  82     /**
  83      * @param path
  84      * @param cacheSize
  85      * @param waitForCompletion
  86      * @throws FileNotFoundException
  87      */
  88     public TmfTraceStub(String path, int cacheSize, boolean waitForCompletion) throws FileNotFoundException {
  89         super(null, TmfEvent.class, path, cacheSize, false);
  90         fTrace = new RandomAccessFile(path, "r");
  91         fParser = new TmfEventParserStub();
  92     }
  93
  94
  95     /**
  96      * @param path
  97      * @param cacheSize
  98      * @param waitForCompletion
  99      * @param parser
 100      * @throws FileNotFoundException
 101      */
 102     public TmfTraceStub(String path, int cacheSize, boolean waitForCompletion, ITmfEventParser<TmfEvent> parser) throws FileNotFoundException {
 103         super(path, TmfEvent.class, path, cacheSize, false);
 104         fTrace = new RandomAccessFile(path, "r");
 105         fParser = parser;
 106     }
 107
 108     /**
 109      */
 110     @Override
 111         public TmfTraceStub clone() {
 112         TmfTraceStub clone = null;
 113                 try {
 114                         clone = (TmfTraceStub) super.clone();
 115                 clone.fTrace  = new RandomAccessFile(getPath(), "r");
 116                 clone.fParser = new TmfEventParserStub();
 117                 } catch (FileNotFoundException e) {
 118                 }
 119         return clone;
 120     }
 121
 122     // ------------------------------------------------------------------------
 123     // Accessors
 124     // ------------------------------------------------------------------------
 125
 126     public RandomAccessFile getStream() {
 127         return fTrace;
 128     }
 129
 130     // ------------------------------------------------------------------------
 131     // Operators
 132     // ------------------------------------------------------------------------
 133
 134         @Override
 135         @SuppressWarnings("unchecked")
 136         public TmfContext seekLocation(ITmfLocation<?> location) {
 137             fLock.lock();
 138         try {
 139             if (fTrace != null) {
 140                 // Position the trace at the requested location and
 141                 // returns the corresponding context
 142                 long loc  = 0;
 143                 long rank = 0;
 144                 if (location != null) {
 145                     loc = ((TmfLocation<Long>) location).getLocation();
 146                     rank = ITmfContext.UNKNOWN_RANK;
 147                 }
 148                 if (loc != fTrace.getFilePointer()) {
 149                     fTrace.seek(loc);
 150                 }
 151                 TmfContext context = new TmfContext(getCurrentLocation(), rank);
 152                 return context;
 153             }
 154                 } catch (IOException e) {
 155                         e.printStackTrace();
 156                 }
 157         finally{
 158             fLock.unlock();
 159         }
 160                 return null;
 161     }
 162
 163
 164         @Override
 165     public TmfContext seekLocation(double ratio) {
 166             fLock.lock();
 167         try {
 168             if (fTrace != null) {
 169                 ITmfLocation<?> location = new TmfLocation<Long>(Long.valueOf((long) (ratio * fTrace.length())));
 170                 TmfContext context = seekLocation(location);
 171                 context.setRank(ITmfContext.UNKNOWN_RANK);
 172                 return context;
 173             }
 174         } catch (IOException e) {
 175             e.printStackTrace();
 176         } finally {
 177             fLock.unlock();
 178         }
 179
 180         return null;
 181     }
 182
 183     @Override
 184     @SuppressWarnings("rawtypes")
 185     public double getLocationRatio(ITmfLocation location) {
 186         fLock.lock();
 187         try {
 188             if (fTrace != null) {
 189                 if (location.getLocation() instanceof Long) {
 190                     return (double) ((Long) location.getLocation()) / fTrace.length();
 191                 }
 192             }
 193         } catch (IOException e) {
 194             e.printStackTrace();
 195         } finally {
 196             fLock.unlock();
 197         }
 198         return 0;
 199     }
 200
 201     @Override
 202         public TmfLocation<Long> getCurrentLocation() {
 203         fLock.lock();
 204         try {
 205             if (fTrace != null) {
 206                 return new TmfLocation<Long>(fTrace.getFilePointer());
 207             }
 208         } catch (IOException e) {
 209             e.printStackTrace();
 210         } finally {
 211             fLock.unlock();
 212         }
 213         return null;
 214     }
 215
 216         @Override
 217         public ITmfEvent parseEvent(ITmfContext context) {
 218             fLock.lock();
 219         try {
 220                         // parseNextEvent will update the context
 221             if (fTrace != null) {
 222                 ITmfEvent event = fParser.parseNextEvent(this, context.clone());
 223                 return event;
 224             }
 225         }
 226         catch (IOException e) {
 227                 e.printStackTrace();
 228         } finally {
 229             fLock.unlock();
 230         }
 231         return null;
 232         }
 233
 234         @Override
 235         public void setTimeRange(TmfTimeRange range) {
 236         super.setTimeRange(range);
 237     }
 238
 239         @Override
 240         public void setStartTime(ITmfTimestamp startTime) {
 241         super.setStartTime(startTime);
 242     }
 243
 244         @Override
 245         public void setEndTime(ITmfTimestamp endTime) {
 246         super.setEndTime(endTime);
 247     }
 248
 249         @Override
 250         public void dispose() {
 251             fLock.lock();
 252             try {
 253                 if (fTrace != null) {
 254                     fTrace.close();
 255                     fTrace = null;
 256                 }
 257             } catch (IOException e) {
 258                 // Ignore
 259             } finally {
 260                 fLock.unlock();
 261             }
 262             super.dispose();
 263         }
 264
 265 }