diff -r 15296fd0af4a -r 14dc2103a631 trace/traceanalyser/com.nokia.s60tools.traceanalyser/src/com/nokia/s60tools/traceanalyser/model/RuleManager.java
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/trace/traceanalyser/com.nokia.s60tools.traceanalyser/src/com/nokia/s60tools/traceanalyser/model/RuleManager.java	Wed Jun 23 13:57:56 2010 +0300
@@ -0,0 +1,429 @@
+/*
+* 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 "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.s60tools.traceanalyser.model;
+
+import java.util.*;
+import org.eclipse.core.runtime.IProgressMonitor;
+import org.eclipse.core.runtime.IStatus;
+import org.eclipse.core.runtime.Status;
+import org.eclipse.core.runtime.jobs.Job;
+import org.eclipse.core.runtime.jobs.ILock;
+
+import com.nokia.s60tools.traceanalyser.containers.DummyRule;
+import com.nokia.s60tools.traceanalyser.containers.RuleInformation;
+import com.nokia.s60tools.traceanalyser.export.ITraceAnalyserRuleType;
+import com.nokia.s60tools.traceanalyser.export.RuleEvent;
+import com.nokia.s60tools.traceanalyser.export.TraceAnalyserRule;
+import com.nokia.s60tools.traceanalyser.export.RuleEvent.RuleStatus;
+import com.nokia.s60tools.traceanalyser.interfaces.ITraceAnalyserFileObserver;
+
+
+/**
+ * This class is responsible for providing Trace Analyser rules and history data to MainView's content provider.
+ * Class calls every rule types getRules-method to get every Trace Analyser Rule rule.
+ * After that class calls each rules getHistoryData method to get history data. 
+ */
+public class RuleManager extends Job {
+	
+	/* file observer */
+	ITraceAnalyserFileObserver engine = null;
+	
+	/* accesslock */
+	ILock accessLock = null;
+	
+	/* boolean value that is true when job is on-going */
+	boolean jobRunning = false;
+	
+	/* List of rule types */
+	ArrayList<ITraceAnalyserRuleType> ruleTypes = null;
+
+	/* HashMap containing each rule and its history data. */
+	HashMap<String, RuleInformation> history = null;
+	
+	/**
+	 * TraceAnalyserFileManager.
+	 * Constructor.
+	 * @param engine, engine which is notified when reading is finished.
+	 * @param ruleTypes, ArrayList, which contains all rule types.
+	 */
+	public RuleManager( ITraceAnalyserFileObserver engine, ArrayList<ITraceAnalyserRuleType> ruleTypes ) {
+		super("Trace Analyser - Reading Rules");
+		this.engine = engine;
+		accessLock = Job.getJobManager().newLock();
+		jobRunning = false;
+		this.ruleTypes = ruleTypes;
+	}
+
+
+	/*
+	 * (non-Javadoc)
+	 * @see org.eclipse.core.runtime.jobs.Job#run(org.eclipse.core.runtime.IProgressMonitor)
+	 */
+	protected IStatus run(IProgressMonitor monitor) {
+
+		accessLock.acquire();
+		
+		// if history has never been read, read it now.
+		if(history == null){
+			
+			history = new HashMap<String,RuleInformation>();
+			ArrayList<TraceAnalyserRule> ruleArray = new ArrayList<TraceAnalyserRule>();
+			
+			// read rules
+			for(ITraceAnalyserRuleType item : ruleTypes){
+				ruleArray.addAll(item.getRules());
+			}
+			
+			// Read History.
+			for(TraceAnalyserRule item : ruleArray){
+				
+				// Get history data from rule
+				RuleInformation information = new RuleInformation(item);
+				information.setEvents(item.readHistory());
+				
+				// count history data(amount off passes, fails....)
+				countHistory(information);
+				history.put(item.getName(), information);
+				}		
+		}
+		engine.rulesUpdated();
+		accessLock.release();
+		jobRunning = false;
+		return Status.OK_STATUS;
+	}
+
+
+	
+	/**
+	 * getRuleInformation.
+	 * Method that returns reads rules and history . If rules are not read method starts reading them.
+	 * @return Rules and History data, or dummy object if job is on-going.
+	 */
+	public RuleInformation[] getRuleInformation() {
+		// files have not yet been read, start reading process
+		if (history == null) {
+			
+			if( jobRunning == false ){
+				jobRunning = true;
+				setPriority(Job.LONG);
+				setUser(false);
+				schedule(100);
+			}
+			RuleInformation[] cFiles = new RuleInformation[1];
+			DummyRule dummyRule = new DummyRule("Loading rules and history...");
+			cFiles[0] = new RuleInformation(dummyRule);
+			return cFiles;
+		}
+		else{
+			return history.values().toArray(new RuleInformation[history.size()]);
+		}
+		
+	}
+	
+	
+	
+	
+	/**
+	 * refresh.
+	 * Resfresh rule list.
+	 */
+	public void refresh() {
+		
+		accessLock.acquire();
+		try {
+			if (!jobRunning) {
+				jobRunning = true;
+				setPriority(Job.LONG);
+				setUser(false);
+				schedule(100);
+			}
+		} 
+		catch (Exception e) {
+			e.printStackTrace();
+		} 
+		finally {
+			accessLock.release();
+		}
+	}
+
+	/**
+	 * addRule.
+	 * Adds new rule.
+	 * @param newRule rule that should be added.
+	 * @return true if rule was added(file operations successful)
+	 */
+	public boolean addRule(TraceAnalyserRule newRule){
+		accessLock.acquire();
+		if(history.containsKey(newRule.getName())){
+			accessLock.release();
+			return false;
+		}
+		else{
+			history.put(newRule.getName(),new RuleInformation(newRule));
+			accessLock.release();
+			return true;
+		}
+	}
+	
+	/**
+	 * changeRuleActivation
+	 * @param ruleName name of the rule
+ 
+	 */
+	public void changeRuleActivation(String ruleName, boolean value){
+		RuleInformation information = history.get(ruleName);
+		if(information != null){
+			information.getRule().setActivated(value);
+			
+		}
+	}
+	
+	
+	/**
+	 * removeRule.
+	 * Removes rule
+	 * @param ruleName rule that should be removed.
+	 * @return true if rule was removed(file operations successful)
+	 */
+	public boolean removeRule(String ruleName){
+		accessLock.acquire();
+		
+		RuleInformation item = history.get(ruleName);
+		boolean deleteComplete = item.delete();
+		if( deleteComplete ){
+			history.remove(ruleName);
+		}
+		accessLock.release();
+		return deleteComplete;
+		
+
+	}
+	
+	
+	/**
+	 * saveHistory.
+	 * Saves history data into each rule.
+	 */
+	@SuppressWarnings("unchecked")
+	public void saveData(){
+		Set set = history.entrySet();
+		Iterator i = set.iterator();
+		int index = 0;
+		
+		
+		
+		while (i.hasNext()) {
+			Map.Entry me = (Map.Entry) i.next();
+			RuleInformation information = (RuleInformation) me.getValue();
+			if(!information.getRule().writeXML()){
+				System.out.println("Unable to save rule definitions"
+						+ information.getRule().getName());
+			}
+			if (!information.getRule().saveHistory(information.getEvents())) {
+				System.out.println("Unable to save history data on rule"
+						+ information.getRule().getName());
+			}
+		
+			index++;
+		}
+	}
+
+	/**
+	 * getActivatedRules.
+	 * @return array of all activated rules.
+	 */
+	@SuppressWarnings("unchecked")
+	public TraceAnalyserRule[] getActivatedRules() {
+		accessLock.acquire();
+		TraceAnalyserRule[] ruleArray = null;
+		ArrayList<TraceAnalyserRule> rules = new ArrayList<TraceAnalyserRule>();
+		if(history != null){
+			//ruleArray = new TraceAnalyserRule[history.size()];
+			Set set = history.entrySet();
+		    Iterator i = set.iterator();
+		    int index = 0;
+		    while (i.hasNext()) {
+				Map.Entry me = (Map.Entry) i.next();
+				TraceAnalyserRule rule = ((RuleInformation) me.getValue()).getRule();
+				if(rule.isActivated()){
+					rules.add(rule);
+				}
+				//ruleArray[index] = ((RuleInformation) me.getValue()).getRule().isActivated();
+				index++;
+			}
+			ruleArray = rules.toArray(new TraceAnalyserRule[rules.size()]);
+
+		}
+		else{
+			ruleArray = new TraceAnalyserRule[0];	
+		}
+		accessLock.release();
+		return ruleArray;
+	}
+
+	/**
+	 * addHistoryEvent.
+	 * Adds new history event.
+	 * @param ruleName name of the rule where event is added.
+	 * @param event history event.
+	 */
+	public void addHistoryEvent(String ruleName, RuleEvent event){
+		accessLock.acquire();
+		RuleInformation item = history.get(ruleName);
+		item.getEvents().add(event);
+		countHistory(item);
+		engine.ruleUpdated(ruleName);
+		accessLock.release();
+
+	}
+	
+	
+	/**
+	 * countHistory.
+	 * Counts history values.
+	 * @param information rule which history values are counted.
+	 */
+	private void countHistory(RuleInformation information){
+		ArrayList<RuleEvent> events = information.getEvents();
+		
+		int pass = 0;
+		int fail = 0;
+		int min = 0;
+		int max = 0;
+		int sum = 0;
+		
+		int[] values = new int[events.size()];
+		
+		for(int i = 0; i < events.size(); i++){
+			
+			
+			RuleEvent event = events.get(i);
+			
+			// if first event set as max and min value.
+			if(i == 0){
+				min = event.getValue();
+				max = event.getValue();
+			}
+			else{
+				// if event value is smaller than min value set event value as min.
+				if(event.getValue() < min){
+					min = event.getValue();
+				}
+				// if event value is greater than max value set event value as max.
+				else if(event.getValue() > max){
+					max = event.getValue();
+				}
+			}
+			
+			// count passes and fails.
+			if(event.getStatus() == RuleStatus.PASS){
+				pass++;
+			}
+			else{
+				fail++;
+			}
+			
+			// count sum and add value to value-array.
+			sum += event.getValue();
+			values[i] = event.getValue();
+		}
+		information.setPass(pass);
+		information.setFail(fail);
+		information.setMin(min);
+		information.setMax(max);
+		
+		// count average based on sum of values.
+		if(events.size() > 0){
+			information.setAvg(sum/events.size());
+		}
+		
+		// count median based on value-array.
+		if(values.length > 0){
+			Arrays.sort(values);
+			information.setMed(values[values.length/2]);
+		}
+		
+	}
+	
+	
+	/**
+	 * clearHistory.
+	 * Clears history data about each rule.
+	 */
+	@SuppressWarnings("unchecked")
+	public void clearHistory(){
+		Set set = history.entrySet();
+	    Iterator i = set.iterator();
+	    
+	    int index = 0;
+	    
+	    while (i.hasNext()) {
+			Map.Entry me = (Map.Entry) i.next();
+			((RuleInformation) me.getValue()).setEvents(new ArrayList<RuleEvent>());
+			countHistory((RuleInformation) me.getValue());
+			index++;
+		}
+		engine.rulesUpdated();
+	}
+	
+	/**
+	 * clearOneRulesHistory.
+	 * Clears history data about one rule.
+	 * @param ruleName rule that's history is cleared.
+	 */
+	public void clearOneRulesHistory(String ruleName){
+		RuleInformation information = history.get(ruleName);
+		information.setEvents(new ArrayList<RuleEvent>());
+		countHistory(information);
+	    engine.ruleUpdated(ruleName);
+
+	}
+	
+	/**
+	 * ruleExists.
+	 * @param ruleName name of the rule
+	 * @return true if rule with that name already exists
+	 */
+	public boolean ruleExists(String ruleName){
+		if(history.get(ruleName) != null){
+			return true;
+		}
+		else{
+			return false;
+		}
+	}
+	
+	
+	/**
+	 * getRule.
+	 * returns one rule.
+	 * @param ruleName name of the rule that is requested.
+	 * @return rule
+	 */
+	public TraceAnalyserRule getRule(String ruleName){
+		RuleInformation information = history.get(ruleName);
+		if(information != null){
+			return information.getRule();
+		}
+		else{
+			return null;
+		}
+	}
+
+}