if (top == null) {
return false;
}
-
+ /*
+ * index if needed
+ */
+ if (hasMoreEvents()) {
+ StreamInputPacketReader packetReader = top.getPacketReader();
+ boolean packetHasMoreEvents = packetReader.hasMoreEvents();
+ StreamInputPacketIndexEntry currentPacket = packetReader
+ .getCurrentPacket();
+ if (!packetHasMoreEvents) {
+ int n = this.streamInputReaders.indexOf(top);
+ currentPacket.setIndexBegin(startIndex[n]);
+ currentPacket.setIndexEnd(index);
+ startIndex[n] = index + 1;
+ }
+ }
/*
* Read the next event of this reader.
*/
final long topEnd = top.getCurrentEvent().timestamp;
this.endTime = Math.max(topEnd, this.endTime);
this.eventCountPerTraceFile[top.getName()]++;
- }
- if (hasMoreEvents()) {
/*
* increment the index
*/
index++;
- StreamInputPacketReader packetReader = top.getPacketReader();
-
- if (packetReader.hasMoreEvents() == false) {
- int n = this.streamInputReaders.indexOf(top);
- StreamInputPacketIndexEntry currentPacket = packetReader
- .getCurrentPacket();
- currentPacket.setIndexBegin(startIndex[n]);
- currentPacket.setIndexEnd(index);
- startIndex[n] = index + 1;
- }
}
+ boolean hasMoreEvents = hasMoreEvents();
+
/*
* If there is no reader in the queue, it means the trace reader reached
* the end of the trace.
*/
- return hasMoreEvents();
+ return hasMoreEvents;
}
/**
}
} catch (CTFReaderException e) {
/*
- * Important, if it failed, it's because it's not yet indexed,
- * so we have to manually advance to the right value.
+ * Important, if it failed, it's because it's not yet indexed, so we
+ * have to manually advance to the right value.
*/
for (StreamInputReader streamInputReader : this.streamInputReaders) {
/*
this.prio.add(streamInputReader);
}
}
- /*
- * advance for offset
- */
- while ((prio.peek().getCurrentEvent().timestamp < tempTimestamp)
- && hasMoreEvents()) {
- this.advance();
+ if (tempIndex == Long.MAX_VALUE) {
+ tempIndex = 0;
}
long pos = tempIndex;
- for (pos = tempIndex; (pos < index) && hasMoreEvents(); pos++) {
- this.advance();
+ if (index > tempIndex) {
+ /*
+ * advance for offset
+ */
+ while ((prio.peek().getCurrentEvent().timestamp < tempTimestamp)
+ && hasMoreEvents()) {
+ this.advance();
+ }
+
+ for (pos = tempIndex; (pos < index) && hasMoreEvents(); pos++) {
+ this.advance();
+ }
}
this.index = pos;
return hasMoreEvents();
packetOffsetBytes += (packetIndex.getPacketSizeBits() + 7) / 8;
}
+ index.getEntries().get(0).setIndexBegin(0L);
}
}
private long timestampEnd = 0;
- private long indexBegin = -1;
+ private long indexBegin = Long.MAX_VALUE;
- private long indexEnd = -1;
+ private long indexEnd = Long.MAX_VALUE;
// ------------------------------------------------------------------------
// Constructors
import java.io.BufferedWriter;\r
import java.io.FileWriter;\r
import java.io.IOException;\r
+import java.io.OutputStreamWriter;\r
\r
import org.eclipse.core.runtime.Platform;\r
import org.eclipse.linuxtools.tmf.core.component.ITmfComponent;\r
static Boolean EVENT = Boolean.FALSE;\r
\r
private static String LOGNAME = "trace.log";\r
- private static BufferedWriter fTraceLog = null;\r
+ private static BufferedWriter fTraceLog = new BufferedWriter(new OutputStreamWriter(System.out));\r
\r
private static BufferedWriter openLogFile(String filename) {\r
BufferedWriter outfile = null;\r
}\r
\r
public static void stop() {\r
- if (fTraceLog == null)\r
+ if (fTraceLog == null) {\r
return;\r
+ }\r
\r
try {\r
fTraceLog.close();\r
import org.eclipse.linuxtools.ctf.core.event.types.Definition;
import org.eclipse.linuxtools.ctf.core.event.types.StructDefinition;
import org.eclipse.linuxtools.ctf.core.trace.StreamInputReader;
+import org.eclipse.linuxtools.internal.tmf.core.TmfCorePlugin;
import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
import org.eclipse.linuxtools.tmf.core.event.ITmfEventField;
import org.eclipse.linuxtools.tmf.core.event.ITmfEventType;
import org.eclipse.linuxtools.tmf.core.event.ITmfTimestamp;
-import org.eclipse.linuxtools.tmf.core.event.TmfEventField;
-import org.eclipse.linuxtools.tmf.core.event.TmfTimestamp;
/**
* <b><u>CTFEvent</u></b>
private static final String NO_STREAM = "No stream"; //$NON-NLS-1$
private static final String EMPTY_CTF_EVENT_NAME = "Empty CTF event"; //$NON-NLS-1$
+ private static final String CONTEXT_ID = "Ctf Event"; //$NON-NLS-1$
// ------------------------------------------------------------------------
// Attributes
private final String eventName;
private final String fileName;
- private final TmfEventField fContent;
+ private final CtfTmfContent fContent;
// ------------------------------------------------------------------------
// Constructors
this.fileName = top.getStreamInput().getFilename();
/* Read the fields */
- this.fContent = new TmfEventField(ITmfEventField.ROOT_FIELD_ID,
+ this.fContent = new CtfTmfContent(ITmfEventField.ROOT_FIELD_ID,
parseFields(eventDef));
}
this.fileName = other.fileName;
/* Copy the fields over */
- this.fContent = other.fContent.clone();
+ this.fContent = (CtfTmfContent) other.fContent.clone();
}
/**
* Inner constructor to create "null" events. Don't use this directly, use
* CTFEvent.getNullEvent();
*/
- private CtfTmfEvent() {
+ public CtfTmfEvent() {
this.fTrace = null;
this.timestamp = -1;
this.sourceCPU = -1;
@Override
public ITmfTimestamp getTimestamp() {
if (fTimestamp == null) {
- fTimestamp = new TmfTimestamp(timestamp);
+ fTimestamp = new CtfTmfTimestamp(timestamp, fTrace);
}
return fTimestamp;
}
+ String fSource = null;
@Override
public String getSource() {
- // TODO Returns eventName for now
- return eventName;
+ // TODO Returns CPU for now
+ if(fSource == null) {
+ fSource= Integer.toString(getCPU());
+ }
+ return fSource;
}
+ private CtfTmfEventType type = null;
@Override
public ITmfEventType getType() {
- // TODO Auto-generated method stub
- return null;
+ if(type == null){
+ type = new CtfTmfEventType(CONTEXT_ID, eventName, fContent);
+ }
+ return type;
}
@Override
return fContent;
}
+ String fReference = null;
@Override
public String getReference() {
- // TODO Auto-generated method stub
- return null;
+ if( fReference == null){
+ fReference = getChannelName();
+ }
+ return fReference;
}
@Override
// this.fEndTime.clone()));
}
-
-
@Override
public void indexTrace(boolean waitForCompletion) {
}
@Override
public ITmfContext seekLocation(ITmfLocation<?> location) {
+ if (location == null) {
+ location = new CtfLocation(0L);
+ }
iterator.setLocation(location);
return iterator;
}
/*******************************************************************************\r
* Copyright (c) 2010 Ericsson\r
- * \r
+ *\r
* All rights reserved. This program and the accompanying materials are\r
* made available under the terms of the Eclipse Public License v1.0 which\r
* accompanies this distribution, and is available at\r
* http://www.eclipse.org/legal/epl-v10.html\r
- * \r
+ *\r
* Contributors:\r
* Patrick Tasse - Initial API and implementation\r
*******************************************************************************/\r
\r
\r
public class TmfFilterNode extends TmfFilterTreeNode {\r
- \r
+\r
public static final String NODE_NAME = "FILTER"; //$NON-NLS-1$\r
public static final String NAME_ATTR = "name"; //$NON-NLS-1$\r
- \r
+\r
String fFilterName;\r
- \r
+\r
public TmfFilterNode(String filterName) {\r
super(null);\r
fFilterName = filterName;\r
public List<String> getValidChildren() {\r
if (getChildrenCount() == 0) {\r
return super.getValidChildren();\r
- } else {\r
- return new ArrayList<String>(0); // only one child allowed\r
}\r
+ return new ArrayList<String>(0); // only one child allowed\r
}\r
\r
@Override\r
for (int i = 0; i < getChildrenCount(); i++) {\r
ITmfFilterTreeNode node = getChildren()[i];\r
buf.append(node.toString());\r
- if (i < getChildrenCount() - 1) {\r
+ if (i < (getChildrenCount() - 1)) {\r
buf.append(" and "); //$NON-NLS-1$\r
}\r
}\r
/*******************************************************************************\r
* Copyright (c) 2010 Ericsson\r
- * \r
+ *\r
* All rights reserved. This program and the accompanying materials are\r
* made available under the terms of the Eclipse Public License v1.0 which\r
* accompanies this distribution, and is available at\r
* http://www.eclipse.org/legal/epl-v10.html\r
- * \r
+ *\r
* Contributors:\r
* Yuriy Vashchuk (yvashchuk@gmail.com) - Initial API and implementation\r
* Patrick Tasse - Refactoring\r
* <p>\r
*/\r
public abstract class TmfFilterTreeNode implements ITmfFilterTreeNode, Cloneable {\r
- \r
+\r
private static final String[] VALID_CHILDREN = {\r
TmfFilterEventTypeNode.NODE_NAME,\r
TmfFilterAndNode.NODE_NAME,\r
TmfFilterMatchesNode.NODE_NAME,\r
TmfFilterCompareNode.NODE_NAME\r
};\r
- \r
+\r
private ITmfFilterTreeNode parent = null;\r
private ArrayList<ITmfFilterTreeNode> children = new ArrayList<ITmfFilterTreeNode>();\r
\r
parent.addChild(this);\r
}\r
}\r
- \r
+\r
/* (non-Javadoc)\r
* @see org.eclipse.linuxtools.tmf.filter.model.ITmfFilterTreeNode#getParent()\r
*/\r
this.parent = parent;\r
}\r
\r
- \r
+\r
/* (non-Javadoc)\r
* @see org.eclipse.linuxtools.tmf.filter.model.ITmfFilterTreeNode#matches(org.eclipse.linuxtools.tmf.event.TmfEvent)\r
*/\r
value = event.getType().getName();\r
}\r
else if (ITmfEvent.EVENT_FIELD_TIMESTAMP.equals(field)) {\r
- value = ((Long) event.getTimestamp().getValue()).toString();\r
+ value = event.getTimestamp().toString();\r
}\r
else if (ITmfEvent.EVENT_FIELD_SOURCE.equals(field)) {\r
value = event.getSource();\r
\r
/* (non-Javadoc)\r
* @see org.eclipse.linuxtools.tmf.filter.model.ITmfFilterTreeNode#getValidChildren()\r
- * \r
+ *\r
* By default, all node types are valid children. Override if different.\r
*/\r
@Override\r
protected ITmfEventField[] extractItemFields(ITmfEvent event) {\r
ITmfEventField[] fields = new TmfEventField[0];\r
if (event != null) {\r
- String timestamp = ((Long) event.getTimestamp().getValue()).toString();\r
+ String timestamp = event.getTimestamp().toString();\r
String source = event.getSource();\r
String type = event.getType().getName();\r
String reference = event.getReference();\r
projects / deliverable / tracecompass.git / commitdiff
