--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/sysperfana/perfinvestigator/com.nokia.carbide.cpp.pi/src/com/nokia/carbide/cpp/internal/pi/model/GenericSampledTrace.java	Thu Feb 11 15:32:31 2010 +0200
@@ -0,0 +1,237 @@
+/*
+ * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). 
+ * All rights reserved.
+ * This component and the accompanying materials are made available
+ * under the terms of the License "Eclipse Public License v1.0"
+ * which accompanies this distribution, and is available
+ * at the URL "http://www.eclipse.org/legal/epl-v10.html".
+ *
+ * Initial Contributors:
+ * Nokia Corporation - initial contribution.
+ *
+ * Contributors:
+ *
+ * Description: 
+ *
+ */
+
+package com.nokia.carbide.cpp.internal.pi.model;
+
+import java.util.Enumeration;
+import java.util.Vector;
+
+public abstract class GenericSampledTrace extends GenericTrace
+{
+	private static final long serialVersionUID = -5030416972125713453L;
+	
+	public Vector samples;
+	
+	public GenericSampledTrace()
+	{
+	  this.samples = new Vector();
+	}
+	
+	public void addSample(GenericSample sample)
+	{
+	  this.samples.add(sample);
+	}
+	
+	public Enumeration getSamples()
+	{
+	  return samples.elements();
+	}
+	
+	public GenericSample getSample(int number)
+	{
+	  return (GenericSample)this.samples.elementAt(number);
+	}
+	
+	public Vector<GenericSample> getSamplesInsideTimePeriod(long start, long end)
+	{
+		Enumeration sEnum = samples.elements();
+		Vector<GenericSample> okSamples = new Vector<GenericSample>();
+		
+		while(sEnum.hasMoreElements())
+		{
+			GenericSample s = (GenericSample)sEnum.nextElement();
+			if (s.sampleSynchTime >= start)
+			{
+				if (s.sampleSynchTime <= end)
+				{
+					okSamples.add(s);
+				}
+			}
+		}
+		
+		return okSamples;
+	}
+	
+	public GenericSample[] getSamplesForTime(long time)
+	{
+		// start the search from the middle of the sample set
+		long location = this.samples.size() / 2;
+		
+		// next, add or remove 1/4 of the length of the sample set
+		int div = 4;
+		
+		// boolean value indicating that the search proceeds now one step at a time
+		boolean saturated = false;
+		
+		// search algorithm, proceed until a value is found or 
+		// reached the boundaries of the search area
+
+		// note that the sample numbers MUST increase with growing
+		// indices within the samples vector in order for this 
+		// algorithm to work!
+		while (true)
+		{
+			// take the sample from the location
+			GenericSample s = (GenericSample)samples.elementAt((int)location);
+			
+			// if the searched value is larger than the value at the proposed location
+			// increment the proposed location with the length of the data set divided
+			// by the divisor
+			if (s.sampleSynchTime < time)
+			{
+				if (!saturated)
+				{
+					int change = this.samples.size() / div;
+					if (change >= 1)
+					{
+						location += change;
+						div *= 2;
+					}
+					else 
+					{
+						saturated = true;
+					}
+				}
+				else
+				{
+					// already saturated, go one step at a time
+					location++;
+				}				
+			}
+			// similarly, decrement the proposed location 
+			// if the value is smaller than the searched value
+			else if (s.sampleSynchTime > time)
+			{
+				if (!saturated)
+				{					
+					int change = this.samples.size() / div;
+					if (change >= 1)
+					{
+						location -= change;
+						div *= 2;
+					}
+					else 
+					{
+						saturated = true;
+					}
+				}
+				else
+				{
+					// already saturated, go one step at a time
+					location--;
+				}
+			}
+			else if (s.sampleSynchTime == time)
+			{
+				return this.getSamplesWithSameTimeFrom(location);
+			}
+			
+			// reached the end of the sample set without a match
+			if (location < 0 || location >= this.samples.size())
+				return null;
+		}
+		
+	}
+	
+	private GenericSample[] getSamplesWithSameTimeFrom(long location)
+	{
+		long sameTime = ((GenericSample)samples.elementAt((int)location)).sampleSynchTime;
+		int lowBound = (int)location;
+		int highBound = (int)location;
+		
+		if (lowBound-1 >=0)
+		{	
+			// go backwards as long as there are samples with the same samplenumber
+			while ( ((GenericSample)samples.elementAt(lowBound - 1)).sampleSynchTime == sameTime 
+					&& (lowBound - 1) >= 0)
+			{
+				lowBound--;
+			}
+		}
+		
+		if (highBound + 1 < this.samples.size())
+		{	
+			// go backwards as long as there are samples with the same samplenumber
+			while ( ((GenericSample)samples.elementAt(highBound + 1)).sampleSynchTime == sameTime 
+					&& (highBound + 1) < this.samples.size())
+			{
+				highBound++;
+			}
+		}
+		
+		GenericSample[] sa = new GenericSample[highBound - lowBound + 1];
+		for (int i = 0; i < sa.length; i++)
+		{
+			sa[i] = (GenericSample)samples.elementAt(lowBound + i);
+		}
+		
+		return sa;
+	}
+	
+	public int getSampleAmount()
+	{
+	  return this.samples.size();
+	}
+	
+	public int getFirstSampleNumber()
+	{
+		if (this.samples.size() > 0)
+			return (int)this.getSample(0).sampleSynchTime;
+		else
+			return 0;
+	}
+	
+	public int getLastSampleNumber()
+	{
+		if (this.samples.size() > 0)
+			return (int)((GenericSample)this.samples.lastElement()).sampleSynchTime;
+		else
+			return 0;
+	}
+	
+	public String toString()
+	{
+		Enumeration sEnum = this.getSamples();
+	  	Vector strings = new Vector();
+	  	int totalLength = 0;
+	  	while(sEnum.hasMoreElements())
+	  	{	
+	  		GenericSample s = (GenericSample)sEnum.nextElement();
+	  		String uus = s.toString() + "\n"; //$NON-NLS-1$
+	  		totalLength += uus.getBytes().length;
+	  		strings.add(uus);
+	  	}
+	  	
+	  	System.out.println(Messages.getString("GenericSampledTrace.totalLength") + totalLength); //$NON-NLS-1$
+	  	byte[] bytes = new byte[totalLength];
+	  	sEnum = strings.elements();
+	  	int index = 0;
+	  	while(sEnum.hasMoreElements())
+	  	{
+	  		String s = (String)sEnum.nextElement();
+	  		byte[] sB = s.getBytes();
+	  		for (int i = index; i < index + sB.length; i++)
+	  		{
+	  			bytes[i] = sB[i - index];
+	  		}
+	  		index += sB.length;
+	  	}
+	  	
+	  	String total = new String(bytes);
+	  	return total;
+	  }
+}