Attachment 179155 Details for Bug 325662 – New handleData() API

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.

[patch] New handleData() API

325662.patch (text/plain), 95.55 KB, created by Francois Chouinard

on 2010-09-17 18:25:13 EDT

(hide)

Description:

Filename:

MIME Type:

Creator: Francois Chouinard

Created: 2010-09-17 18:25:13 EDT

Size: 95.55 KB

patch

obsolete

>### Eclipse Workspace Patch 1.0
>#P org.eclipse.linuxtools.lttng.headless
>Index: src/TmfTraceTest.java
>===================================================================
>--- src/TmfTraceTest.java	(revision 25481)
>+++ src/TmfTraceTest.java	(working copy)
>@@ -80,15 +80,11 @@
> 
> 	}
> 
>-
> 	@Override
>-    public void handleData() {
>-        LttngEvent[] result = getData();
>-        
>-        LttngEvent evt = (result.length > 0) ? result[0] : null;
>-        
>-        if ( (evt != null) && (PARSE_EVENTS) ) {
>-            ((LttngEvent) evt).getContent().getFields();
>+    public void handleData(LttngEvent event) {
>+		super.handleData(event);
>+        if ( (event != null) && (PARSE_EVENTS) ) {
>+            ((LttngEvent) event).getContent().getFields();
>             
>             // *** Uncomment the following to print the parsed content
>             // Warning : this is VERY intensive
>#P org.eclipse.linuxtools.lttng.ui
>Index: src/org/eclipse/linuxtools/lttng/ui/views/common/AbsTimeUpdateView.java
>===================================================================
>--- src/org/eclipse/linuxtools/lttng/ui/views/common/AbsTimeUpdateView.java	(revision 25481)
>+++ src/org/eclipse/linuxtools/lttng/ui/views/common/AbsTimeUpdateView.java	(working copy)
>@@ -26,7 +26,6 @@
> import org.eclipse.linuxtools.lttng.state.evProcessor.ITransEventProcessor;
> import org.eclipse.linuxtools.lttng.ui.TraceDebug;
> import org.eclipse.linuxtools.lttng.ui.model.trange.ItemContainer;
>-import org.eclipse.linuxtools.tmf.event.TmfEvent;
> import org.eclipse.linuxtools.tmf.event.TmfTimeRange;
> import org.eclipse.linuxtools.tmf.event.TmfTimestamp;
> import org.eclipse.linuxtools.tmf.experiment.TmfExperiment;
>@@ -373,26 +372,30 @@
> 			 * org.eclipse.linuxtools.lttng.request.LttngSyntEventRequest#handleData
> 			 * ()
> 			 */
>-//			int handleDataCount = 0;
>-//			int handleDataValidCount = 0;
>+////			int handleDataCount = 0;
>+////			int handleDataValidCount = 0;
>+//			@Override
>+//			public void handleData() {
>+//				LttngSyntheticEvent[] result = getData();
>+//	
>+//				TmfEvent evt = (result.length > 0) ? result[0] : null;
>+////				handleDataCount++;
>+
> 			@Override
>-			public void handleData() {
>-				LttngSyntheticEvent[] result = getData();
>-	
>-				TmfEvent evt = (result.length > 0) ? result[0] : null;
>-//				handleDataCount++;
>-				if (evt != null) {
>+			public void handleData(LttngSyntheticEvent event) {
>+				super.handleData(event);
>+				if (event != null) {
> //					handleDataValidCount++;
>-					LttngSyntheticEvent synEvent = (LttngSyntheticEvent) evt;
>+					LttngSyntheticEvent synEvent = (LttngSyntheticEvent) event;
> 					// process event
> 					SequenceInd indicator = synEvent.getSynType();
> 					if (indicator == SequenceInd.BEFORE
> 							|| indicator == SequenceInd.AFTER) {
>-						processor.process(evt, synEvent.getTraceModel());
>+						processor.process(event, synEvent.getTraceModel());
> 					} else if (indicator == SequenceInd.STARTREQ) {
> 						handleRequestStarted();
> 					} else if (indicator == SequenceInd.ENDREQ) {
>-						processor.process(evt, synEvent.getTraceModel());
>+						processor.process(event, synEvent.getTraceModel());
> 						// handleCompleted();
> 					}
> 	
>@@ -403,7 +406,7 @@
> 							modelInputChanged(this, false);
> 	
> 							if (TraceDebug.isDEBUG()) {
>-								frunningTimeStamp = evt.getTimestamp();
>+								frunningTimeStamp = event.getTimestamp();
> 								TraceDebug.debug("handled: " + fCount + " sequence: " + synEvent.getSynType());
> 							}
> 	
>Index: src/org/eclipse/linuxtools/lttng/ui/views/PerspectiveFactory.java
>===================================================================
>--- src/org/eclipse/linuxtools/lttng/ui/views/PerspectiveFactory.java	(revision 25481)
>+++ src/org/eclipse/linuxtools/lttng/ui/views/PerspectiveFactory.java	(working copy)
>@@ -31,6 +31,9 @@
>  */
> public class PerspectiveFactory implements IPerspectiveFactory {
> 
>+	// Perspective ID
>+    public static final String ID = "org.eclipse.linuxtools.lttng.ui.perspective";
>+	
>     // LTTng views
>     private static final String PROJECT_VIEW_ID      = ProjectView.ID;
>     private static final String CONTROL_VIEW_ID      = ControlView.ID;
>Index: src/org/eclipse/linuxtools/lttng/ui/views/histogram/HistogramRequest.java
>===================================================================
>--- src/org/eclipse/linuxtools/lttng/ui/views/histogram/HistogramRequest.java	(revision 25481)
>+++ src/org/eclipse/linuxtools/lttng/ui/views/histogram/HistogramRequest.java	(working copy)
>@@ -80,11 +80,15 @@
> 	 * HandleData function : will be called by TMF each time a new event is receive for the request.<p>
> 	 * Calculation for the content is done here.
> 	 */
>-	@Override
>-    public void handleData() {
>-        LttngEvent[] result = getData();
>-        LttngEvent event = (result.length > 0) ? result[0] : null;
>+//	@Override
>+//    public void handleData() {
>+//        LttngEvent[] result = getData();
>+//        LttngEvent event = (result.length > 0) ? result[0] : null;
>         
>+	@Override
>+    public void handleData(LttngEvent event) {
>+		super.handleData(event);
>+
>         // *** FIXME ***
>     	// *** EVIL BUG ***
>         // The request by timerange only does not work! (see constructor above) 
>@@ -93,23 +97,21 @@
>     	//
>         if (event != null) {
>         
>-        	LttngEvent tmpEvent = (LttngEvent) event;
>-
> //			Tracer.trace("Hst: " + event.getTimestamp());
>         	
>         	// This check is linked to the evil fix mentionned above
>-        	if ( ( tmpEvent.getTimestamp().getValue() >= parentCanvas.getHistogramContent().getStartTime() ) &&
>-        		 ( tmpEvent.getTimestamp().getValue() <= parentCanvas.getHistogramContent().getEndTime() ) )
>+        	if ( ( event.getTimestamp().getValue() >= parentCanvas.getHistogramContent().getStartTime() ) &&
>+        		 ( event.getTimestamp().getValue() <= parentCanvas.getHistogramContent().getEndTime() ) )
>         	{
>         		
>         		// Distance (in time) between this event and the last one we read
>-	        	long distance = ( tmpEvent.getTimestamp().getValue() - lastRangeTime );
>+	        	long distance = ( event.getTimestamp().getValue() - lastRangeTime );
> 				
> 	        	// Check if we changed of interval (the distance is higher than the interval time)
> 				if  ( distance > parentCanvas.getHistogramContent().getElementsTimeInterval() ) {
> 					
> 					parentCanvas.getHistogramContent().getElementByIndex(lastInterval).intervalNbEvents = nbEventsInInterval;
>-					lastRangeTime = tmpEvent.getTimestamp().getValue();
>+					lastRangeTime = event.getTimestamp().getValue();
> 					
> 					// * NOTE *
> 					// We can skip several interval at once, so we need to find what was our interval now
>Index: plugin.xml
>===================================================================
>--- plugin.xml	(revision 25481)
>+++ plugin.xml	(working copy)
>@@ -2,7 +2,7 @@
> <?eclipse version="3.4"?>
> <plugin>
>    <extension
>-         id="org,eclipse.linuxtools.lttng.ui.perspective"
>+         id="org.eclipse.linuxtools.lttng.ui.perspective"
>          name="%extension.name.0"
>          point="org.eclipse.ui.perspectives">
>       <perspective
>Index: ChangeLog
>===================================================================
>--- ChangeLog	(revision 25481)
>+++ ChangeLog	(working copy)
>@@ -1,3 +1,10 @@
>+2010-09-17  Francois Chouinard  <fchouinard@gmail.com>
>+
>+	* plugin.xml: Fixed perspective ID
>+	* src/org/eclipse/linuxtools/lttng/ui/views/common/AbsTimeUpdateView.java: Adjusted to new handleData() API 
>+	* src/org/eclipse/linuxtools/lttng/ui/views/histogram/HistogramRequest.java: Adjusted to new handleData() API
>+	* src/org/eclipse/linuxtools/lttng/ui/views/PerspectiveFactory.java: Fixed perspective ID
>+
> 2010-09-15  Francois Chouinard  <fchouinard@gmail.com>
> 
> 	* src/org/eclipse/linuxtools/lttng/ui/views/statistics/StatisticsView.java: ExecutionType update
>#P org.eclipse.linuxtools.tmf.ui
>Index: ChangeLog
>===================================================================
>--- ChangeLog	(revision 25481)
>+++ ChangeLog	(working copy)
>@@ -1,3 +1,7 @@
>+2010-09-17  Francois Chouinard  <fchouinard@gmail.com>
>+
>+	* src/org/eclipse/linuxtools/tmf/ui/viewers/events/TmfEventsTable.java: Adjusted to new handleData() API   
>+
> 2010-09-12  francois  <francois@sushi>
> 
> 	* src/org/eclipse/linuxtools/tmf/ui/widgets/TmfVirtualTable.java (handleTableKeyEvent): Fixed table scrolling issues
>Index: src/org/eclipse/linuxtools/tmf/ui/viewers/events/TmfEventsTable.java
>===================================================================
>--- src/org/eclipse/linuxtools/tmf/ui/viewers/events/TmfEventsTable.java	(revision 25481)
>+++ src/org/eclipse/linuxtools/tmf/ui/viewers/events/TmfEventsTable.java	(working copy)
>@@ -144,17 +144,33 @@
>                     return;
>                 }
> 
>+                fCacheStartIndex = index;
>+                fCacheEndIndex = index;
>+
>                 TmfDataRequest<TmfEvent> request = new TmfDataRequest<TmfEvent>(TmfEvent.class, index, fCacheSize) {
>-                    @Override
>-                    public void handleData() {
>-                        TmfEvent[] tmpEvent = getData();
>-                        if ((tmpEvent != null) && (tmpEvent.length > 0)) {
>-                            fCache = tmpEvent;
>-                            fCacheStartIndex = index;
>-                            fCacheEndIndex = index + tmpEvent.length;
>+//                    @Override
>+//                    public void handleData() {
>+//                        TmfEvent[] tmpEvent = getData();
>+//                        if ((tmpEvent != null) && (tmpEvent.length > 0)) {
>+//                            fCache = tmpEvent;
>+//                            fCacheStartIndex = index;
>+//                            fCacheEndIndex = index + tmpEvent.length;
>+//                        }
>+//                    }
>+
>+                	private int count = 0;
>+
>+                	@Override
>+                    public void handleData(TmfEvent event) {
>+                		super.handleData(event);
>+                        if (event != null) {
>+                            fCache[count++] = event.clone();
>+                            fCacheEndIndex++;
>                         }
>                     }
>+
>                 };
>+
>                 ((ITmfDataProvider<TmfEvent>) fTrace).sendRequest(request);
>                 try {
>                     request.waitForCompletion();
>#P org.eclipse.linuxtools.lttng
>Index: src/org/eclipse/linuxtools/lttng/control/LttngSyntheticEventProvider.java
>===================================================================
>--- src/org/eclipse/linuxtools/lttng/control/LttngSyntheticEventProvider.java	(revision 25481)
>+++ src/org/eclipse/linuxtools/lttng/control/LttngSyntheticEventProvider.java	(working copy)
>@@ -46,16 +46,15 @@
>  * @author alvaro
>  * 
>  */
>-public class LttngSyntheticEventProvider extends
>-		TmfEventProvider<LttngSyntheticEvent> {
>+public class LttngSyntheticEventProvider extends TmfEventProvider<LttngSyntheticEvent> {
> 
> 	// ========================================================================
> 	// Data
> 	// ========================================================================
>+
> 	public static final int BLOCK_SIZE = 1;
> 	public static final int NB_EVENTS  = 1;
>-	public static final int QUEUE_SIZE = 1; // lttng specific, one event at a
>-											// time
>+	public static final int QUEUE_SIZE = 1; // lttng specific, one event at a time
> 
> 	// TmfDataProvider<LttngEvent> fExtProvider = null;
> 	private ITmfDataRequest<LttngSyntheticEvent> fmainRequest = null;
>@@ -185,22 +184,14 @@
> 				 * ()
> 				 */
> 				@Override
>-				public void handleData() {
>-					LttngEvent[] events = getData();
>-					
>-//					Tracer.trace("Sep: " + events[0].getTimestamp());
>-
>-					if (events.length > 0) {
>-						for (LttngEvent e : events) {
>-							handleIncomingData(e);
>-						}
>+				public void handleData(LttngEvent event) {
>+					super.handleData(event);
>+					if (event != null) {
>+						handleIncomingData(event);
> 					} else {
> 						TraceDebug.debug("handle data received with no data");
>-//						handleProviderDone(getTraceModel());
>-//						done();
> 					}
> 				}
>-
> 				/*
> 				 * (non-Javadoc)
> 				 * 
>@@ -211,7 +202,6 @@
> 					// mark this sub-request as completed
> 					super.done();
> 					handleProviderDone(getTraceModel());
>-//					super.done();
> 				}
> 				
> 				/**
>@@ -222,14 +212,8 @@
> 				private void handleIncomingData(LttngEvent e) {
> 					long eventTime = e.getTimestamp().getValue();
> 
>-					// if (eventTime == 13589777932952L) {
>-					// // syscall entry id 78 expected
>-					// System.out.println("debug mark at 13589777932952L");
>-					// }
>-
> 					TmfTrace<LttngEvent> inTrace =  e.getParentTrace();
> 					if (!(inTrace == getTrace())) {
>-//						System.out.println("Event from a different trace discarded");
> 						return;
> 					}
> 					
>@@ -240,16 +224,8 @@
> 					if (eventTime >= fDispatchTime) {
> 						// Before update
> 						syntheticEvent.setSequenceInd(SequenceInd.BEFORE);
>-//						queueResult(syntheticEvent);
>-//						queueResult(syntheticAckIndicator);
>-
>-						LttngSyntheticEvent[] result = new LttngSyntheticEvent[1];
>-						result[0] = syntheticEvent;
>-						fmainRequest.setData(result);
>-						fmainRequest.handleData();
>-						result[0] = syntheticAckIndicator;
>-						fmainRequest.setData(result);
>-						fmainRequest.handleData();
>+						fmainRequest.handleData(syntheticEvent);
>+						fmainRequest.handleData(syntheticAckIndicator);
> 
> 						// Update state locally
> 						syntheticEvent.setSequenceInd(SequenceInd.UPDATE);
>@@ -257,16 +233,8 @@
> 
> 						// After Update
> 						syntheticEvent.setSequenceInd(SequenceInd.AFTER);
>-//						queueResult(syntheticEvent);
>-//						queueResult(syntheticAckIndicator);
>-
>-						result = new LttngSyntheticEvent[1];
>-						result[0] = syntheticEvent;
>-						fmainRequest.setData(result);
>-						fmainRequest.handleData();
>-						result[0] = syntheticAckIndicator;
>-						fmainRequest.setData(result);
>-						fmainRequest.handleData();
>+						fmainRequest.handleData(syntheticEvent);
>+						fmainRequest.handleData(syntheticAckIndicator);
> 
> 						// increment once per dispatch
> 						incrementSynEvenCount();
>@@ -339,21 +307,8 @@
> 		startIndEvent.setSequenceInd(SequenceInd.STARTREQ);
> 
> 		// Notify application
>-		LttngSyntheticEvent[] result = new LttngSyntheticEvent[1];
>-		result[0] = startIndEvent;
>-		fmainRequest.setData(result);
>-		fmainRequest.handleData();
>-		result[0] = fStatusEventAck;
>-		fmainRequest.setData(result);
>-		fmainRequest.handleData();
>-
>-//		try {
>-//			queueResult(startIndEvent);
>-//			queueResult(fStatusEventAck);
>-//		} catch (InterruptedException e) {
>-//			// TODO: cancel this request
>-//			e.printStackTrace();
>-//		}
>+		fmainRequest.handleData(startIndEvent);
>+		fmainRequest.handleData(fStatusEventAck);
> 
> 		// Notify state event processor
> 		fstateUpdateProcessor.process(startIndEvent, null);
>@@ -387,27 +342,9 @@
> 		finishEvent.setSequenceInd(SequenceInd.ENDREQ);
> 		finishEvent.setTraceModel(traceModel);
> 
>-		LttngSyntheticEvent[] result = new LttngSyntheticEvent[1];
>-		result[0] = finishEvent;
>-		fmainRequest.setData(result);
>-		fmainRequest.handleData();
>-		result[0] = fStatusEventAck;
>-		fmainRequest.setData(result);
>-		fmainRequest.handleData();
>-		
>+		fmainRequest.handleData(finishEvent);
>+		fmainRequest.handleData(fStatusEventAck);
> 		fmainRequest.done();
>-
>-		//		try {
>-//			queueResult(finishEvent);
>-//			queueResult(fStatusEventAck);
>-//			// End the loop in the main request
>-//			queueResult(LttngSyntheticEvent.NullEvent);
>-//		} catch (InterruptedException e) {
>-//			// System.out.println(getName() +
>-//			// ":handleProviderDone() failed to queue request");
>-//			// TODO: Cancel the request
>-////			e.printStackTrace();
>-//		}
> 	}
> 
> 	/**
>@@ -518,14 +455,4 @@
> 		return null;
> 	}
> 
>-//	@Override
>-//	public LttngSyntheticEvent getNext(ITmfContext context) {
>-//		return super.getNext(context);
>-//	}
>-
>-//	@Override
>-//	public void queueResult(LttngSyntheticEvent data) {
>-//		super.queueResult(data);
>-//	}
>-
> }
>Index: src/org/eclipse/linuxtools/lttng/state/experiment/StateExperimentManager.java
>===================================================================
>--- src/org/eclipse/linuxtools/lttng/state/experiment/StateExperimentManager.java	(revision 25481)
>+++ src/org/eclipse/linuxtools/lttng/state/experiment/StateExperimentManager.java	(working copy)
>@@ -203,22 +203,6 @@
> 
> 		// trigger data request to build the state system check points
> 		fStateCheckPointRequest = buildCheckPoints(experiment);
>-
>-//		LTTngTreeNode experimentNode = getChildByName(experiment.getName());
>-//		if (experimentNode != null) {
>-//			// get the trace manager nodes
>-//			LTTngTreeNode[] traceNodes = experimentNode.getChildren();
>-//			for (LTTngTreeNode traceStateManagerNode : traceNodes) {
>-//				// The trace node needs to perform its first data request
>-//				// for this experiment with the main goal of building its
>-//				// checkpoints
>-//				if (traceStateManagerNode instanceof ILttExperimentSelectedListener) {
>-//					// no need to provide the trace to the trace manager
>-//					((ILttExperimentSelectedListener) traceStateManagerNode).experimentUpdated(
>-//							new TmfExperimentUpdatedSignal(source, experiment, null), fwaitForCompletion);
>-//				}
>-//			}
>-//		}
> 	}
> 
> 	/*
>@@ -338,15 +322,10 @@
> 			 * org.eclipse.linuxtools.tmf.request.TmfDataRequest#handleData()
> 			 */
> 			@Override
>-			public void handleData() {
>-				LttngEvent[] events = getData();
>-				if (events.length > 0) {
>-					nbEvents++;
>-		
>-					LttngEvent event = (LttngEvent) events[0];
>-					
>+			public void handleData(LttngEvent event) {
>+				super.handleData(event);
>+				if (event != null) {
> //					Tracer.trace("Chk: " + event.getTimestamp());
>-					
> 					ITmfTrace trace = event.getParentTrace();
> 					IStateTraceManager traceManager = ftraceToManagerMap.get(getTraceKey(trace));
> 					if (traceManager != null) {
>@@ -400,9 +379,6 @@
> 			 * @param header
> 			 */
> 			private void printCompletedMessage() {
>-//				System.out.println(System.currentTimeMillis() + ": StateExperimentManager completed checkpoints");
>-
>-				// super.handleCompleted();
> 				if (TraceDebug.isDEBUG()) {
> 					TraceDebug.debug("Trace check point building completed, number of events handled: " + nbEvents
> 							+ "\n\t\t");
>Index: src/org/eclipse/linuxtools/lttng/state/trace/StateTraceManager.java
>===================================================================
>--- src/org/eclipse/linuxtools/lttng/state/trace/StateTraceManager.java	(revision 25481)
>+++ src/org/eclipse/linuxtools/lttng/state/trace/StateTraceManager.java	(working copy)
>@@ -351,12 +351,10 @@
> 		 * ()
> 		 */
> 		@Override
>-		public void handleData() {
>-			LttngSyntheticEvent[] result = getData();
>-
>-			evt[0] = (result.length > 0) ? result[0] : null;
>-			if (evt[0] != null) {
>-				synEvent = (LttngSyntheticEvent) evt[0];
>+		public void handleData(LttngSyntheticEvent event) {
>+			super.handleData(event);
>+			if (event != null) {
>+				synEvent = event;
> 				if (synEvent.getSynType() == SequenceInd.AFTER) {
> 					// Note : We call this function before incrementing
> 					// eventCount to save a default check point at the "0th"
>Index: src/org/eclipse/linuxtools/lttng/trace/LTTngTrace.java
>===================================================================
>--- src/org/eclipse/linuxtools/lttng/trace/LTTngTrace.java	(revision 25481)
>+++ src/org/eclipse/linuxtools/lttng/trace/LTTngTrace.java	(working copy)
>@@ -58,11 +58,11 @@
> //	// [lmcfrch]
> //	private long lastTime = 0;
> 
>-	public static boolean printDebug = false;
>+	public static boolean printDebug  = false;
> 	public static boolean uniqueEvent = false;
> 	
>     private final static boolean SHOW_LTT_DEBUG_DEFAULT    = false;
>-	private final static boolean IS_PARSING_NEEDED_DEFAULT = true;
>+	private final static boolean IS_PARSING_NEEDED_DEFAULT = !uniqueEvent;
> 	private final static int     CHECKPOINT_PAGE_SIZE      = 1000;
>     
>     // Reference to our JNI trace
>Index: src/org/eclipse/linuxtools/lttng/event/LttngEvent.java
>===================================================================
>--- src/org/eclipse/linuxtools/lttng/event/LttngEvent.java	(revision 25481)
>+++ src/org/eclipse/linuxtools/lttng/event/LttngEvent.java	(working copy)
>@@ -65,7 +65,7 @@
>     
>     
>     /**
>-     * Return the parent trace asoociated with this event
>+     * Return the parent trace associated with this event
>      * 
>      * @return Parent trace
>      */
>@@ -179,4 +179,9 @@
>     	
>     	return result.toString();
>     }
>+    
>+    @Override
>+	public LttngEvent clone() {
>+    	return new LttngEvent(this);
>+    }
> }
>Index: src/org/eclipse/linuxtools/lttng/request/LttngSyntEventRequest.java
>===================================================================
>--- src/org/eclipse/linuxtools/lttng/request/LttngSyntEventRequest.java	(revision 25481)
>+++ src/org/eclipse/linuxtools/lttng/request/LttngSyntEventRequest.java	(working copy)
>@@ -68,7 +68,6 @@
> 			TmfTimeRange experimentTimeRange, ITransEventProcessor processor, ExecutionType execType) {
> 		
> 		super(LttngSyntheticEvent.class, range, nbEvents, maxBlockSize, execType);
>-		//super(0, nbEvents, maxBlockSize);
> 		fExperimentTimeRange = experimentTimeRange;
> 		addListener(listener);
> 
>@@ -170,7 +169,8 @@
> 	 * @see org.eclipse.linuxtools.lttng.request.ILttngEventRequest#handleData()
> 	 */
> 	@Override
>-	public void handleData() {
>+	public void handleData(LttngSyntheticEvent event) {
>+		super.handleData(event);
> 	}
> 
> 
>Index: ChangeLog
>===================================================================
>--- ChangeLog	(revision 25481)
>+++ ChangeLog	(working copy)
>@@ -1,3 +1,12 @@
>+2010-09-17  Francois Chouinard  <fchouinard@gmail.com>
>+
>+	* src/org/eclipse/linuxtools/lttng/control/LttngSyntheticEventProvider.java: Adjusted to new handleData() API
>+	* src/org/eclipse/linuxtools/lttng/event/LttngEvent.java: Adjusted to new handleData() API
>+	* src/org/eclipse/linuxtools/lttng/request/LttngSyntEventRequest.java: Adjusted to new handleData() API
>+	* src/org/eclipse/linuxtools/lttng/state/experiment/StateExperimentManager.java: Adjusted to new handleData() API
>+	* src/org/eclipse/linuxtools/lttng/state/trace/StateTraceManager.java: Adjusted to new handleData() API
>+	* src/org/eclipse/linuxtools/lttng/trace/LTTngTrace.java: Adjusted to new handleData() API
>+
> 2010-09-15  Francois Chouinard  <fchouinard@gmail.com>
> 
> 	* src/org/eclipse/linuxtools/lttng/trace/LTTngExperiment.java: ExecutionType update
>#P org.eclipse.linuxtools.tmf.tests
>Index: stubs/org/eclipse/linuxtools/tmf/request/TmfDataRequestStub.java
>===================================================================
>--- stubs/org/eclipse/linuxtools/tmf/request/TmfDataRequestStub.java	(revision 25481)
>+++ stubs/org/eclipse/linuxtools/tmf/request/TmfDataRequestStub.java	(working copy)
>@@ -53,8 +53,8 @@
>     }
> 
> 	@Override
>-	public void handleData() {
>-		// TODO Auto-generated method stub
>+	public void handleData(T data) {
>+		super.handleData(data);
> 	}
> 
> }
>Index: stubs/org/eclipse/linuxtools/tmf/request/TmfEventRequestStub.java
>===================================================================
>--- stubs/org/eclipse/linuxtools/tmf/request/TmfEventRequestStub.java	(revision 25481)
>+++ stubs/org/eclipse/linuxtools/tmf/request/TmfEventRequestStub.java	(working copy)
>@@ -54,7 +54,7 @@
>     }
> 
> 	@Override
>-	public void handleData() {
>-		// TODO Auto-generated method stub
>+	public void handleData(T data) {
>+		super.handleData(data);
> 	}
> }
>Index: stubs/org/eclipse/linuxtools/tmf/component/TmfSyntheticEventProviderStub.java
>===================================================================
>--- stubs/org/eclipse/linuxtools/tmf/component/TmfSyntheticEventProviderStub.java	(revision 25481)
>+++ stubs/org/eclipse/linuxtools/tmf/component/TmfSyntheticEventProviderStub.java	(working copy)
>@@ -55,17 +55,14 @@
>         TmfTimeRange range = eventRequest.getRange();
>         final TmfEventRequest<TmfEvent> subRequest =
>         	new TmfEventRequest<TmfEvent>(TmfEvent.class, range, NB_EVENTS, BLOCK_SIZE) {
>-            	@Override
>-            	public void handleData() {
>-            		TmfEvent[] events = getData();
>-            		if (events.length > 0) {
>-            			for (TmfEvent e : events) {
>-            				handleIncomingData(e);
>-            			}
>-            		} else {
>-            			request.done();
>-            		}
>-            	}
>+        		@Override
>+        		public void handleData(TmfEvent event) {
>+            		super.handleData(event);
>+        			if (event != null)
>+        				handleIncomingData(event);
>+        			else
>+        				request.done();
>+        		}
>         	};
>         provider.sendRequest(subRequest);
> 
>Index: src/org/eclipse/linuxtools/tmf/tests/experiment/TmfExperimentTest.java
>===================================================================
>--- src/org/eclipse/linuxtools/tmf/tests/experiment/TmfExperimentTest.java	(revision 25481)
>+++ src/org/eclipse/linuxtools/tmf/tests/experiment/TmfExperimentTest.java	(working copy)
>@@ -563,11 +563,9 @@
>         TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);
>         final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, nbEvents, blockSize) {
>             @Override
>-            public void handleData() {
>-            	TmfEvent[] events = getData();
>-                for (TmfEvent e : events) {
>-                    requestedEvents.add(e);
>-                }
>+            public void handleData(TmfEvent event) {
>+            	super.handleData(event);
>+                requestedEvents.add(event);
>             }
>         };
>         fExperiment.sendRequest(request);
>@@ -592,13 +590,11 @@
> 
>         TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);
>         final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, nbEvents, blockSize) {
>-            @Override
>-            public void handleData() {
>-            	TmfEvent[] events = getData();
>-                for (TmfEvent e : events) {
>-                    requestedEvents.add(e);
>-                }
>-            }
>+        	@Override
>+        	public void handleData(TmfEvent event) {
>+        		super.handleData(event);
>+        		requestedEvents.add(event);
>+        	}
>         };
>         fExperiment.sendRequest(request);
>         request.waitForCompletion();
>@@ -623,13 +619,11 @@
> 
>         TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);
>         final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, nbEvents, blockSize) {
>-            @Override
>-            public void handleData() {
>-            	TmfEvent[] events = getData();
>-                for (TmfEvent e : events) {
>-                    requestedEvents.add(e);
>-                }
>-            }
>+        	@Override
>+        	public void handleData(TmfEvent event) {
>+        		super.handleData(event);
>+        		requestedEvents.add(event);
>+        	}
>         };
>         fExperiment.sendRequest(request);
>         request.waitForCompletion();
>@@ -657,15 +651,14 @@
> 
>         TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);
>         final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, nbEvents, blockSize) {
>-            @Override
>-            public void handleData() {
>-            	TmfEvent[] events = getData();
>-                for (TmfEvent e : events) {
>-                    requestedEvents.add(e);
>-                }
>-                // Cancel request after the first chunk is received
>-                cancel();
>-            }
>+        	int nbRead = 0;
>+        	@Override
>+        	public void handleData(TmfEvent event) {
>+        		super.handleData(event);
>+        		requestedEvents.add(event);
>+        		if (++nbRead == blockSize)
>+        			cancel();
>+        	}
>             @Override
>             public void handleCancel() {
>             	if (requestedEvents.size() < blockSize) {
>Index: src/org/eclipse/linuxtools/tmf/tests/experiment/TmfMultiTraceExperimentTest.java
>===================================================================
>--- src/org/eclipse/linuxtools/tmf/tests/experiment/TmfMultiTraceExperimentTest.java	(revision 25481)
>+++ src/org/eclipse/linuxtools/tmf/tests/experiment/TmfMultiTraceExperimentTest.java	(working copy)
>@@ -566,13 +566,11 @@
> 
>         TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);
>         final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, nbEvents, blockSize) {
>-            @Override
>-            public void handleData() {
>-            	TmfEvent[] events = getData();
>-                for (TmfEvent e : events) {
>-                    requestedEvents.add(e);
>-                }
>-            }
>+        	@Override
>+        	public void handleData(TmfEvent event) {
>+        		super.handleData(event);
>+        		requestedEvents.add(event);
>+        	}
>         };
>         fExperiment.sendRequest(request);
>         request.waitForCompletion();
>@@ -596,13 +594,11 @@
> 
>         TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);
>         final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, nbEvents, blockSize) {
>-            @Override
>-            public void handleData() {
>-            	TmfEvent[] events = getData();
>-                for (TmfEvent e : events) {
>-                    requestedEvents.add(e);
>-                }
>-            }
>+        	@Override
>+        	public void handleData(TmfEvent event) {
>+        		super.handleData(event);
>+        		requestedEvents.add(event);
>+        	}
>         };
>         fExperiment.sendRequest(request);
>         request.waitForCompletion();
>@@ -627,13 +623,11 @@
> 
>         TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);
>         final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, nbEvents, blockSize) {
>-            @Override
>-            public void handleData() {
>-            	TmfEvent[] events = getData();
>-                for (TmfEvent e : events) {
>-                    requestedEvents.add(e);
>-                }
>-            }
>+        	@Override
>+        	public void handleData(TmfEvent event) {
>+        		super.handleData(event);
>+        		requestedEvents.add(event);
>+        	}
>         };
>         fExperiment.sendRequest(request);
>         request.waitForCompletion();
>@@ -661,15 +655,14 @@
> 
>         TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);
>         final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, nbEvents, blockSize) {
>-            @Override
>-            public void handleData() {
>-            	TmfEvent[] events = getData();
>-                for (TmfEvent e : events) {
>-                    requestedEvents.add(e);
>-                }
>-                // Cancel request after the first chunk is received
>-                cancel();
>-            }
>+        	int nbRead = 0;
>+        	@Override
>+        	public void handleData(TmfEvent event) {
>+        		super.handleData(event);
>+        		requestedEvents.add(event);
>+        		if (++nbRead == blockSize)
>+        			cancel();
>+        	}
>             @Override
>             public void handleCancel() {
>             	if (requestedEvents.size() < blockSize) {
>Index: src/org/eclipse/linuxtools/tmf/tests/request/TmfDataRequestTest.java
>===================================================================
>--- src/org/eclipse/linuxtools/tmf/tests/request/TmfDataRequestTest.java	(revision 25481)
>+++ src/org/eclipse/linuxtools/tmf/tests/request/TmfDataRequestTest.java	(working copy)
>@@ -15,10 +15,6 @@
> import junit.framework.TestCase;
> 
> import org.eclipse.linuxtools.tmf.event.TmfEvent;
>-import org.eclipse.linuxtools.tmf.event.TmfEventReference;
>-import org.eclipse.linuxtools.tmf.event.TmfEventSource;
>-import org.eclipse.linuxtools.tmf.event.TmfEventType;
>-import org.eclipse.linuxtools.tmf.event.TmfTimestamp;
> import org.eclipse.linuxtools.tmf.request.TmfDataRequest;
> import org.eclipse.linuxtools.tmf.request.TmfDataRequestStub;
> 
>@@ -107,7 +103,6 @@
> 
>         assertEquals("getIndex", 0, request.getIndex());
>         assertEquals("getNbRequestedEvents", TmfDataRequest.ALL_DATA, request.getNbRequested());
>-        assertEquals("getBlockize", TmfDataRequest.DEFAULT_BLOCK_SIZE, request.getBlockize());
> 
>         assertFalse("isCompleted", request.isCompleted());
>         assertFalse("isFailed", request.isFailed());
>@@ -124,7 +119,6 @@
> 
>         assertEquals("getIndex", 10, request.getIndex());
>         assertEquals("getNbRequestedEvents", TmfDataRequest.ALL_DATA, request.getNbRequested());
>-        assertEquals("getBlockize", TmfDataRequest.DEFAULT_BLOCK_SIZE, request.getBlockize());
> 
>         assertFalse("isCompleted", request.isCompleted());
>         assertFalse("isFailed", request.isFailed());
>@@ -141,7 +135,6 @@
> 
>         assertEquals("getIndex", 10, request.getIndex());
>         assertEquals("getNbRequestedEvents", 100, request.getNbRequested());
>-        assertEquals("getBlockize", TmfDataRequest.DEFAULT_BLOCK_SIZE, request.getBlockize());
> 
>         assertFalse("isCompleted", request.isCompleted());
>         assertFalse("isFailed", request.isFailed());
>@@ -158,7 +151,6 @@
> 
>         assertEquals("getIndex", 10, request.getIndex());
>         assertEquals("getNbRequestedEvents", 100, request.getNbRequested());
>-        assertEquals("getBlockize", 200, request.getBlockize());
> 
>         assertFalse("isCompleted", request.isCompleted());
>         assertFalse("isFailed", request.isFailed());
>@@ -215,10 +207,10 @@
> 	// ------------------------------------------------------------------------
> 
> 	public void testToString() {
>-        String expected1 = "[TmfDataRequest(0,TmfEvent,10,100,200)]";
>-        String expected2 = "[TmfDataRequest(1,TmfEvent,20,100,200)]";
>-        String expected3 = "[TmfDataRequest(2,TmfEvent,20,200,200)]";
>-        String expected4 = "[TmfDataRequest(3,TmfEvent,20,200,300)]";
>+        String expected1 = "[TmfDataRequest(0,TmfEvent,10,100)]";
>+        String expected2 = "[TmfDataRequest(1,TmfEvent,20,100)]";
>+        String expected3 = "[TmfDataRequest(2,TmfEvent,20,200)]";
>+        String expected4 = "[TmfDataRequest(3,TmfEvent,20,200)]";
> 
>         assertEquals("toString", expected1, fRequest1.toString());
>         assertEquals("toString", expected2, fRequest2.toString());
>@@ -227,30 +219,6 @@
> 	}
> 
> 	// ------------------------------------------------------------------------
>-	// setData/getData
>-	// ------------------------------------------------------------------------
>-
>-	public void testSetData() {
>-		// Initialize the data
>-		int nbEvents = 10;
>-		TmfEvent[] events = new TmfEvent[nbEvents];
>-		for (int i = 0; i < nbEvents; i++) {
>-			events[i] = new TmfEvent(new TmfTimestamp(i), new TmfEventSource(),
>-					new TmfEventType(), new TmfEventReference());
>-		}
>-
>-		fRequest1.setData(events);
>-		assertEquals("setData", nbEvents, fRequest1.getNbRead());
>-
>-		TmfEvent[] eventsRead = fRequest1.getData();
>-		assertEquals("getData", nbEvents, eventsRead.length);
>-
>-		for (int i = 0; i < nbEvents; i++) {
>-			assertEquals("getData", i, eventsRead[i].getTimestamp().getValue());
>-		}
>-	}
>-
>-	// ------------------------------------------------------------------------
> 	// done
> 	// ------------------------------------------------------------------------
> 
>Index: src/org/eclipse/linuxtools/tmf/tests/request/TmfEventRequestTest.java
>===================================================================
>--- src/org/eclipse/linuxtools/tmf/tests/request/TmfEventRequestTest.java	(revision 25481)
>+++ src/org/eclipse/linuxtools/tmf/tests/request/TmfEventRequestTest.java	(working copy)
>@@ -15,9 +15,6 @@
> import junit.framework.TestCase;
> 
> import org.eclipse.linuxtools.tmf.event.TmfEvent;
>-import org.eclipse.linuxtools.tmf.event.TmfEventReference;
>-import org.eclipse.linuxtools.tmf.event.TmfEventSource;
>-import org.eclipse.linuxtools.tmf.event.TmfEventType;
> import org.eclipse.linuxtools.tmf.event.TmfTimeRange;
> import org.eclipse.linuxtools.tmf.event.TmfTimestamp;
> import org.eclipse.linuxtools.tmf.request.TmfDataRequest;
>@@ -115,7 +112,6 @@
> 
>         assertEquals("getIndex", 0, request.getIndex());
>         assertEquals("getNbRequestedEvents", TmfDataRequest.ALL_DATA, request.getNbRequested());
>-        assertEquals("getBlockize", TmfDataRequest.DEFAULT_BLOCK_SIZE, request.getBlockize());
> 
>         assertFalse("isCompleted", request.isCompleted());
>         assertFalse("isFailed", request.isFailed());
>@@ -136,7 +132,6 @@
> 
>         assertEquals("getIndex", 0, request.getIndex());
>         assertEquals("getNbRequestedEvents", TmfDataRequest.ALL_DATA, request.getNbRequested());
>-        assertEquals("getBlockize", TmfDataRequest.DEFAULT_BLOCK_SIZE, request.getBlockize());
> 
>         assertFalse("isCompleted", request.isCompleted());
>         assertFalse("isFailed", request.isFailed());
>@@ -157,7 +152,6 @@
> 
>         assertEquals("getIndex", 0, request.getIndex());
>         assertEquals("getNbRequestedEvents", 100, request.getNbRequested());
>-        assertEquals("getBlockize", TmfDataRequest.DEFAULT_BLOCK_SIZE, request.getBlockize());
> 
>         assertFalse("isCompleted", request.isCompleted());
>         assertFalse("isFailed", request.isFailed());
>@@ -178,7 +172,6 @@
> 
>         assertEquals("getIndex", 0, request.getIndex());
>         assertEquals("getNbRequestedEvents", 100, request.getNbRequested());
>-        assertEquals("getBlockize", 200, request.getBlockize());
> 
>         assertFalse("isCompleted", request.isCompleted());
>         assertFalse("isFailed", request.isFailed());
>@@ -235,10 +228,10 @@
> 	// ------------------------------------------------------------------------
> 
> 	public void testToString() {
>-        String expected1 = "[TmfEventRequest(0,TmfEvent," + range1 + ",100,200)]";
>-        String expected2 = "[TmfEventRequest(1,TmfEvent," + range2 + ",100,200)]";
>-        String expected3 = "[TmfEventRequest(2,TmfEvent," + range2 + ",200,200)]";
>-        String expected4 = "[TmfEventRequest(3,TmfEvent," + range2 + ",200,300)]";
>+        String expected1 = "[TmfEventRequest(0,TmfEvent," + range1 + ",100)]";
>+        String expected2 = "[TmfEventRequest(1,TmfEvent," + range2 + ",100)]";
>+        String expected3 = "[TmfEventRequest(2,TmfEvent," + range2 + ",200)]";
>+        String expected4 = "[TmfEventRequest(3,TmfEvent," + range2 + ",200)]";
> 
>         assertEquals("toString", expected1, fRequest1.toString());
>         assertEquals("toString", expected2, fRequest2.toString());
>@@ -247,30 +240,6 @@
> 	}
> 
> 	// ------------------------------------------------------------------------
>-	// setData/getData
>-	// ------------------------------------------------------------------------
>-
>-	public void testSetData() {
>-		// Initialize the data
>-		int nbEvents = 10;
>-		TmfEvent[] events = new TmfEvent[nbEvents];
>-		for (int i = 0; i < nbEvents; i++) {
>-			events[i] = new TmfEvent(new TmfTimestamp(i), new TmfEventSource(),
>-					new TmfEventType(), new TmfEventReference());
>-		}
>-
>-		fRequest1.setData(events);
>-		assertEquals("setData", nbEvents, fRequest1.getNbRead());
>-
>-		TmfEvent[] eventsRead = fRequest1.getData();
>-		assertEquals("getData", nbEvents, eventsRead.length);
>-
>-		for (int i = 0; i < nbEvents; i++) {
>-			assertEquals("getData", i, eventsRead[i].getTimestamp().getValue());
>-		}
>-	}
>-
>-	// ------------------------------------------------------------------------
> 	// done
> 	// ------------------------------------------------------------------------
> 
>Index: src/org/eclipse/linuxtools/tmf/tests/request/TmfCoalescedDataRequestTest.java
>===================================================================
>--- src/org/eclipse/linuxtools/tmf/tests/request/TmfCoalescedDataRequestTest.java	(revision 25481)
>+++ src/org/eclipse/linuxtools/tmf/tests/request/TmfCoalescedDataRequestTest.java	(working copy)
>@@ -16,10 +16,6 @@
> import junit.framework.TestCase;
> 
> import org.eclipse.linuxtools.tmf.event.TmfEvent;
>-import org.eclipse.linuxtools.tmf.event.TmfEventReference;
>-import org.eclipse.linuxtools.tmf.event.TmfEventSource;
>-import org.eclipse.linuxtools.tmf.event.TmfEventType;
>-import org.eclipse.linuxtools.tmf.event.TmfTimestamp;
> import org.eclipse.linuxtools.tmf.request.TmfCoalescedDataRequest;
> import org.eclipse.linuxtools.tmf.request.TmfDataRequest;
> import org.eclipse.linuxtools.tmf.request.TmfDataRequestStub;
>@@ -112,7 +108,6 @@
> 
>         assertEquals("getIndex", 0, request.getIndex());
>         assertEquals("getNbRequestedEvents", TmfDataRequest.ALL_DATA, request.getNbRequested());
>-        assertEquals("getBlockize", TmfDataRequest.DEFAULT_BLOCK_SIZE, request.getBlockize());
> 
>         assertFalse("isCompleted", request.isCompleted());
>         assertFalse("isFailed", request.isFailed());
>@@ -129,7 +124,6 @@
> 
>         assertEquals("getIndex", 10, request.getIndex());
>         assertEquals("getNbRequestedEvents", TmfDataRequest.ALL_DATA, request.getNbRequested());
>-        assertEquals("getBlockize", TmfDataRequest.DEFAULT_BLOCK_SIZE, request.getBlockize());
> 
>         assertFalse("isCompleted", request.isCompleted());
>         assertFalse("isFailed", request.isFailed());
>@@ -146,7 +140,6 @@
> 
>         assertEquals("getIndex", 10, request.getIndex());
>         assertEquals("getNbRequestedEvents", 100, request.getNbRequested());
>-        assertEquals("getBlockize", TmfDataRequest.DEFAULT_BLOCK_SIZE, request.getBlockize());
> 
>         assertFalse("isCompleted", request.isCompleted());
>         assertFalse("isFailed", request.isFailed());
>@@ -163,7 +156,6 @@
> 
>         assertEquals("getIndex", 10, request.getIndex());
>         assertEquals("getNbRequestedEvents", 100, request.getNbRequested());
>-        assertEquals("getBlockize", 200, request.getBlockize());
> 
>         assertFalse("isCompleted", request.isCompleted());
>         assertFalse("isFailed", request.isFailed());
>@@ -220,10 +212,10 @@
> 	// ------------------------------------------------------------------------
> 
> 	public void testToString() {
>-        String expected1 = "[TmfCoalescedDataRequest(0,TmfEvent,10,100,200)]";
>-        String expected2 = "[TmfCoalescedDataRequest(1,TmfEvent,20,100,200)]";
>-        String expected3 = "[TmfCoalescedDataRequest(2,TmfEvent,20,200,200)]";
>-        String expected4 = "[TmfCoalescedDataRequest(3,TmfEvent,20,200,300)]";
>+        String expected1 = "[TmfCoalescedDataRequest(0,TmfEvent,10,100)]";
>+        String expected2 = "[TmfCoalescedDataRequest(1,TmfEvent,20,100)]";
>+        String expected3 = "[TmfCoalescedDataRequest(2,TmfEvent,20,200)]";
>+        String expected4 = "[TmfCoalescedDataRequest(3,TmfEvent,20,200)]";
> 
>         assertEquals("toString", expected1, fRequest1.toString());
>         assertEquals("toString", expected2, fRequest2.toString());
>@@ -240,60 +232,10 @@
> 		TmfDataRequest<TmfEvent> request1 = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 10, 100, 200);
> 		TmfDataRequest<TmfEvent> request2 = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 11, 100, 200);
> 		TmfDataRequest<TmfEvent> request3 = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 10, 101, 200);
>-		TmfDataRequest<TmfEvent> request4 = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 10, 100, 201);
> 
>         assertTrue ("isCompatible", coalescedRequest.isCompatible(request1));
>         assertFalse("isCompatible", coalescedRequest.isCompatible(request2));
>         assertFalse("isCompatible", coalescedRequest.isCompatible(request3));
>-        assertFalse("isCompatible", coalescedRequest.isCompatible(request4));
>-	}
>-
>-	// ------------------------------------------------------------------------
>-	// setData/getData
>-	// ------------------------------------------------------------------------
>-
>-	public void testSetData() {
>-
>-		TmfCoalescedDataRequest<TmfEvent> coalescedRequest = new TmfCoalescedDataRequest<TmfEvent>(TmfEvent.class, 10, 100, 200);
>-		TmfDataRequest<TmfEvent> request1 = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 10, 100, 200);
>-		TmfDataRequest<TmfEvent> request2 = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 10, 100, 200);
>-		coalescedRequest.addRequest(request1);
>-		coalescedRequest.addRequest(request2);
>-
>-		// Initialize the data
>-		int nbEvents = 10;
>-		TmfEvent[] events = new TmfEvent[nbEvents];
>-		for (int i = 0; i < nbEvents; i++) {
>-			events[i] = new TmfEvent(new TmfTimestamp(i), new TmfEventSource(),
>-					new TmfEventType(), new TmfEventReference());
>-		}
>-
>-		coalescedRequest.setData(events);
>-		coalescedRequest.handleData();
>-
>-		// Validate the coalescing request
>-		assertEquals("setData", nbEvents, coalescedRequest.getNbRead());
>-		TmfEvent[] eventsRead1 = coalescedRequest.getData();
>-		assertEquals("getData", nbEvents, eventsRead1.length);
>-		for (int i = 0; i < nbEvents; i++) {
>-			assertEquals("getData", i, eventsRead1[i].getTimestamp().getValue());
>-		}
>-
>-		// Validate the first coalesced request
>-		assertEquals("setData", nbEvents, request1.getNbRead());
>-		TmfEvent[] eventsRead2 = request1.getData();
>-		assertEquals("getData", nbEvents, eventsRead2.length);
>-		for (int i = 0; i < nbEvents; i++) {
>-			assertEquals("getData", i, eventsRead2[i].getTimestamp().getValue());
>-		}
>-
>-		// Validate the second coalesced request
>-		assertEquals("setData", nbEvents, request2.getNbRead());
>-		TmfEvent[] eventsRead3 = request2.getData();
>-		assertEquals("getData", nbEvents, eventsRead3.length);
>-		for (int i = 0; i < nbEvents; i++) {
>-			assertEquals("getData", i, eventsRead3[i].getTimestamp().getValue());
>-		}
> 	}
> 
> 	// ------------------------------------------------------------------------
>Index: src/org/eclipse/linuxtools/tmf/tests/request/TmfCoalescedEventRequestTest.java
>===================================================================
>--- src/org/eclipse/linuxtools/tmf/tests/request/TmfCoalescedEventRequestTest.java	(revision 25481)
>+++ src/org/eclipse/linuxtools/tmf/tests/request/TmfCoalescedEventRequestTest.java	(working copy)
>@@ -25,15 +25,10 @@
> import org.eclipse.linuxtools.tmf.component.ITmfDataProvider;
> import org.eclipse.linuxtools.tmf.component.TmfProviderManager;
> import org.eclipse.linuxtools.tmf.event.TmfEvent;
>-import org.eclipse.linuxtools.tmf.event.TmfEventReference;
>-import org.eclipse.linuxtools.tmf.event.TmfEventSource;
>-import org.eclipse.linuxtools.tmf.event.TmfEventType;
> import org.eclipse.linuxtools.tmf.event.TmfTimeRange;
> import org.eclipse.linuxtools.tmf.event.TmfTimestamp;
> import org.eclipse.linuxtools.tmf.request.TmfCoalescedDataRequest;
> import org.eclipse.linuxtools.tmf.request.TmfCoalescedEventRequest;
>-import org.eclipse.linuxtools.tmf.request.TmfDataRequest;
>-import org.eclipse.linuxtools.tmf.request.TmfDataRequestStub;
> import org.eclipse.linuxtools.tmf.request.TmfEventRequest;
> import org.eclipse.linuxtools.tmf.request.TmfEventRequestStub;
> import org.eclipse.linuxtools.tmf.signal.TmfSignal;
>@@ -133,7 +128,6 @@
> 
>         assertEquals("getRange", range1, request.getRange());
>         assertEquals("getNbRequestedEvents", TmfEventRequest.ALL_DATA, request.getNbRequested());
>-        assertEquals("getBlockize", TmfEventRequest.DEFAULT_BLOCK_SIZE, request.getBlockize());
> 
>         assertFalse("isCompleted", request.isCompleted());
>         assertFalse("isFailed", request.isFailed());
>@@ -150,7 +144,6 @@
> 
>         assertEquals("getRange", range1, request.getRange());
>         assertEquals("getNbRequestedEvents", TmfEventRequest.ALL_DATA, request.getNbRequested());
>-        assertEquals("getBlockize", TmfEventRequest.DEFAULT_BLOCK_SIZE, request.getBlockize());
> 
>         assertFalse("isCompleted", request.isCompleted());
>         assertFalse("isFailed", request.isFailed());
>@@ -167,7 +160,6 @@
> 
>         assertEquals("getRange", range1, request.getRange());
>         assertEquals("getNbRequestedEvents", 100, request.getNbRequested());
>-        assertEquals("getBlockize", TmfEventRequest.DEFAULT_BLOCK_SIZE, request.getBlockize());
> 
>         assertFalse("isCompleted", request.isCompleted());
>         assertFalse("isFailed", request.isFailed());
>@@ -184,7 +176,6 @@
> 
>         assertEquals("getRange", range1, request.getRange());
>         assertEquals("getNbRequestedEvents", 100, request.getNbRequested());
>-        assertEquals("getBlockize", 200, request.getBlockize());
> 
>         assertFalse("isCompleted", request.isCompleted());
>         assertFalse("isFailed", request.isFailed());
>@@ -228,11 +219,11 @@
> 
> 	public void testEqualsSuper() throws Exception {
> 		TmfCoalescedDataRequest<TmfEvent> dataRequest1 = new TmfCoalescedDataRequest<TmfEvent>(
>-			fRequest1.getDataType(), fRequest1.getIndex(), fRequest1.getNbRequested(), fRequest1.getBlockize());
>+				fRequest1.getDataType(), fRequest1.getIndex(), fRequest1.getNbRequested());
> 		TmfCoalescedDataRequest<TmfEvent> dataRequest2 = new TmfCoalescedDataRequest<TmfEvent>(
>-			fRequest1.getDataType(), fRequest1.getIndex(), fRequest1.getNbRequested(), fRequest1.getBlockize());
>+				fRequest1.getDataType(), fRequest1.getIndex(), fRequest1.getNbRequested());
> 		TmfCoalescedDataRequest<TmfEvent> dataRequest3 = new TmfCoalescedDataRequest<TmfEvent>(
>-			fRequest3.getDataType(), fRequest3.getIndex(), fRequest3.getNbRequested(), fRequest3.getBlockize());
>+				fRequest3.getDataType(), fRequest3.getIndex(), fRequest3.getNbRequested());
> 
> 		assertTrue("equals", fRequest1.equals(dataRequest2));
>         assertTrue("equals", fRequest2.equals(dataRequest1));
>@@ -255,10 +246,10 @@
> 	// ------------------------------------------------------------------------
> 
> 	public void testToString() {
>-        String expected1 = "[TmfCoalescedEventRequest(0,TmfEvent," + range1 + ",100,200)]";
>-        String expected2 = "[TmfCoalescedEventRequest(1,TmfEvent," + range2 + ",100,200)]";
>-        String expected3 = "[TmfCoalescedEventRequest(2,TmfEvent," + range2 + ",200,200)]";
>-        String expected4 = "[TmfCoalescedEventRequest(3,TmfEvent," + range2 + ",200,300)]";
>+        String expected1 = "[TmfCoalescedEventRequest(0,TmfEvent," + range1 + ",100)]";
>+        String expected2 = "[TmfCoalescedEventRequest(1,TmfEvent," + range2 + ",100)]";
>+        String expected3 = "[TmfCoalescedEventRequest(2,TmfEvent," + range2 + ",200)]";
>+        String expected4 = "[TmfCoalescedEventRequest(3,TmfEvent," + range2 + ",200)]";
> 
>         assertEquals("toString", expected1, fRequest1.toString());
>         assertEquals("toString", expected2, fRequest2.toString());
>@@ -275,62 +266,10 @@
> 		TmfEventRequest<TmfEvent> request1 = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, range1, 100, 200);
> 		TmfEventRequest<TmfEvent> request2 = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, range2, 100, 200);
> 		TmfEventRequest<TmfEvent> request3 = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, range1, 101, 200);
>-		TmfEventRequest<TmfEvent> request4 = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, range1, 100, 201);
>-		TmfDataRequest<TmfEvent>  request5 = new TmfDataRequestStub<TmfEvent> (TmfEvent.class,     10, 100, 201);
> 
>         assertTrue ("isCompatible", coalescedRequest.isCompatible(request1));
>         assertTrue ("isCompatible", coalescedRequest.isCompatible(request2));
>         assertFalse("isCompatible", coalescedRequest.isCompatible(request3));
>-        assertFalse("isCompatible", coalescedRequest.isCompatible(request4));
>-        assertFalse("isCompatible", coalescedRequest.isCompatible(request5));
>-	}
>-
>-	// ------------------------------------------------------------------------
>-	// setData/getData
>-	// ------------------------------------------------------------------------
>-
>-	public void testSetData() {
>-
>-		TmfCoalescedEventRequest<TmfEvent> coalescedRequest = new TmfCoalescedEventRequest<TmfEvent>(TmfEvent.class, range1, 100, 200);
>-		TmfEventRequest<TmfEvent> request1 = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, range1, 100, 200);
>-		TmfEventRequest<TmfEvent> request2 = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, range1, 100, 200);
>-		coalescedRequest.addRequest(request1);
>-		coalescedRequest.addRequest(request2);
>-
>-		// Initialize the data
>-		int nbEvents = 10;
>-		TmfEvent[] events = new TmfEvent[nbEvents];
>-		for (int i = 0; i < nbEvents; i++) {
>-			events[i] = new TmfEvent(new TmfTimestamp(i), new TmfEventSource(),
>-					new TmfEventType(), new TmfEventReference());
>-		}
>-
>-		coalescedRequest.setData(events);
>-		coalescedRequest.handleData();
>-
>-		// Validate the coalescing request
>-		assertEquals("setData", nbEvents, coalescedRequest.getNbRead());
>-		TmfEvent[] eventsRead1 = coalescedRequest.getData();
>-		assertEquals("getData", nbEvents, eventsRead1.length);
>-		for (int i = 0; i < nbEvents; i++) {
>-			assertEquals("getData", i, eventsRead1[i].getTimestamp().getValue());
>-		}
>-
>-		// Validate the first coalesced request
>-		assertEquals("setData", nbEvents, request1.getNbRead());
>-		TmfEvent[] eventsRead2 = request1.getData();
>-		assertEquals("getData", nbEvents, eventsRead2.length);
>-		for (int i = 0; i < nbEvents; i++) {
>-			assertEquals("getData", i, eventsRead2[i].getTimestamp().getValue());
>-		}
>-
>-		// Validate the second coalesced request
>-		assertEquals("setData", nbEvents, request2.getNbRead());
>-		TmfEvent[] eventsRead3 = request2.getData();
>-		assertEquals("getData", nbEvents, eventsRead3.length);
>-		for (int i = 0; i < nbEvents; i++) {
>-			assertEquals("getData", i, eventsRead3[i].getTimestamp().getValue());
>-		}
> 	}
> 
> 	// ------------------------------------------------------------------------
>@@ -499,14 +438,13 @@
> 
>         requestedEvents1 = new Vector<TmfEvent>();
>         request1 = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, NB_EVENTS, BLOCK_SIZE) {
>+        	int nbRead = 0;
>             @Override
>-            public void handleData() {
>+            public void handleData(TmfEvent event) {
>+        		super.handleData(event);
>             	if (!isCompleted()) {
>-            		TmfEvent[] events = getData();
>-            		for (TmfEvent e : events) {
>-            			requestedEvents1.add(e);
>-            		}
>-            		if (signal.forceCancel)
>+          			requestedEvents1.add(event);
>+            		if (++nbRead >= BLOCK_SIZE && signal.forceCancel)
>             			cancel();
>             	}
>             }
>@@ -515,12 +453,10 @@
>         requestedEvents2 = new Vector<TmfEvent>();
>         request2 = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, NB_EVENTS, BLOCK_SIZE) {
>             @Override
>-            public void handleData() {
>+            public void handleData(TmfEvent event) {
>+        		super.handleData(event);
>             	if (!isCompleted()) {
>-            		TmfEvent[] events = getData();
>-            		for (TmfEvent e : events) {
>-            			requestedEvents2.add(e);
>-            		}
>+            		requestedEvents2.add(event);
>             	}
>             }
>         };
>@@ -528,12 +464,10 @@
>         requestedEvents3 = new Vector<TmfEvent>();
>         request3 = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, NB_EVENTS, BLOCK_SIZE) {
>             @Override
>-            public void handleData() {
>+            public void handleData(TmfEvent event) {
>+        		super.handleData(event);
>             	if (!isCompleted()) {
>-            		TmfEvent[] events = getData();
>-            		for (TmfEvent e : events) {
>-            			requestedEvents3.add(e);
>-            		}
>+            		requestedEvents3.add(event);
>             	}
>             }
>         };
>Index: src/org/eclipse/linuxtools/tmf/tests/trace/TmfTraceTest.java
>===================================================================
>--- src/org/eclipse/linuxtools/tmf/tests/trace/TmfTraceTest.java	(revision 25481)
>+++ src/org/eclipse/linuxtools/tmf/tests/trace/TmfTraceTest.java	(working copy)
>@@ -69,7 +69,8 @@
> 		// Dummy request to force the trace indexing
>     	TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class) {
> 			@Override
>-			public void handleData() {
>+			public void handleData(TmfEvent event) {
>+        		super.handleData(event);
> 			}
>     	};
>     	fTrace.sendRequest(request);
>@@ -705,13 +706,11 @@
> 
>         TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);
>         final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, NB_EVENTS, BLOCK_SIZE) {
>-            @Override
>-            public void handleData() {
>-            	TmfEvent[] events = getData();
>-                for (TmfEvent e : events) {
>-                    requestedEvents.add(e);
>-                }
>-            }
>+        	@Override
>+        	public void handleData(TmfEvent event) {
>+        		super.handleData(event);
>+        		requestedEvents.add(event);
>+        	}
>         };
>         ITmfDataProvider<TmfEvent>[] providers = (ITmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfEvent.class, TmfTraceStub.class);
>         providers[0].sendRequest(request);
>@@ -735,13 +734,11 @@
> 
>         TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);
>         final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, NB_EVENTS, BLOCK_SIZE) {
>-            @Override
>-            public void handleData() {
>-            	TmfEvent[] events = getData();
>-                for (TmfEvent e : events) {
>-                    requestedEvents.add(e);
>-                }
>-            }
>+        	@Override
>+        	public void handleData(TmfEvent event) {
>+        		super.handleData(event);
>+        		requestedEvents.add(event);
>+        	}
>         };
>         ITmfDataProvider<TmfEvent>[] providers = (ITmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfEvent.class, TmfTraceStub.class);
>         providers[0].sendRequest(request);
>@@ -768,15 +765,14 @@
> 
>         TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);
>         final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, NB_EVENTS, BLOCK_SIZE) {
>-            @Override
>-            public void handleData() {
>-            	TmfEvent[] events = getData();
>-                for (TmfEvent e : events) {
>-                    requestedEvents.add(e);
>-                }
>-                // Cancel request after the first chunk is received
>-                cancel();
>-            }
>+        	int nbRead = 0;
>+        	@Override
>+        	public void handleData(TmfEvent event) {
>+        		super.handleData(event);
>+        		requestedEvents.add(event);
>+        		if (++nbRead == BLOCK_SIZE)
>+        			cancel();
>+        	}
>         };
>         ITmfDataProvider<TmfEvent>[] providers = (ITmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfEvent.class, TmfTraceStub.class);
>         providers[0].sendRequest(request);
>Index: src/org/eclipse/linuxtools/tmf/tests/trace/TmfExperimentTest.java
>===================================================================
>--- src/org/eclipse/linuxtools/tmf/tests/trace/TmfExperimentTest.java	(revision 25481)
>+++ src/org/eclipse/linuxtools/tmf/tests/trace/TmfExperimentTest.java	(working copy)
>@@ -517,13 +517,11 @@
> 
>         TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);
>         final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, nbEvents, blockSize) {
>-            @Override
>-            public void handleData() {
>-            	TmfEvent[] events = getData();
>-                for (TmfEvent e : events) {
>-                    requestedEvents.add(e);
>-                }
>-            }
>+        	@Override
>+        	public void handleData(TmfEvent event) {
>+        		super.handleData(event);
>+        		requestedEvents.add(event);
>+        	}
>         };
>         fExperiment.sendRequest(request);
>         request.waitForCompletion();
>@@ -546,13 +544,11 @@
> 
>         TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);
>         final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, nbEvents, blockSize) {
>-            @Override
>-            public void handleData() {
>-            	TmfEvent[] events = getData();
>-                for (TmfEvent e : events) {
>-                    requestedEvents.add(e);
>-                }
>-            }
>+        	@Override
>+        	public void handleData(TmfEvent event) {
>+        		super.handleData(event);
>+        		requestedEvents.add(event);
>+        	}
>         };
>         fExperiment.sendRequest(request);
>         request.waitForCompletion();
>@@ -576,13 +572,11 @@
> 
>         TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);
>         final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, nbEvents, blockSize) {
>-            @Override
>-            public void handleData() {
>-            	TmfEvent[] events = getData();
>-                for (TmfEvent e : events) {
>-                    requestedEvents.add(e);
>-                }
>-            }
>+        	@Override
>+        	public void handleData(TmfEvent event) {
>+        		super.handleData(event);
>+        		requestedEvents.add(event);
>+        	}
>         };
>         fExperiment.sendRequest(request);
>         request.waitForCompletion();
>@@ -609,15 +603,14 @@
> 
>         TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);
>         final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, nbEvents, blockSize) {
>-            @Override
>-            public void handleData() {
>-            	TmfEvent[] events = getData();
>-                for (TmfEvent e : events) {
>-                    requestedEvents.add(e);
>-                }
>-                // Cancel request after the first chunk is received
>-                cancel();
>-            }
>+      	int nbRead = 0;
>+      	@Override
>+      	public void handleData(TmfEvent event) {
>+    		super.handleData(event);
>+      		requestedEvents.add(event);
>+      		if (++nbRead == blockSize)
>+      			cancel();
>+      	}
>         };
>         fExperiment.sendRequest(request);
>         request.waitForCompletion();
>Index: src/org/eclipse/linuxtools/tmf/tests/component/TmfEventProviderTest.java
>===================================================================
>--- src/org/eclipse/linuxtools/tmf/tests/component/TmfEventProviderTest.java	(revision 25481)
>+++ src/org/eclipse/linuxtools/tmf/tests/component/TmfEventProviderTest.java	(working copy)
>@@ -96,14 +96,12 @@
>         TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);
>         final TmfEventRequest<TmfEvent> request =
>         	new TmfEventRequest<TmfEvent>(TmfEvent.class, range, NB_EVENTS, BLOCK_SIZE) {
>-            	@Override
>-            	public void handleData() {
>-            		TmfEvent[] events = getData();
>-            		for (TmfEvent e : events) {
>-            			requestedEvents.add(e);
>-            		}
>-            	}
>-        	};
>+        	@Override
>+        	public void handleData(TmfEvent event) {
>+        	super.handleData(event);
>+        		requestedEvents.add(event);
>+        	}
>+        };
>         provider.sendRequest(request);
>         try {
> 			request.waitForCompletion();
>@@ -132,13 +130,11 @@
> 
>         final TmfEventRequest<TmfSyntheticEventStub> request =
>         	new TmfEventRequest<TmfSyntheticEventStub>(TmfSyntheticEventStub.class, range, nbEvents, blockSize) {
>-            	@Override
>-            	public void handleData() {
>-            		TmfSyntheticEventStub[] events = getData();
>-            		for (TmfSyntheticEventStub e : events) {
>-            			requestedEvents.add(e);
>-            		}
>-            	}
>+        		@Override
>+        		public void handleData(TmfSyntheticEventStub event) {
>+            		super.handleData(event);
>+        			requestedEvents.add(event);
>+        		}
>         	};
>         provider.sendRequest(request);
> 
>@@ -203,7 +199,6 @@
>         TmfTimeRange range = new TmfTimeRange(start, end);
> 		try {
> 			getSyntheticData(range, -1, TmfSyntheticEventProviderStub.BLOCK_SIZE);
>-//			System.out.println("aie");
> 		} catch (InterruptedException e) {
> 			fail();
> 		}
>Index: ChangeLog
>===================================================================
>--- ChangeLog	(revision 25481)
>+++ ChangeLog	(working copy)
>@@ -1,3 +1,18 @@
>+2010-09-17  Francois Chouinard  <fchouinard@gmail.com>
>+
>+	* src/org/eclipse/linuxtools/tmf/tests/component/TmfEventProviderTest.java: Adjusted unit test 
>+	* src/org/eclipse/linuxtools/tmf/tests/experiment/TmfExperimentTest.java: Adjusted to new handleData() API  
>+	* src/org/eclipse/linuxtools/tmf/tests/experiment/TmfMultiTraceExperimentTest.java:Adjusted to new handleData() API  
>+	* src/org/eclipse/linuxtools/tmf/tests/request/TmfCoalescedDataRequestTest.java: Adjusted to new handleData() API 
>+	* src/org/eclipse/linuxtools/tmf/tests/request/TmfCoalescedEventRequestTest.java: Adjusted to new handleData() API 
>+	* src/org/eclipse/linuxtools/tmf/tests/request/TmfDataRequestTest.java: Adjusted to new handleData() API 
>+	* src/org/eclipse/linuxtools/tmf/tests/request/TmfEventRequestTest.java: Adjusted to new handleData() API 
>+	* src/org/eclipse/linuxtools/tmf/tests/trace/TmfExperimentTest.java: Adjusted to new handleData() API 
>+	* src/org/eclipse/linuxtools/tmf/tests/trace/TmfTraceTest.java: Adjusted to new handleData() API 
>+	* stubs/org/eclipse/linuxtools/tmf/component/TmfSyntheticEventProviderStub.java: Adjusted to new handleData() API 
>+	* stubs/org/eclipse/linuxtools/tmf/request/TmfDataRequestStub.java: Adjusted to new handleData() API 
>+	* stubs/org/eclipse/linuxtools/tmf/request/TmfEventRequestStub.java: Adjusted to new handleData() API 
>+
> 2010-09-09  Francois Chouinard  <fchouinard@gmail.com>
> 
>     * src/org/eclipse/linuxtools/tmf/tests/experiment/TmfExperimentTest.java: Added a few checks
>#P org.eclipse.linuxtools.tmf
>Index: src/org/eclipse/linuxtools/tmf/event/TmfEvent.java
>===================================================================
>--- src/org/eclipse/linuxtools/tmf/event/TmfEvent.java	(revision 25481)
>+++ src/org/eclipse/linuxtools/tmf/event/TmfEvent.java	(working copy)
>@@ -29,7 +29,7 @@
>  * Notice that for performance reasons TmfEvent is NOT immutable. If a copy
>  * of the event is needed, use the copy constructor.
>  */
>-public class TmfEvent extends TmfData {
>+public class TmfEvent extends TmfData implements Cloneable {
> 
>     // ------------------------------------------------------------------------
>     // Constants
>@@ -190,4 +190,9 @@
> 		return "[TmfEvent(" + fEffectiveTimestamp + "," + fSource + "," + fType + "," + fContent + ")]";
> 	}
> 
>+	@Override
>+	public TmfEvent clone() {
>+		return new TmfEvent(this);
>+	}
>+
> }
>Index: src/org/eclipse/linuxtools/tmf/request/TmfCoalescedEventRequest.java
>===================================================================
>--- src/org/eclipse/linuxtools/tmf/request/TmfCoalescedEventRequest.java	(revision 25481)
>+++ src/org/eclipse/linuxtools/tmf/request/TmfCoalescedEventRequest.java	(working copy)
>@@ -90,7 +90,6 @@
> 	public boolean isCompatible(ITmfDataRequest<T> request) {
> 		if (request instanceof ITmfEventRequest<?>) {
> 			boolean ok = getNbRequested() == request.getNbRequested();
>-			ok &= getBlockize() == request.getBlockize();
> 			ok &= getExecType() == request.getExecType();
> 			if (ok) {
> 				TmfTimestamp startTime = ((ITmfEventRequest<T>) request).getRange().getStartTime();
>@@ -110,22 +109,23 @@
>     // ------------------------------------------------------------------------
> 
>     @Override
>-	public void handleData() {
>+	public void handleData(T data) {
>+    	super.handleData(data);
>     	for (ITmfDataRequest<T> request : fRequests) {
>-			if (request instanceof TmfEventRequest<?>) {
>-    			TmfEventRequest<T> req = (TmfEventRequest<T>) request;
>-    			T[] data = getData();
>-    			TmfTimestamp ts = data[0].getTimestamp();
>-        		if (data.length > 0 && req.getRange().contains(ts)) {
>-            		req.setData(data);
>-            		req.handleData();
>-        		}
>-    		}
>-    		else {
>-    			TmfDataRequest<T> req = (TmfDataRequest<T>) request;
>-    			T[] data = getData();
>-        		req.setData(data);
>-        		req.handleData();
>+    		if (data == null) {
>+    			request.handleData(null);
>+    		} else {
>+    			if (request instanceof TmfEventRequest<?>) {
>+    				TmfEventRequest<T> req = (TmfEventRequest<T>) request;
>+    				TmfTimestamp ts = data.getTimestamp();
>+    				if (req.getRange().contains(ts)) {
>+    					req.handleData(data);
>+    				}
>+    			}
>+    			else {
>+    				TmfDataRequest<T> req = (TmfDataRequest<T>) request;
>+    				req.handleData(data);
>+    			}
>     		}
>     	}
>     }
>@@ -166,7 +166,7 @@
>     @Override
>     public String toString() {
> 		return "[TmfCoalescedEventRequest(" + getRequestId() + "," + getDataType().getSimpleName() 
>-			+ "," + getRange() + "," + getNbRequested() + "," + getBlockize() + ")]";
>+			+ "," + getRange() + "," + getNbRequested() + ")]";
>     }
> 
> }
>Index: src/org/eclipse/linuxtools/tmf/request/ITmfDataRequest.java
>===================================================================
>--- src/org/eclipse/linuxtools/tmf/request/ITmfDataRequest.java	(revision 25481)
>+++ src/org/eclipse/linuxtools/tmf/request/ITmfDataRequest.java	(working copy)
>@@ -57,11 +57,6 @@
>     public int getNbRequested();
> 
>     /**
>-     * @return the block size
>-     */
>-    public int getBlockize();
>-
>-    /**
>      * @return the number of events read so far
>      */
>     public int getNbRead();
>@@ -79,9 +74,7 @@
> 	// Data handling
> 	// ------------------------------------------------------------------------
> 
>-    public void setData(T[] data);
>-    public T[] getData();
>-    public void handleData();
>+    public void handleData(T data);
> 
> 	// ------------------------------------------------------------------------
> 	// Request handling
>Index: src/org/eclipse/linuxtools/tmf/request/TmfDataRequest.java
>===================================================================
>--- src/org/eclipse/linuxtools/tmf/request/TmfDataRequest.java	(revision 25481)
>+++ src/org/eclipse/linuxtools/tmf/request/TmfDataRequest.java	(working copy)
>@@ -90,8 +90,7 @@
>     private final int      		fRequestId;  	// A unique request ID
>     private final int      		fIndex;      	// The index (rank) of the requested event
>     private final int      		fNbRequested;	// The number of requested events (ALL_DATA for all)
>-    private final int      		fBlockSize;     // The maximum number of events per chunk
>-    protected     int      		fNbRead;        // The number of reads so far
>+    private       int      		fNbRead;        // The number of reads so far
> 
>     private final   Object lock;
>     private boolean fRequestRunning   = false;
>@@ -99,8 +98,6 @@
>     private boolean fRequestFailed    = false;
>     private boolean fRequestCanceled  = false;
> 
>-    private T[] fData;	// Data object
>-    
>     // ------------------------------------------------------------------------
>     // Constructors
>     // ------------------------------------------------------------------------
>@@ -165,7 +162,6 @@
>     	fDataType    = dataType;
>     	fIndex       = index;
>     	fNbRequested = nbRequested;
>-    	fBlockSize   = blockSize;
>     	fExecType    = execType;
>     	fNbRead      = 0;
>         lock         = new Object();
>@@ -213,13 +209,6 @@
>     }
> 
>     /**
>-     * @return the block size
>-     */
>-    public int getBlockize() {
>-        return fBlockSize;
>-    }
>-
>-    /**
>      * @return the number of events read so far
>      */
>     public synchronized int getNbRead() {
>@@ -268,20 +257,9 @@
>     /** 
>      * Sets the data object to specified value. To be called by the 
>      * asynchronous method implementor.
>+     * 
>      * @param data Data value to set.
>      */
>-    public synchronized void setData(T[] data) {
>-    	fNbRead += data.length;
>-    	fData = data;
>-    }
>-    
>-    /**
>-     * Returns the data value, null if not set.
>-     */
>-    public synchronized T[] getData() {
>-    	return fData;
>-    }
>-    
>     /**
>      * Handle a block of incoming data. This method is called every time
>      * a block of data becomes available.
>@@ -295,9 +273,13 @@
>      *   (or a copy) if some persistence is needed between invocations.
>      * - When there is no more data, done() is called. 
>      *
>-     * @param events - an array of events
>+     * @param events - an events
>      */
>-    public abstract void handleData();
>+    public void handleData(T data) {
>+        if (data != null) {
>+        	fNbRead++;
>+        }
>+    }
> 
>     public void handleStarted() {
>     }
>@@ -356,7 +338,7 @@
>         if (Tracer.isRequestTraced()) Tracer.traceRequest(this, "starting");
>         synchronized(lock) {
>             fRequestRunning = true;
>-            lock.notify();
>+            lock.notifyAll();
>         }
>         handleStarted();
>         if (Tracer.isRequestTraced()) Tracer.traceRequest(this, "started");
>@@ -373,7 +355,7 @@
>                 fRequestCompleted = true;
>             }
>             handleCompleted();
>-            lock.notify();
>+            lock.notifyAll();
>         }
>     }
> 
>@@ -421,7 +403,6 @@
>     @Override
>     public String toString() {
> 		return "[TmfDataRequest(" + fRequestId + "," + fDataType.getSimpleName() 
>-			+ "," + fIndex + "," + fNbRequested + "," + fBlockSize + ")]";
>+			+ "," + fIndex + "," + fNbRequested + ")]";
>     }
>-
> }
>Index: src/org/eclipse/linuxtools/tmf/request/TmfEventRequest.java
>===================================================================
>--- src/org/eclipse/linuxtools/tmf/request/TmfEventRequest.java	(revision 25481)
>+++ src/org/eclipse/linuxtools/tmf/request/TmfEventRequest.java	(working copy)
>@@ -114,7 +114,7 @@
>     @Override
>     public String toString() {
> 		return "[TmfEventRequest(" + getRequestId() + "," + getDataType().getSimpleName() 
>-			+ "," + getRange() + "," + getNbRequested() + "," + getBlockize() + ")]";
>+			+ "," + getRange() + "," + getNbRequested() + ")]";
>     }
> 
> }
>Index: src/org/eclipse/linuxtools/tmf/request/TmfCoalescedDataRequest.java
>===================================================================
>--- src/org/eclipse/linuxtools/tmf/request/TmfCoalescedDataRequest.java	(revision 25481)
>+++ src/org/eclipse/linuxtools/tmf/request/TmfCoalescedDataRequest.java	(working copy)
>@@ -92,7 +92,6 @@
> 
> 		boolean ok = request.getIndex() == getIndex();
> 		ok &= request.getNbRequested()  == getNbRequested();
>-		ok &= request.getBlockize()     == getBlockize();
> 		ok &= request.getExecType()     == getExecType();
> 		
> 		return ok;
>@@ -103,14 +102,19 @@
>     // ------------------------------------------------------------------------
> 
>     @Override
>-	public void handleData() {
>-    	for (ITmfDataRequest<T> request : fRequests) {
>-    		request.setData(getData());
>-    		request.handleData();
>-    	}
>+	public void handleData(T data) {
>+		super.handleData(data);
>+    	// Don't call sub-requests handleData() unless this is a
>+		// TmfCoalescedDataRequest; extended classes should call
>+		// the sub-requests handleData().
>+		if (getClass() == TmfCoalescedDataRequest.class) {
>+	    	for (ITmfDataRequest<T> request : fRequests) {
>+	    		request.handleData(data);
>+	    	}
>+		}
>     }
> 
>-    @Override
>+	@Override
>     public void done() {
>     	for (ITmfDataRequest<T> request : fRequests) {
>     		request.done();
>@@ -159,7 +163,7 @@
>     @Override
>     public String toString() {
> 		return "[TmfCoalescedDataRequest(" + getRequestId() + "," + getDataType().getSimpleName() 
>-			+ "," + getIndex() + "," + getNbRequested() + "," + getBlockize() + ")]";
>+			+ "," + getIndex() + "," + getNbRequested() + ")]";
>     }
> 
> }
>Index: src/org/eclipse/linuxtools/tmf/component/TmfEventProvider.java
>===================================================================
>--- src/org/eclipse/linuxtools/tmf/component/TmfEventProvider.java	(revision 25481)
>+++ src/org/eclipse/linuxtools/tmf/component/TmfEventProvider.java	(working copy)
>@@ -40,12 +40,12 @@
> 	
> 	@Override
> 	public boolean isCompleted(ITmfDataRequest<T> request, T data, int nbRead) {
>-		boolean dataRequestCompleted = super.isCompleted(request, data, nbRead);
>-		if (!dataRequestCompleted && request instanceof ITmfEventRequest<?> && !data.isNullRef()) {
>+		boolean requestCompleted = super.isCompleted(request, data, nbRead);
>+		if (!requestCompleted && request instanceof ITmfEventRequest<?> && !data.isNullRef()) {
> 			TmfTimestamp endTime = ((ITmfEventRequest<?>) request).getRange().getEndTime();
> 			return data.getTimestamp().compareTo(endTime, false) > 0;
> 		}
>-		return dataRequestCompleted;
>+		return requestCompleted;
> 	}
> 
> 	@Override
>@@ -53,7 +53,7 @@
> 		if (request instanceof ITmfEventRequest<?>) {
> 			ITmfEventRequest<T> eventRequest = (ITmfEventRequest<T>) request;
> 			TmfCoalescedEventRequest<T> coalescedRequest = 
>-				new TmfCoalescedEventRequest<T>(fType, eventRequest.getRange(), eventRequest.getNbRequested(), eventRequest.getBlockize(), eventRequest.getExecType());
>+				new TmfCoalescedEventRequest<T>(fType, eventRequest.getRange(), eventRequest.getNbRequested(), eventRequest.getExecType());
> 			coalescedRequest.addRequest(eventRequest);
> 	        if (Tracer.isRequestTraced()) {
> 		        Tracer.traceRequest(request, "coalesced with " + coalescedRequest.getRequestId());
>Index: src/org/eclipse/linuxtools/tmf/component/TmfDataProvider.java
>===================================================================
>--- src/org/eclipse/linuxtools/tmf/component/TmfDataProvider.java	(revision 25481)
>+++ src/org/eclipse/linuxtools/tmf/component/TmfDataProvider.java	(working copy)
>@@ -12,7 +12,6 @@
> 
> package org.eclipse.linuxtools.tmf.component;
> 
>-import java.lang.reflect.Array;
> import java.util.Vector;
> import java.util.concurrent.BlockingQueue;
> import java.util.concurrent.LinkedBlockingQueue;
>@@ -159,8 +158,8 @@
> 
> 	protected void newCoalescedDataRequest(ITmfDataRequest<T> request) {
> 		synchronized(fLock) {
>-			TmfCoalescedDataRequest<T> coalescedRequest =
>-				new TmfCoalescedDataRequest<T>(fType, request.getIndex(), request.getNbRequested(), request.getBlockize(), request.getExecType());
>+			TmfCoalescedDataRequest<T> coalescedRequest = new TmfCoalescedDataRequest<T>(
>+					fType, request.getIndex(), request.getNbRequested(),request.getExecType());
> 			coalescedRequest.addRequest(request);
> 	        if (Tracer.isRequestTraced()) {
> 	        	Tracer.traceRequest(request, "coalesced with " + coalescedRequest.getRequestId());
>@@ -216,11 +215,7 @@
> 
> 				// Extract the generic information
> 				request.start();
>-				int blockSize   = request.getBlockize();
> 				int nbRequested = request.getNbRequested();
>-			 
>-				// Create the result buffer
>-				Vector<T> result = new Vector<T>();
> 				int nbRead = 0;
> 
> 				// Initialize the execution
>@@ -238,21 +233,16 @@
> 					while (data != null && !isCompleted(request, data, nbRead))
> 					{
> 						if (fLogData) Tracer.traceEvent(provider, request, data);
>-						result.add(data);
>-						if (++nbRead % blockSize == 0) {
>-							pushData(request, result);
>-						}
>+						request.handleData(data);
>+
> 						// To avoid an unnecessary read passed the last data requested
>-						if (nbRead < nbRequested) {
>+						if (++nbRead < nbRequested) {
> 							data = getNext(context);
> 							if (Tracer.isRequestTraced() && (data == null || data.isNullRef())) {
> 								Tracer.trace("Request #" + request.getRequestId() + " end of data");
> 							}
> 						}
> 					}
>-					if (result.size() > 0) {
>-						pushData(request, result);
>-					}
> 					request.done();
> 
> 					if (Tracer.isRequestTraced()) Tracer.traceRequest(request, "completed");
>@@ -260,7 +250,6 @@
> 				catch (Exception e) {
> 			        if (Tracer.isRequestTraced()) Tracer.traceRequest(request, "exception (failed)");
> 					request.fail();
>-//					e.printStackTrace();
> 				}
> 			}
> 		};
>@@ -276,26 +265,6 @@
> 	}
> 
> 	/**
>-	 * Format the result data and forwards it to the requester.
>-	 * Note: after handling, the data is *removed*.
>-	 * 
>-	 * @param request
>-	 * @param data
>-	 */
>-	@SuppressWarnings("unchecked")
>-	protected void pushData(ITmfDataRequest<T> request, Vector<T> data) {
>-		synchronized(request) {
>-			if (!request.isCompleted()) {
>-				T[] result = (T[]) Array.newInstance(fType, data.size());
>-				data.toArray(result);
>-				request.setData(result);
>-				request.handleData();
>-				data.removeAllElements();
>-			}
>-		}
>-	}
>-
>-	/**
> 	 * Initialize the provider based on the request. The context is
> 	 * provider specific and will be updated by getNext().
> 	 * 
>@@ -305,50 +274,6 @@
> 	public abstract ITmfContext armRequest(ITmfDataRequest<T> request);
> 	public abstract T getNext(ITmfContext context);
> 
>-//	public abstract void queueResult(T data);
>-
>-	/**
>-	 * Return the next piece of data based on the context supplied. The context
>-	 * would typically be updated for the subsequent read.
>-	 * 
>-	 * @param context
>-	 * @return
>-	 */
>-//	private static final int TIMEOUT = 10000;
>-////	public abstract T getNext(ITmfContext context) throws InterruptedException;
>-////	private int getLevel = 0;
>-//	public T getNext(ITmfContext context) throws InterruptedException {
>-////		String name = Thread.currentThread().getName(); getLevel++;
>-////		System.out.println("[" + System.currentTimeMillis() + "] " + name + " " + (getLevel) + " getNext() - entering");
>-//		T data = fDataQueue.poll(TIMEOUT, TimeUnit.MILLISECONDS);
>-//		if (data == null) {
>-////			if (Tracer.isErrorTraced()) Tracer.traceError(getName() + ": Request timeout on read");
>-//			throw new InterruptedException();
>-//		}
>-////		System.out.println("[" + System.currentTimeMillis() + "] " + name + " " + (getLevel) + " getNext() - leaving");
>-////		getLevel--;
>-//		return data;
>-//	}
>-//
>-//	/**
>-//	 * Makes the generated result data available for getNext()
>-//	 * 
>-//	 * @param data
>-//	 */
>-////	public abstract void queueResult(T data) throws InterruptedException;
>-////	private int putLevel = 0;
>-//	public void queueResult(T data) throws InterruptedException {
>-////		String name = Thread.currentThread().getName(); putLevel++;
>-////		System.out.println("[" + System.currentTimeMillis() + "] " + name + " " + (putLevel) + " queueResult() - entering");
>-//		boolean ok = fDataQueue.offer(data, TIMEOUT, TimeUnit.MILLISECONDS);
>-//		if (!ok) {
>-////			if (Tracer.isErrorTraced()) Tracer.traceError(getName() + ": Request timeout on write");
>-//			throw new InterruptedException();
>-//		}
>-////		System.out.println("[" + System.currentTimeMillis() + "] " + name + " " + (putLevel) + " queueResult() - leaving");
>-////		putLevel--;
>-//	}
>-
> 	/**
> 	 * Checks if the data meets the request completion criteria.
> 	 * 
>Index: src/org/eclipse/linuxtools/tmf/experiment/TmfExperiment.java
>===================================================================
>--- src/org/eclipse/linuxtools/tmf/experiment/TmfExperiment.java	(revision 25481)
>+++ src/org/eclipse/linuxtools/tmf/experiment/TmfExperiment.java	(working copy)
>@@ -634,36 +634,26 @@
> 		fCheckpoints.clear();
> 		
> //		fEventLog = openLogFile("TraceEvent.log");
>-//		System.out.println(System.currentTimeMillis() + ": Experiment indexing started");
>+		System.out.println(System.currentTimeMillis() + ": Experiment indexing started");
> 
>-		ITmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, TmfTimeRange.Eternity, TmfDataRequest.ALL_DATA, 1, ITmfDataRequest.ExecutionType.BACKGROUND) {
>+		ITmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, TmfTimeRange.Eternity,
>+				TmfDataRequest.ALL_DATA, 1, ITmfDataRequest.ExecutionType.BACKGROUND) {
> 
>-//			long indexingStart = System.nanoTime();
>+			long indexingStart = System.nanoTime();
> 			
> 			TmfTimestamp startTime =  null;
> 			TmfTimestamp lastTime  =  null;
> 
> 			@Override
>-			public void handleData() {
>-				TmfEvent[] events = getData();
>-				if (events.length > 0) {
>-
>-//					try {
>-//						if (fEventLog != null) {
>-//							fEventLog.write(events[0].getTimestamp().toString());
>-//							fEventLog.newLine();
>-//							fEventLog.flush();
>-//						}
>-//					} catch (IOException e) {
>-//						e.printStackTrace();
>-//					}
>-					
>-					TmfTimestamp ts = events[0].getTimestamp();
>+			public void handleData(TmfEvent event) {
>+        		super.handleData(event);
>+				if (event != null) {
>+					TmfTimestamp ts = event.getTimestamp();
> 					if (startTime == null)
> 						startTime = new TmfTimestamp(ts);
> 					lastTime = new TmfTimestamp(ts);
> 
>-					if ((fNbRead % DEFAULT_INDEX_PAGE_SIZE) == 0) {
>+					if ((getNbRead() % DEFAULT_INDEX_PAGE_SIZE) == 0) {
> 						updateExperiment();
> 					}
> 				}
>@@ -671,33 +661,21 @@
> 
> 			@Override
> 			public void handleSuccess() {
>-
>-//				try {
>-//					fEventLog.close();
>-//					fEventLog = null;
>-//				} catch (IOException e) {
>-//					e.printStackTrace();
>-//				}
>-
>-//				long indexingEnd = System.nanoTime();
>+				long indexingEnd = System.nanoTime();
> 
> 				updateExperiment();
>-//				System.out.println(System.currentTimeMillis() + ": Experiment indexing completed");
>-//
>-//				long average = (indexingEnd - indexingStart) / fNbEvents;
>-//				System.out.println(getName() + ": start=" + startTime + ", end=" + lastTime + ", elapsed=" + (indexingEnd * 1.0 - indexingStart) / 1000000000);
>-//				System.out.println(getName() + ": nbEvents=" + fNbEvents + " (" + (average / 1000) + "." + (average % 1000) + " us/evt)");
>+				System.out.println(System.currentTimeMillis() + ": Experiment indexing completed");
> 
>-//				 for (int i = 0; i < fCheckpoints.size(); i++) {
>-//					 TmfCheckpoint checkpoint = fCheckpoints.get(i);
>-//					 System.out.println("fCheckpoints[" + i + "] " + checkpoint.getTimestamp() + ", " + checkpoint.getLocation().toString());
>-//				 }
>+				long average = (indexingEnd - indexingStart) / fNbEvents;
>+				System.out.println(getName() + ": start=" + startTime + ", end=" + lastTime + ", elapsed=" + (indexingEnd * 1.0 - indexingStart) / 1000000000);
>+				System.out.println(getName() + ": nbEvents=" + fNbEvents + " (" + (average / 1000) + "." + (average % 1000) + " us/evt)");
> 			}
> 
> 			private void updateExperiment() {
>-				if (fNbRead != 0) {
>+				int nbRead = getNbRead();
>+				if (nbRead != 0) {
> 					fTimeRange = new TmfTimeRange(startTime, new TmfTimestamp(lastTime));
>-					fNbEvents  = fNbRead;
>+					fNbEvents  = nbRead;
> 					notifyListeners();
> 				}
> 			}
>@@ -746,11 +724,6 @@
> 		broadcast(new TmfExperimentUpdatedSignal(this, this)); // , signal.getTrace()));
>     }
> 
>-//	@Override
>-//	public void queueResult(T data) {
>-////		super.queueResult(data);
>-//	}
>-
>     // ------------------------------------------------------------------------
>     // TmfDataProvider
>     // ------------------------------------------------------------------------
>@@ -787,35 +760,28 @@
> 				while (!isFinished[0]) {
> 
> //					TmfEventRequest<T> subRequest = new TmfEventRequest<T>(eventRequest.getDataType(), new TmfTimeRange(timestamp[0], endTS), CHUNK_SIZE[0], eventRequest.getBlockize(), ExecutionType.BACKGROUND)
>-					TmfDataRequest<T> subRequest = new TmfDataRequest<T>(eventRequest.getDataType(), nbRead[0], CHUNK_SIZE[0], eventRequest.getBlockize(), ExecutionType.BACKGROUND)
>+//					TmfDataRequest<T> subRequest = new TmfDataRequest<T>(eventRequest.getDataType(), nbRead[0], CHUNK_SIZE[0], eventRequest.getBlockize(), ExecutionType.BACKGROUND)
>+					TmfDataRequest<T> subRequest = new TmfDataRequest<T>(eventRequest.getDataType(), nbRead[0], CHUNK_SIZE[0], ExecutionType.BACKGROUND)
> 					{
>-//						int count = 0;
> 						@Override
>-						public void handleData() {
>-							T[] data = getData();
>-//							timestamp[0] = data[data.length-1].getTimestamp();
>-//							if (count == 0) {
>-//								System.out.println("First event of the block: " + data[0].getTimestamp());
>-//							}
>-//							count++;
>-//							Tracer.trace("Ndx: " + ((TmfEvent) data[0]).getTimestamp());
>-							eventRequest.setData(data);
>-							eventRequest.handleData();
>-							if (fNbRead == CHUNK_SIZE[0]) {
>-								nbRead[0] += fNbRead;
>-//								System.out.println("fNbRead=" + fNbRead + ", count=" + count +", total=" + nbRead[0] + ", TS=" + data[0].getTimestamp());
>+						public void handleData(T data) {
>+							super.handleData(data);
>+							eventRequest.handleData(data);
>+							if (getNbRead() == CHUNK_SIZE[0]) {
>+								nbRead[0] += getNbRead();
> 							}
>-							if (fNbRead > CHUNK_SIZE[0]) {
>+							if (getNbRead() > CHUNK_SIZE[0]) {
> 								System.out.println("ERROR - Read too many events");
> 							}
> 						}
>+
> 						@Override
> 						public void handleCompleted() {
> //							System.out.println("Request completed at: " + timestamp[0]);
>-							if (fNbRead < CHUNK_SIZE[0]) {
>+							if (getNbRead() < CHUNK_SIZE[0]) {
> 								eventRequest.done();
> 								isFinished[0] = Boolean.TRUE;
>-								nbRead[0] += fNbRead;
>+								nbRead[0] += getNbRead();
> //								System.out.println("fNbRead=" + fNbRead + ", count=" + count +", total=" + nbRead[0]);
> 							}
> 							super.handleCompleted();
>@@ -845,4 +811,5 @@
> 
> 		thread.start();
> 	}
>+
> }
>Index: ChangeLog
>===================================================================
>--- ChangeLog	(revision 25481)
>+++ ChangeLog	(working copy)
>@@ -1,3 +1,15 @@
>+2010-09-17  Francois Chouinard  <fchouinard@gmail.com>
>+
>+	* src/org/eclipse/linuxtools/tmf/component/TmfDataProvider.java: Adjusted to new handleData() API 
>+	* src/org/eclipse/linuxtools/tmf/component/TmfEventProvider.java: Adjusted to new handleData() API 
>+	* src/org/eclipse/linuxtools/tmf/event/TmfEvent.java: Support for single event 
>+	* src/org/eclipse/linuxtools/tmf/experiment/TmfExperiment.java: Adjusted to new handleData() API  
>+	* src/org/eclipse/linuxtools/tmf/request/ITmfDataRequest.java: Adjusted to new handleData() API  
>+	* src/org/eclipse/linuxtools/tmf/request/TmfCoalescedDataRequest.java: Adjusted to new handleData() API  
>+	* src/org/eclipse/linuxtools/tmf/request/TmfCoalescedEventRequest.java: Adjusted to new handleData() API  
>+	* src/org/eclipse/linuxtools/tmf/request/TmfDataRequest.java: Adjusted to new handleData() API 
>+	* src/org/eclipse/linuxtools/tmf/request/TmfEventRequest.java: Adjusted to new handleData() API 
>+
> 2010-09-15  Francois Chouinard  <fchouinard@gmail.com>
> 
>     * src/org/eclipse/linuxtools/tmf/experiment/TmfExperiment.java: Optimized TmfExperimentContext handling 
>#P org.eclipse.linuxtools.lttng.tests
>Index: src/org/eclipse/linuxtools/lttng/LttngTestPreparation.java
>===================================================================
>--- src/org/eclipse/linuxtools/lttng/LttngTestPreparation.java	(revision 25481)
>+++ src/org/eclipse/linuxtools/lttng/LttngTestPreparation.java	(working copy)
>@@ -211,14 +211,10 @@
> 	
> 		// request
> 		validSequence = true;
>-		TmfEventRequest<T> request = new TmfEventRequest<T>(k,
>-				trange, TmfDataRequest.ALL_DATA, DEFAULT_CHUNK) {
>+		TmfEventRequest<T> request = new TmfEventRequest<T>(k, trange, TmfDataRequest.ALL_DATA, DEFAULT_CHUNK) {
> 	
> 			@Override
>-			public void handleData() {
>-				T[] result = getData();
>-	
>-				T event = (result.length > 0) ? result[0] : null;
>+			public void handleData(T event) {
> 				if (event == null) {
> 					System.out
> 							.println("Syntheric Event Received is null, after event: "
>Index: src/org/eclipse/linuxtools/lttng/control/LTTngSyntheticEventProviderTest.java
>===================================================================
>--- src/org/eclipse/linuxtools/lttng/control/LTTngSyntheticEventProviderTest.java	(revision 25481)
>+++ src/org/eclipse/linuxtools/lttng/control/LTTngSyntheticEventProviderTest.java	(working copy)
>@@ -12,6 +12,11 @@
> package org.eclipse.linuxtools.lttng.control;
> 
> import org.eclipse.linuxtools.lttng.LttngTestPreparation;
>+import org.eclipse.linuxtools.lttng.event.LttngEvent;
>+import org.eclipse.linuxtools.lttng.event.LttngSyntheticEvent;
>+import org.eclipse.linuxtools.lttng.state.experiment.IStateExperimentManager;
>+import org.eclipse.linuxtools.tmf.experiment.TmfExperiment;
>+import org.eclipse.linuxtools.tmf.request.TmfEventRequest;
> 
> public class LTTngSyntheticEventProviderTest extends LttngTestPreparation {
> 	// ========================================================================
>@@ -19,83 +24,75 @@
> 	// ========================================================================
> 
> 	public void testPlainDataRequest() {
>-//		// prepare
>-//		init();
>-//		TmfExperiment<LttngEvent> experiment = prepareExperimentToTest();
>-//		TmfEventRequest<LttngEvent> request = prepareEventRequest(
>-//				LttngEvent.class, 0, 31);
>-//
>-//		// execute
>-//		experiment.sendRequest(request);
>-//		try {
>-//			request.waitForCompletion();
>-//		} catch (InterruptedException e) {
>-//			e.printStackTrace();
>-//		}
>-//
>-//		// finish
>-//		assertEquals("Unexpected eventCount", 15316, feventCount);
>-//		boolean expected = true;
>-//		assertEquals("Events received out of expected order", expected,
>-//				validSequence);
>+		// prepare
>+		init();
>+		TmfExperiment<LttngEvent> experiment = prepareExperimentToTest();
>+		TmfEventRequest<LttngEvent> request = prepareEventRequest(
>+				LttngEvent.class, 0, 31);
>+
>+		// execute
>+		experiment.sendRequest(request);
>+		try {
>+			request.waitForCompletion();
>+		} catch (InterruptedException e) {
>+			e.printStackTrace();
>+		}
>+
>+		// finish
>+		assertEquals("Unexpected eventCount", 15316, feventCount);
>+		boolean expected = true;
>+		assertEquals("Events received out of expected order", expected,
>+				validSequence);
> 	}
> 
> 	/**
> 	 * 
> 	 */
> 	public void testSyntheticEventRequest() {
>-//		init();
>-//		// Create a new Experiment manager context
>-//		IStateExperimentManager expManager = prepareExperimentContext(false);
>-//
>-//		// make sure a TmfExperiment instance is registered as provider and
>-//		// selected as current
>-//		TmfExperiment<LttngEvent> experiment = prepareExperimentToTest();
>-//
>-//		// experiment selected, build experiment selection context and trigger
>-//		// check point creation
>-//		expManager.experimentSelected_prep(experiment);
>-//		// builds check points in parallel
>-//		expManager.experimentSelected(this, experiment);
>-//
>-//		// Obtain the singleton event provider
>-//		LttngSyntheticEventProvider synProvider = LttngCoreProviderFactory
>-//				.getEventProvider();
>-//
>-//		// prepare synthetic event requests
>-//		boolean printExpectedEvents = false;
>-//		TmfEventRequest<LttngSyntheticEvent> request1 = prepareEventRequest(LttngSyntheticEvent.class, 5, 9,
>-//				printExpectedEvents); /* 2001 events */
>-//		TmfEventRequest<LttngSyntheticEvent> request2 = prepareEventRequest(LttngSyntheticEvent.class, 11, 13,
>-//				printExpectedEvents); /* 1001 events */
>-//
>-//		// execute
>-//		synProvider.sendRequest(request1);
>-//		try {
>-//			request1.waitForCompletion();
>-//		} catch (InterruptedException e) {
>-//			e.printStackTrace();
>-//		}
>-//		System.out.println("EventCount " + feventCount);
>-//
>-//		synProvider.sendRequest(request2);
>-//		try {
>-//			request2.waitForCompletion();
>-//		} catch (InterruptedException e) {
>-//			e.printStackTrace();
>-//		}
>-//		System.out.println("EventCount " + feventCount);
>-//
>-////		try {
>-////			request1.waitForCompletion();
>-////			request2.waitForCompletion();
>-////		} catch (InterruptedException e) {
>-////			e.printStackTrace();
>-////		}
>-////		System.out.println("EventCount " + feventCount);
>-//
>-//		// finish
>-//		assertEquals("Unexpected eventCount", 3002, feventCount);
>+		init();
>+		// Create a new Experiment manager context
>+		IStateExperimentManager expManager = prepareExperimentContext(false);
>+
>+		// make sure a TmfExperiment instance is registered as provider and
>+		// selected as current
>+		TmfExperiment<LttngEvent> experiment = prepareExperimentToTest();
>+
>+		// experiment selected, build experiment selection context and trigger
>+		// check point creation
>+		expManager.experimentSelected_prep(experiment);
>+		// builds check points in parallel
>+		expManager.experimentSelected(this, experiment);
>+
>+		// Obtain the singleton event provider
>+		LttngSyntheticEventProvider synProvider = LttngCoreProviderFactory
>+				.getEventProvider();
>+
>+		// prepare synthetic event requests
>+		boolean printExpectedEvents = false;
>+		TmfEventRequest<LttngSyntheticEvent> request1 = prepareEventRequest(LttngSyntheticEvent.class, 5, 9,
>+				printExpectedEvents); /* 2001 events */
>+		TmfEventRequest<LttngSyntheticEvent> request2 = prepareEventRequest(LttngSyntheticEvent.class, 11, 13,
>+				printExpectedEvents); /* 1001 events */
>+
>+		// execute
>+		synProvider.sendRequest(request1);
>+		try {
>+			request1.waitForCompletion();
>+		} catch (InterruptedException e) {
>+			e.printStackTrace();
>+		}
>+		System.out.println("EventCount " + feventCount);
>+
>+		synProvider.sendRequest(request2);
>+		try {
>+			request2.waitForCompletion();
>+		} catch (InterruptedException e) {
>+			e.printStackTrace();
>+		}
>+		System.out.println("EventCount " + feventCount);
>+
>+		// finish
>+		assertEquals("Unexpected eventCount", 3002, feventCount);
> 	}
> 
> }
>\ No newline at end of file
>Index: ChangeLog
>===================================================================
>--- ChangeLog	(revision 25481)
>+++ ChangeLog	(working copy)
>@@ -1,3 +1,8 @@
>+2010-09-17  Francois Chouinard  <fchouinard@gmail.com>
>+
>+	* src/org/eclipse/linuxtools/lttng/control/LTTngSyntheticEventProviderTest.java: Adjusted unit test
>+	* src/org/eclipse/linuxtools/lttng/LttngTestPreparation.java: Adjusted unit test
>+
> 2010-09-09  Francois Chouinard  <fchouinard@gmail.com>
> 
> 	* src/org/eclipse/linuxtools/lttng/tests/AllLTTngCoreTests.java: Invoke new test

Flags:

fchouinard: iplog-

Actions: View | Diff

Attachments on bug 325662: 179155