Index: /query-answering/src/main/java/gr/ntua/ece/cslab/modissense/dataoriented/QueryAnswering.java
===================================================================
--- /query-answering/src/main/java/gr/ntua/ece/cslab/modissense/dataoriented/QueryAnswering.java (revision 749)
+++ /query-answering/src/main/java/gr/ntua/ece/cslab/modissense/dataoriented/QueryAnswering.java (revision 749)
@@ -0,0 +1,302 @@
+package gr.ntua.ece.cslab.modissense.dataoriented;
+
+import gr.ntua.ece.cslab.modissense.dataoriented.containers.POI;
+import gr.ntua.ece.cslab.modissense.dataoriented.containers.POIList;
+import gr.ntua.ece.cslab.modissense.dataoriented.threads.DataFetcherThread;
+
+import java.io.IOException;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.NavigableMap;
+import java.util.Random;
+import java.util.Set;
+import java.util.TreeMap;
+
+import org.apache.hadoop.hbase.HBaseConfiguration;
+import org.apache.hadoop.hbase.client.HTable;
+
+public class QueryAnswering {
+	
+	public static final Integer MAX_NUMBER_OF_USERS=50000;
+	public static int OUTPUT_RESULTS = 100;
+	public static String TABLE_NAME = "TestingTable";
+	public static String COLUMN_FAMILY = "cf";
+	public static String QUALIFIER = "";
+	public static Integer THREADS = 10;
+
+	
+	public static int GET_BUFFER = 100; 
+	
+	// query params
+	private List<Long> users;
+	private double xFrom, yFrom;
+	private double xTo, yTo;
+	private List<String> keywords;
+	private HTable table;
+	private List<POI> results;
+	
+	public QueryAnswering() throws IOException {
+		this.table = new HTable(HBaseConfiguration.create(), TABLE_NAME);
+		this.results = new LinkedList<POI>();
+	}
+	
+	public List<Long> getUsers() {
+		return users;
+	}
+
+	public void setUsers(List<Long> users) {
+		this.users = users;
+	}
+
+	public double getxFrom() {
+		return xFrom;
+	}
+
+	public void setxFrom(double xFrom) {
+		this.xFrom = xFrom;
+	}
+
+	public double getyFrom() {
+		return yFrom;
+	}
+
+	public void setyFrom(double yFrom) {
+		this.yFrom = yFrom;
+	}
+
+	public double getxTo() {
+		return xTo;
+	}
+
+	public void setxTo(double xTo) {
+		this.xTo = xTo;
+	}
+
+	public double getyTo() {
+		return yTo;
+	}
+
+	public void setyTo(double yTo) {
+		this.yTo = yTo;
+	}
+
+	public List<String> getKeywords() {
+		return keywords;
+	}
+
+	public void setKeywords(List<String> keywords) {
+		this.keywords = keywords;
+	}
+
+	public List<POI> getResults(){
+		return this.results;
+	}
+	
+	public void executeQuery() throws IOException, InterruptedException{
+		List<POIList> list = this.getDataFromDB();
+		
+		Map<Long, List<POI>> map = new HashMap<Long, List<POI>>();
+		for(POIList pl:list){
+			for(POI p:pl.getPOIs()){
+				if(this.POIisValid(p)){
+					if(map.get(p.getId())==null){
+						map.put(p.getId(), new LinkedList<POI>());
+					}
+					map.get(p.getId()).add(p);
+				}
+					
+			}
+		}
+		
+		TreeMap<Double, POI> sorted = new TreeMap<Double, POI>();
+		
+		for(Entry<Long, List<POI>> e:map.entrySet()){
+			double rank= 0.0;
+			for(POI p:e.getValue())
+				rank+=p.getScore();
+			rank/=e.getValue().size();
+			POI temp = e.getValue().get(0);
+			
+			POI newPOI = new POI();
+			newPOI.setId(temp.getId());
+			newPOI.setKeywords(temp.getKeywords());
+			newPOI.setName(temp.getName());
+			newPOI.setScore(rank);
+			newPOI.setX(temp.getX());
+			newPOI.setY(temp.getY());
+			sorted.put(rank, newPOI);
+		}
+		
+		int count = 0;
+		NavigableMap<Double, POI> reverseSorted = sorted.descendingMap();
+		for(Entry<Double, POI> e: reverseSorted.entrySet()){
+			count+=1;
+			this.results.add(e.getValue());
+//			System.out.println(e.getValue().getId()+"\t"+e.getValue().getScore()+"\t["+e.getKey()+"]");
+			if(count>= OUTPUT_RESULTS)
+				break;
+			
+		}
+	}
+		
+	public List<POIList> getDataFromDB() throws IOException, InterruptedException{
+		
+		List<POIList> returnValue = new LinkedList<POIList>();
+		Collections.sort(this.users);
+		List<DataFetcherThread> threads = new LinkedList<DataFetcherThread>();
+		int portion = this.users.size()/THREADS;
+		for(int i=0;i<THREADS;i++){
+			int beginIndex = i*portion;
+			int endIndex = (i==THREADS-1?this.users.size():(i+1)*portion);
+			DataFetcherThread thread = new DataFetcherThread();
+			thread.setUsers(this.users.subList(beginIndex, endIndex));
+			thread.setTable(table);
+			threads.add(thread);
+		}
+		
+		for(Thread t:threads){
+			t.start();
+		}
+		
+		for(Thread t:threads){
+			t.join();
+		}
+		
+		for(DataFetcherThread t: threads){
+			for(POIList pl:t.getResults()){
+				returnValue.add(pl);
+			}
+		}
+		return returnValue;
+	}
+	
+	public boolean POIisValid(POI poi){
+		if(poi.getX()<this.xFrom || poi.getX() > this.xTo)
+			return false;
+		if(poi.getY()<this.yFrom || poi.getY() > this.yTo)
+			return false;
+		for(String s:keywords){
+			if(poi.getKeywords().contains(s))
+				return true;
+		}
+		return false;
+	}
+	
+	public void close() throws IOException{
+		this.table.close();
+	}
+	
+	public static int getIndex(String[] args, String key){
+		int index=0;
+		for(String s:args){
+			if(s.equals(key))
+				return index;
+			else
+				index+=1;
+		}
+		return -1;
+	}
+	
+	public static void main(String[] args) throws IOException, InterruptedException {
+		boolean randomUsers = false;
+		int validArgumentsCount = 0;
+		if(getIndex(args, "--random-users")!=-1){
+			randomUsers=true;
+		}
+		
+		List<Long> users = new LinkedList<Long>();
+		
+		if(getIndex(args, "--users")!=-1){
+			validArgumentsCount+=1;
+			if(randomUsers){
+				Random rand = new Random();
+				int usersCount = new Integer(args[getIndex(args, "--users")+1]);
+				Set<Long> chosenUsers = new HashSet<Long>();
+				for(int i=0;i<usersCount;i++){
+					Long choice = Math.abs((rand.nextLong())%MAX_NUMBER_OF_USERS+1);
+					while(chosenUsers.contains(choice))
+						choice = Math.abs((rand.nextLong())%MAX_NUMBER_OF_USERS+1);
+					users.add(choice);
+				}
+			} else {
+				String[] userIds = args[getIndex(args, "--users")+1].split(" ");
+				for(String s:userIds){
+					users.add(new Long(s));
+				}
+			}
+		}
+		
+		double xFrom = 0, xTo = 0, yFrom = 0, yTo = 0;
+		if(getIndex(args, "--coordinates")!=-1){
+			validArgumentsCount+=1;
+			String[] values = args[getIndex(args, "--coordinates")+1].split(" ");
+			xFrom = new Double(values[0]);
+			yFrom = new Double(values[1]);
+			xTo = new Double(values[2]);
+			yTo = new Double(values[3]);
+		}
+		
+		List<String> keywords = new LinkedList<String>();
+		if(getIndex(args, "--keywords")!=-1){
+			validArgumentsCount+=1;
+			for(String s:args[getIndex(args, "--keywords")+1].split(" "))
+				keywords.add(s);
+		}
+		
+		if(getIndex(args, "--get-buffer")!=-1) {
+			GET_BUFFER = new Integer(args[getIndex(args, "--get-buffer")+1]);
+		}
+		
+		if(getIndex(args, "--threads")!=-1) {
+			THREADS = new Integer(args[getIndex(args, "--threads")+1]);
+		}
+		if(getIndex(args, "--output")!=-1) {
+			OUTPUT_RESULTS = new Integer(args[getIndex(args, "--output")+1]);
+		}
+		
+		if(validArgumentsCount!=3) {
+			System.out.println("Needed arguments"
+					+ "\n\t"
+					+ "--users\t\t\tlist of user ids (in double quotes) or a number of randomly chosen users"
+					+ "\n\t"
+					+ "--coordinates\t\tcoordinates rectangular in the following form \"xFrom yFrom xTo yTo\""
+					+ "\n\t"
+					+ "--keywords\t\tspace separated list of keywords encapsulated in double quotes"
+					+ "\n"
+					+ "Optional arguments:"
+					+ "\n\t"
+					+ "--random-users\t\tIf the users defined will be randomly picked"
+					+ "\n\t"
+					+ "--get-buffer\t\tthe number of cached gets before sending the request to HBase (default 100)"
+					+ "\n\t"
+					+ "--threads\t\tthreads initiated for hitting the db server"
+					+ "\n\t"
+					+ "--output\t\tdetermine the number of POIs chosen");
+			System.exit(1);
+		}
+		
+		QueryAnswering qa = new QueryAnswering();
+		
+		qa.setKeywords(keywords);
+		qa.setUsers(users);
+		qa.setxFrom(xFrom);
+		qa.setyFrom(yFrom);
+		qa.setxTo(xTo);
+		qa.setyTo(yTo);
+		
+		long start = System.currentTimeMillis();
+//		System.out.print("Fetching data from database...");
+//		qa.getDataFromDB();
+//		System.out.format(" DONE! (%d ms)\n", (System.currentTimeMillis()-start));
+		qa.executeQuery();
+		System.out.println(qa.users.size()+"\t"+(System.currentTimeMillis()-start));
+		qa.close();
+		System.err.println(qa.getResults());
+	}
+
+}
Index: /query-answering/src/main/java/gr/ntua/ece/cslab/modissense/dataoriented/datagen/QuickDataGenerator.java
===================================================================
--- /query-answering/src/main/java/gr/ntua/ece/cslab/modissense/dataoriented/datagen/QuickDataGenerator.java (revision 749)
+++ /query-answering/src/main/java/gr/ntua/ece/cslab/modissense/dataoriented/datagen/QuickDataGenerator.java (revision 749)
@@ -0,0 +1,200 @@
+package gr.ntua.ece.cslab.modissense.dataoriented.datagen;
+
+import gr.ntua.ece.cslab.modissense.dataoriented.containers.POI;
+import gr.ntua.ece.cslab.modissense.dataoriented.containers.POIList;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Random;
+import java.util.Set;
+
+import org.apache.hadoop.hbase.HBaseConfiguration;
+import org.apache.hadoop.hbase.HColumnDescriptor;
+import org.apache.hadoop.hbase.HTableDescriptor;
+import org.apache.hadoop.hbase.client.HBaseAdmin;
+import org.apache.hadoop.hbase.client.HTable;
+import org.apache.hadoop.hbase.client.Put;
+import org.apache.hadoop.hbase.util.Bytes;
+
+public class QuickDataGenerator {
+	
+	public static String TABLE_NAME = "TestingTable";
+	public static String COLUMN_FAMILY = "cf";
+	public static String QUALIFIER = "";
+	
+	public static Integer MedianPOIsPerUser = 100;
+	public static Integer DeviationPOIsPerUser = 10;
+	
+	public static Integer PutsBufferSize=1000;
+
+	public static String[] keywords = {"beer", "wine", "bar", "food", "restaurant", "italian", "nice", "good", "dance"};
+	public static Double[] regionX = {10.0, 20.0, 30.0};
+	public static Double[] regionY = {10.0, 20.0, 30.0};
+	public static String letters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWYZ ";
+	
+	private List<POI> pool;
+	private int poisSize;
+	private int usersSize;
+	
+	public QuickDataGenerator() {
+		
+	}
+	
+	public int getPoisSize() {
+		return poisSize;
+	}
+
+	public void setPoisSize(int poisSize) {
+		this.poisSize = poisSize;
+	}
+
+	public int getUsersSize() {
+		return usersSize;
+	}
+
+	public void setUsersSize(int usersSize) {
+		this.usersSize = usersSize;
+	}
+
+	public List<POI> getPool(){
+		return this.pool;
+	}
+	
+	public void createPOIPool(){
+		this.pool = new ArrayList<POI>(this.poisSize);
+		for(Long i=1l;i<=this.poisSize;i++){
+			this.pool.add(this.createRandomPOI(i));
+		}
+	}
+	
+	public POI createRandomPOI(Long id){
+		Random rand = new Random();
+		POI poi =  new POI();
+		int nameSize = rand.nextInt(50);
+		StringBuffer buffer = new StringBuffer();
+		for(int i=0;i<nameSize; i++){
+			buffer.append(letters.charAt(rand.nextInt(letters.length())));
+		}
+		String poiName = buffer.toString();						//poiname
+		Set<String> keyws = new HashSet<String>();				//keywords
+		int keywsCount = rand.nextInt(keywords.length)+1;			
+		for(int i=0;i<keywsCount;i++){
+			keyws.add(keywords[rand.nextInt(keywords.length)]);
+		}
+		
+		Double xDomain = regionX[rand.nextInt(regionX.length)];
+		Double yDomain = regionY[rand.nextInt(regionX.length)];
+		xDomain+=rand.nextGaussian();						// X
+		yDomain+=rand.nextGaussian();						// Y
+		
+		poi.setId(id);
+		poi.setName(poiName);
+		poi.setKeywords(keyws);
+		poi.setX(xDomain);
+		poi.setY(yDomain);
+		
+		return poi;
+	}
+	
+	public void createTable() throws IOException{
+		HBaseAdmin admin = new HBaseAdmin(HBaseConfiguration.create());
+		if(admin.tableExists(TABLE_NAME)){
+			admin.disableTable(TABLE_NAME);
+			admin.deleteTable(TABLE_NAME);
+		}
+		HTableDescriptor descripton = new HTableDescriptor(TABLE_NAME);
+		descripton.addFamily(new HColumnDescriptor(COLUMN_FAMILY.getBytes()));
+		admin.createTable(descripton);
+		admin.close();
+	}
+	
+	public POIList createPOIList(){
+		HashSet<Integer> chosenValues = new HashSet<Integer>();
+		Random rand = new Random();
+		
+		long numberOfPOIsInPOIList = Math.round((rand.nextGaussian()*DeviationPOIsPerUser+MedianPOIsPerUser));
+		
+		POIList list = new POIList();
+		for(long i=0;i<numberOfPOIsInPOIList;i++){
+			int index = rand.nextInt(this.poisSize); 
+			while(chosenValues.contains(index))
+				index = rand.nextInt(this.poisSize);
+			chosenValues.add(index);
+			POI chosen = this.pool.get(index);
+			chosen.setScore(rand.nextDouble());
+			list.addPOI(chosen);
+		}
+		
+		return list;
+	}
+	
+	public void populateTable() throws IOException{
+		HTable table = new HTable(HBaseConfiguration.create(), TABLE_NAME);
+		List<Put> puts = new LinkedList<Put>();
+		for(long i=1;i<=this.usersSize;i++){
+			System.out.format("Creating POIList for user %d...\t",i);
+			byte[] poiListSerialized = this.createPOIList().getCompressedBytes();
+			System.out.println("Done!");
+			Put put = new Put(Bytes.toBytes(i));
+			put.add(COLUMN_FAMILY.getBytes(), QUALIFIER.getBytes(), poiListSerialized);
+			puts.add(put);
+			if(i%PutsBufferSize==0 || i==this.usersSize){
+				System.out.println("Flushing puts buffer");
+				table.put(puts);
+				puts.clear();
+			}
+		}
+		table.close();
+	}
+	
+	public static int getIndex(String[] args, String key){
+		int index=0;
+		for(String s:args){
+			if(s.equals(key))
+				return index;
+			else
+				index+=1;
+		}
+		return -1;
+	}
+		
+	public static void main(String[] args) throws IOException {
+		if(args.length<4){
+			System.out.println("I need \n\t--pois <number> \n\t--users <number> \nparameters, indicating the number of pois and users respectively.");
+			System.out.println("Optional parameters:"
+					+ "\n\t"
+					+ "--median <number>\t(indicating the average number of pois per user, as calculated from a Gauss distr)"
+					+ "\n\t"
+					+ "--deviation <number>\t(indicating the deviation from the median)"
+					+ "\n\t"
+					+ "--put-buffer-size\t(how many puts are cached before written to hbase)");
+			System.exit(1);
+		}
+		
+		int poolSize = new Integer(args[getIndex(args, "--pois")+1]);
+		int users = new Integer(args[getIndex(args, "--users")+1]);
+		if(getIndex(args, "--median")!=-1){
+			MedianPOIsPerUser = new Integer(args[getIndex(args, "--median")+1]);
+		}
+		if(getIndex(args, "--deviation")!=-1){
+			DeviationPOIsPerUser = new Integer(args[getIndex(args, "--deviation")+1]);
+		}
+		if(getIndex(args, "--put-buffer-size")!=-1){
+			PutsBufferSize = new Integer(args[getIndex(args, "--put-buffer-size")+1]);
+		}
+
+		QuickDataGenerator gen = new QuickDataGenerator();
+		gen.setPoisSize(poolSize);
+		gen.setUsersSize(users);
+		gen.createPOIPool();
+		System.out.println("Created POI pool, sized "+gen.getPool().size());
+		gen.createTable();
+		System.out.println("Created table to HBase with name "+QuickDataGenerator.TABLE_NAME);
+		gen.populateTable();
+		System.out.format("Populated %s with %d users\t", QuickDataGenerator.TABLE_NAME, gen.getUsersSize());
+		
+	}
+}
Index: /query-answering/src/main/java/gr/ntua/ece/cslab/modissense/dataoriented/containers/POI.java
===================================================================
--- /query-answering/src/main/java/gr/ntua/ece/cslab/modissense/dataoriented/containers/POI.java (revision 748)
+++ /query-answering/src/main/java/gr/ntua/ece/cslab/modissense/dataoriented/containers/POI.java (revision 749)
@@ -9,4 +9,5 @@
 public class POI implements Serializable{
 
+	private Long id;
 	private String name;
 	private Double x, y;
@@ -15,5 +16,10 @@
 	
 	public POI() {
-		
+		this.id = new Long(Long.MAX_VALUE);
+		this.name = new String();
+		this.x = new Double(Double.MAX_VALUE);
+		this.y = new Double(Double.MAX_VALUE);
+		this.keywords = new HashSet<String>();
+		this.score = new Double(Long.MAX_VALUE);
 	}
 	
@@ -51,7 +57,15 @@
 	}
 
