/*******************************************************************************
- * Copyright (c) 2012 Ericsson
+ * Copyright (c) 2012, 2013 Ericsson
*
* All rights reserved. This program and the accompanying materials are made
* available under the terms of the Eclipse Public License v1.0 which
* accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
- * Contributors: Matthew Khouzam - Initial API and implementation
+ * Contributors:
+ * Matthew Khouzam - Initial API and implementation
+ * Patrick Tasse - Updated for removal of context clone
*******************************************************************************/
package org.eclipse.linuxtools.tmf.core.ctfadaptor;
+import java.util.Collections;
+import java.util.Map;
+
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
-import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.IStatus;
+import org.eclipse.core.runtime.Status;
+import org.eclipse.linuxtools.ctf.core.event.IEventDeclaration;
import org.eclipse.linuxtools.ctf.core.trace.CTFReaderException;
import org.eclipse.linuxtools.ctf.core.trace.CTFTrace;
-import org.eclipse.linuxtools.tmf.core.ctfadaptor.CtfTmfTimestamp.TimestampType;
+import org.eclipse.linuxtools.ctf.core.trace.CTFTraceReader;
+import org.eclipse.linuxtools.internal.tmf.core.Activator;
import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
-import org.eclipse.linuxtools.tmf.core.event.ITmfTimestamp;
-import org.eclipse.linuxtools.tmf.core.event.TmfTimestamp;
import org.eclipse.linuxtools.tmf.core.exceptions.TmfTraceException;
-import org.eclipse.linuxtools.tmf.core.statesystem.ITmfStateSystem;
+import org.eclipse.linuxtools.tmf.core.timestamp.ITmfTimestamp;
+import org.eclipse.linuxtools.tmf.core.timestamp.TmfTimestamp;
import org.eclipse.linuxtools.tmf.core.trace.ITmfContext;
import org.eclipse.linuxtools.tmf.core.trace.ITmfEventParser;
import org.eclipse.linuxtools.tmf.core.trace.ITmfLocation;
+import org.eclipse.linuxtools.tmf.core.trace.ITmfTraceProperties;
import org.eclipse.linuxtools.tmf.core.trace.TmfTrace;
/**
* @version 1.0
* @author Matthew khouzam
*/
-public class CtfTmfTrace extends TmfTrace implements ITmfEventParser {
-
+public class CtfTmfTrace extends TmfTrace
+ implements ITmfEventParser, ITmfTraceProperties {
- //-------------------------------------------
- // Constants
- //-------------------------------------------
+ // -------------------------------------------
+ // Constants
+ // -------------------------------------------
/**
* Default cache size for CTF traces
*/
protected static final int DEFAULT_CACHE_SIZE = 50000;
- //-------------------------------------------
- // Fields
- //-------------------------------------------
-
- /** Reference to the state system assigned to this trace */
- protected ITmfStateSystem ss = null;
+ // -------------------------------------------
+ // Fields
+ // -------------------------------------------
/* Reference to the CTF Trace */
private CTFTrace fTrace;
-
-
- //-------------------------------------------
- // TmfTrace Overrides
- //-------------------------------------------
+ // -------------------------------------------
+ // TmfTrace Overrides
+ // -------------------------------------------
/**
* Method initTrace.
*
*/
setCacheSize();
+ super.initTrace(resource, path, eventType);
+
@SuppressWarnings("unused")
CtfTmfEventType type;
try {
this.fTrace = new CTFTrace(path);
CtfIteratorManager.addTrace(this);
- CtfTmfLightweightContext ctx;
+ CtfTmfContext ctx;
/* Set the start and (current) end times for this trace */
- ctx = (CtfTmfLightweightContext) seekEvent(0L);
+ ctx = (CtfTmfContext) seekEvent(0L);
CtfTmfEvent event = getNext(ctx);
- if((ctx.getLocation().equals(CtfIterator.NULL_LOCATION)) || (ctx.getCurrentEvent() == null)) {
+ if ((ctx.getLocation().equals(CtfIterator.NULL_LOCATION)) || (ctx.getCurrentEvent() == null)) {
/* Handle the case where the trace is empty */
this.setStartTime(TmfTimestamp.BIG_BANG);
} else {
*/
throw new TmfTraceException(e.getMessage(), e);
}
-
- super.initTrace(resource, path, eventType);
-
- //FIXME This should be called via the ExperimentUpdated signal
- buildStateSystem();
-
- /* Refresh the project, so it can pick up new files that got created. */
- if ( resource != null) {
- try {
- resource.getProject().refreshLocal(IResource.DEPTH_INFINITE, null);
- } catch (CoreException e) {
- throw new TmfTraceException(e.getMessage(), e);
- }
- }
}
- /* (non-Javadoc)
- * @see org.eclipse.linuxtools.tmf.core.trace.TmfTrace#dispose()
- */
@Override
public synchronized void dispose() {
CtfIteratorManager.removeTrace(this);
+ if (fTrace != null) {
+ fTrace.dispose();
+ fTrace = null;
+ }
super.dispose();
}
/**
* Method validate.
- * @param project IProject
- * @param path String
- * @return boolean
+ *
+ * @param project
+ * IProject
+ * @param path
+ * String
+ * @return IStatus IStatus.error or Status.OK_STATUS
* @see org.eclipse.linuxtools.tmf.core.trace.ITmfTrace#validate(IProject, String)
+ * @since 2.0
*/
@Override
- public boolean validate(final IProject project, final String path) {
+ public IStatus validate(final IProject project, final String path) {
+ IStatus validTrace = Status.OK_STATUS;
try {
final CTFTrace temp = new CTFTrace(path);
- return temp.majortIsSet(); // random test
+ if (!temp.majortIsSet()) {
+ validTrace = new Status(IStatus.ERROR, Activator.PLUGIN_ID, Messages.CtfTmfTrace_MajorNotSet);
+ } else {
+ CTFTraceReader ctfTraceReader = new CTFTraceReader(temp);
+ if (!ctfTraceReader.hasMoreEvents()) {
+ // TODO: This will need an additional check when we support live traces
+ // because having no event is valid for a live trace
+ validTrace = new Status(IStatus.ERROR, Activator.PLUGIN_ID, Messages.CtfTmfTrace_NoEvent);
+ }
+ ctfTraceReader.dispose();
+ }
+ temp.dispose();
} catch (final CTFReaderException e) {
- /* Nope, not a CTF trace we can read */
- return false;
+ validTrace = new Status(IStatus.ERROR, Activator.PLUGIN_ID, Messages.CtfTmfTrace_ReadingError +": " + e.toString()); //$NON-NLS-1$
}
+ return validTrace;
}
/**
* Method getCurrentLocation. This is not applicable in CTF
+ *
* @return null, since the trace has no knowledge of the current location
* @see org.eclipse.linuxtools.tmf.core.trace.ITmfTrace#getCurrentLocation()
*/
return null;
}
-
-
@Override
public double getLocationRatio(ITmfLocation location) {
final CtfLocation curLocation = (CtfLocation) location;
- final CtfTmfLightweightContext context = new CtfTmfLightweightContext(this);
+ final CtfTmfContext context = new CtfTmfContext(this);
context.setLocation(curLocation);
context.seek(curLocation.getLocationInfo());
- final CtfLocationData currentTime = ((CtfLocationData)context.getLocation().getLocationInfo());
+ final CtfLocationInfo currentTime = ((CtfLocationInfo) context.getLocation().getLocationInfo());
final long startTime = getIterator(this, context).getStartTime();
final long endTime = getIterator(this, context).getEndTime();
return ((double) currentTime.getTimestamp() - startTime)
/ (endTime - startTime);
}
-
-
-
-
- /* (non-Javadoc)
- * @see org.eclipse.linuxtools.tmf.core.trace.TmfTrace#seekEvent(org.eclipse.linuxtools.tmf.core.event.ITmfTimestamp)
- */
- @Override
- public synchronized ITmfContext seekEvent(ITmfTimestamp timestamp) {
- if( timestamp instanceof CtfTmfTimestamp){
- CtfTmfLightweightContext iter = new CtfTmfLightweightContext(this);
- iter.seek(timestamp.getValue());
- return iter;
- }
- return super.seekEvent(timestamp);
- }
-
/**
* Method seekEvent.
- * @param location ITmfLocation<?>
+ *
+ * @param location
+ * ITmfLocation<?>
* @return ITmfContext
*/
@Override
- public ITmfContext seekEvent(final ITmfLocation location) {
+ public synchronized ITmfContext seekEvent(final ITmfLocation location) {
CtfLocation currentLocation = (CtfLocation) location;
- CtfTmfLightweightContext context = new CtfTmfLightweightContext(this);
+ CtfTmfContext context = new CtfTmfContext(this);
+ if (fTrace == null) {
+ context.setLocation(null);
+ context.setRank(ITmfContext.UNKNOWN_RANK);
+ return context;
+ }
/*
* The rank is set to 0 if the iterator seeks the beginning. If not, it
* will be set to UNKNOWN_RANK, since CTF traces don't support seeking
* by rank for now.
*/
if (currentLocation == null) {
- currentLocation = new CtfLocation(new CtfLocationData(0L, 0L));
+ currentLocation = new CtfLocation(new CtfLocationInfo(0L, 0L));
context.setRank(0);
}
if (currentLocation.getLocationInfo() == CtfLocation.INVALID_LOCATION) {
- ((CtfTmfTimestamp) getEndTime()).setType(TimestampType.NANOS);
currentLocation = new CtfLocation(getEndTime().getValue() + 1, 0L);
}
context.setLocation(currentLocation);
currentLocation = new CtfLocation(event.getTimestamp().getValue(), 0);
}
}
- if(context.getRank() != 0) {
+ if (context.getRank() != 0) {
context.setRank(ITmfContext.UNKNOWN_RANK);
}
return context;
}
-
@Override
- public ITmfContext seekEvent(double ratio) {
- CtfTmfLightweightContext context = new CtfTmfLightweightContext(this);
+ public synchronized ITmfContext seekEvent(double ratio) {
+ CtfTmfContext context = new CtfTmfContext(this);
+ if (fTrace == null) {
+ context.setLocation(null);
+ context.setRank(ITmfContext.UNKNOWN_RANK);
+ return context;
+ }
final long end = this.getEndTime().getValue();
final long start = this.getStartTime().getValue();
final long diff = end - start;
/**
* Method readNextEvent.
- * @param context ITmfContext
+ *
+ * @param context
+ * ITmfContext
* @return CtfTmfEvent
* @see org.eclipse.linuxtools.tmf.core.trace.ITmfTrace#getNext(ITmfContext)
*/
@Override
public synchronized CtfTmfEvent getNext(final ITmfContext context) {
+ if (fTrace == null) {
+ return null;
+ }
CtfTmfEvent event = null;
- if (context instanceof CtfTmfLightweightContext) {
- if (CtfLocation.INVALID_LOCATION.equals(context.getLocation().getLocationInfo())) {
+ if (context instanceof CtfTmfContext) {
+ if (context.getLocation() == null || CtfLocation.INVALID_LOCATION.equals(context.getLocation().getLocationInfo())) {
return null;
}
- CtfTmfLightweightContext ctfContext = (CtfTmfLightweightContext) context;
+ CtfTmfContext ctfContext = (CtfTmfContext) context;
event = ctfContext.getCurrentEvent();
if (event != null) {
}
/**
- * Suppressing the warning, because the 'throws' will usually happen in
- * sub-classes.
+ * gets the CTFtrace that this is wrapping
*
- * @throws TmfTraceException
+ * @return the CTF trace
*/
- @SuppressWarnings("unused")
- protected void buildStateSystem() throws TmfTraceException {
- /*
- * Nothing is done in the basic implementation, please specify
- * how/if to build a state system in derived classes.
- */
- return;
+ public CTFTrace getCTFTrace() {
+ return fTrace;
}
+ // -------------------------------------------
+ // ITmfTraceProperties
+ // -------------------------------------------
+
/**
* @since 2.0
*/
@Override
- public ITmfStateSystem getStateSystem() {
- return this.ss;
- }
-
- /**
- * gets the CTFtrace that this is wrapping
- * @return the CTF trace
- */
- public CTFTrace getCTFTrace() {
- return fTrace;
+ public Map<String, String> getTraceProperties() {
+ return Collections.unmodifiableMap(fTrace.getEnvironment());
}
+ // -------------------------------------------
+ // Clocks
+ // -------------------------------------------
- //-------------------------------------------
- // Environment Parameters
- //-------------------------------------------
/**
- * Method getNbEnvVars.
+ * gets the clock offset
*
- * @return int
+ * @return the clock offset in ns
*/
- public int getNbEnvVars() {
- return this.fTrace.getEnvironment().size();
+ public long getOffset() {
+ if (fTrace != null) {
+ return fTrace.getOffset();
+ }
+ return 0;
}
/**
- * Method getEnvNames.
+ * Returns whether or not an event is in the metadata of the trace,
+ * therefore if it can possibly be in the trace. It does not verify whether
+ * or not the event is actually in the trace
*
- * @return String[]
+ * @param eventName
+ * The name of the event to check
+ * @return Whether the event is in the metadata or not
+ * @since 2.1
*/
- public String[] getEnvNames() {
- final String[] s = new String[getNbEnvVars()];
- return this.fTrace.getEnvironment().keySet().toArray(s);
+ public boolean hasEvent(final String eventName) {
+ Map<Long, IEventDeclaration> events = fTrace.getEvents(0L);
+ if (events != null) {
+ for (IEventDeclaration decl : events.values()) {
+ if (decl.getName().equals(eventName)) {
+ return true;
+ }
+ }
+ }
+ return false;
}
/**
- * Method getEnvValue.
+ * Return whether all requested events are in the metadata
*
- * @param key
- * String
- * @return String
+ * @param names
+ * The array of events to check for
+ * @return Whether all events are in the metadata
+ * @since 2.1
*/
- public String getEnvValue(final String key) {
- return this.fTrace.getEnvironment().get(key);
+ public boolean hasAllEvents(String[] names) {
+ for (String name : names) {
+ if (!hasEvent(name)) {
+ return false;
+ }
+ }
+ return true;
}
- //-------------------------------------------
- // Clocks
- //-------------------------------------------
-
/**
- * gets the clock offset
- * @return the clock offset in ns
+ * Returns whether the metadata contains at least one of the requested
+ * events
+ *
+ * @param names
+ * The array of event names of check for
+ * @return Whether one of the event is present in trace metadata
+ * @since 2.1
*/
- public long getOffset(){
- if( fTrace != null ) {
- return fTrace.getOffset();
+ public boolean hasAtLeastOneOfEvents(String[] names) {
+ for (String name : names) {
+ if (hasEvent(name)) {
+ return true;
+ }
}
- return 0;
+ return false;
}
- //-------------------------------------------
- // Parser
- //-------------------------------------------
+ // -------------------------------------------
+ // Parser
+ // -------------------------------------------
@Override
public CtfTmfEvent parseEvent(ITmfContext context) {
CtfTmfEvent event = null;
- if( context instanceof CtfTmfLightweightContext ){
- CtfTmfLightweightContext itt = (CtfTmfLightweightContext) context.clone();
- event = itt.getCurrentEvent();
+ if (context instanceof CtfTmfContext) {
+ final ITmfContext tmpContext = seekEvent(context.getLocation());
+ event = getNext(tmpContext);
}
return event;
}
setCacheSize(DEFAULT_CACHE_SIZE);
}
- //-------------------------------------------
- // Helpers
- //-------------------------------------------
+ // -------------------------------------------
+ // Helpers
+ // -------------------------------------------
- private static CtfIterator getIterator(CtfTmfTrace trace, CtfTmfLightweightContext context) {
+ private static CtfIterator getIterator(CtfTmfTrace trace, CtfTmfContext context) {
return CtfIteratorManager.getIterator(trace, context);
}
+
+ /**
+ * Get an iterator to the trace
+ *
+ * @return an iterator to the trace
+ * @since 2.0
+ */
+ public CtfIterator createIterator() {
+ return new CtfIterator(this);
+ }
}
projects / deliverable / tracecompass.git / blobdiff