+	public Long getId() {
+		return id;
+	}
+
+	public void setId(Long poiId) {
+		this.id = poiId;
+	}
+	
 	@Override
 	public String toString() {
-		return this.name+" @ "+"("+this.x+", "+this.y+") tagged with "+this.keywords +" with score "+this.score;
+		return "["+this.id+"] "+this.name+" @ "+"("+this.x+", "+this.y+") tagged with "+this.keywords +" with score "+this.score;
 	}
 
@@ -61,8 +75,11 @@
 		
 		ByteBuffer buffer = ByteBuffer.wrap(bytes);
+		this.id = buffer.getLong(index);
+		index+= Long.SIZE/8;
+		
 		int sizeOfName = buffer.getInt(index);
 		index+= Integer.SIZE/8;
 		
-		this.name = new String(bytes, 4, sizeOfName);
+		this.name = new String(bytes, index, sizeOfName);
 		index+=this.name.length();
 		
@@ -93,5 +110,6 @@
 	@Override
 	public byte[] getBytes() {
-		int totalSize = 	Integer.SIZE/8 + this.name.length() // bytes needed to write string size + string
+		int totalSize =		Long.SIZE/8						// poi id	 	
+							+ Integer.SIZE/8 + this.name.length() // bytes needed to write string size + string
 							+ Double.SIZE/8 					// x coord
 							+ Double.SIZE/8						// y coord
@@ -103,4 +121,5 @@
 		
 		ByteBuffer buffer = ByteBuffer.wrap(serializable);
+		buffer.put(Bytes.toBytes(this.id));
 		buffer.put(Bytes.toBytes(this.name.length()));
 		buffer.put(this.name.getBytes());
@@ -120,4 +139,5 @@
 		POI poi = new POI();
 		
+		poi.setId(1l);
 		poi.setName("Fraoulokipos");
 		poi.setX(10.2);
Index: /query-answering/src/main/java/gr/ntua/ece/cslab/modissense/dataoriented/threads/DataFetcherThread.java
===================================================================
--- /query-answering/src/main/java/gr/ntua/ece/cslab/modissense/dataoriented/threads/DataFetcherThread.java (revision 749)
+++ /query-answering/src/main/java/gr/ntua/ece/cslab/modissense/dataoriented/threads/DataFetcherThread.java (revision 749)
@@ -0,0 +1,118 @@
+package gr.ntua.ece.cslab.modissense.dataoriented.threads;
+
+import gr.ntua.ece.cslab.modissense.dataoriented.QueryAnswering;
+import gr.ntua.ece.cslab.modissense.dataoriented.containers.POIList;
+
+import java.io.IOException;
+import java.util.LinkedList;
+import java.util.List;
+
+import org.apache.hadoop.hbase.client.Get;
+import org.apache.hadoop.hbase.client.HTable;
+import org.apache.hadoop.hbase.client.Result;
+import org.apache.hadoop.hbase.util.Bytes;
+
+public class DataFetcherThread extends Thread {
+
+	private HTable table;
+	private List<Long> users;
+	private List<POIList> results;
+
+
+	private long totalTime=0, fetchTime=0, transformTime=0;
+	public DataFetcherThread() {
+		super();
+		this.results = new LinkedList<POIList>();
+	}
+
+	public HTable getTable() {
+		return table;
+	}
+
+	public void setTable(HTable table) {
+		this.table = table;
+	}
+
+	public List<Long> getUsers() {
+		return users;
+	}
+
+	public void setUsers(List<Long> users) {
+		this.users = users;
+	}
+
+	public List<POIList> getResults() {
+		return results;
+	}
+
+	public long getTotalTime() {
+		return totalTime;
+	}
+
+	public long getFetchTime() {
+		return fetchTime;
+	}
+
+	public long getTransformTime() {
+		return transformTime;
+	}
+
+	@Override
+	public synchronized void start() {
+		super.start();
+		this.totalTime = System.currentTimeMillis();
+	}
+	@Override
+	public void run() {
+		try {
+			List<Get> gets = new LinkedList<Get>();
+			for(Long userId:this.users){
+				Get get = new Get(Bytes.toBytes(userId));
+				gets.add(get);
+				if(gets.size()%QueryAnswering.GET_BUFFER==0) {
+					long fetchTime = System.currentTimeMillis();
+					long transformTime = 0;
+					Result[] results;
+					results = table.get(gets);
+					for(Result r: results){
+						byte[] bytes = r.getValue(QueryAnswering.COLUMN_FAMILY.getBytes(), QueryAnswering.QUALIFIER.getBytes());
+						if(bytes!=null){
+							long start = System.currentTimeMillis();
+							POIList poilist = new POIList();
+							poilist.parseCompressedBytes(bytes);
+							this.results.add(poilist);
+							transformTime=System.currentTimeMillis()-start;
+						} else {
+							System.out.println("Null byte array");
+						}
+					}
+					this.fetchTime += (System.currentTimeMillis()-fetchTime) - transformTime;
+					this.transformTime+=transformTime;
+					gets.clear();
+				}
+			}
+			if(gets.size()!=0) {
+				long fetchTime = System.currentTimeMillis();
+				long transformTime = 0;
+				Result[] results;
+				results = table.get(gets);
+				for(Result r: results){
+					byte[] bytes = r.getValue(QueryAnswering.COLUMN_FAMILY.getBytes(), QueryAnswering.QUALIFIER.getBytes());
+					if(bytes!=null){
+						long start = System.currentTimeMillis();
+						POIList poilist = new POIList();
+						poilist.parseCompressedBytes(bytes);
+						this.results.add(poilist);
+						transformTime=System.currentTimeMillis()-start;
+					}
+				}
+				this.fetchTime += (System.currentTimeMillis()-fetchTime) - transformTime;
+				this.transformTime+=transformTime;
+			}
+
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+		this.totalTime = System.currentTimeMillis() - this.totalTime;
+	}
+}
