pdbench/census/Chase/src/Settings.java

import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;

import org.w3c.dom.Document;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;

/**
 * 
 */

/**
 * @author Lublena
 *
 */
public class Settings
{
	private String fileName;
	//private HashMap<String, String> dbSettings;
	//ArrayList<Dependency> dependencies;
	private HashMap dbSettings;
	ArrayList dependencies;
	
	Settings(String aFileName)
	{
		fileName = aFileName;
		//dbSettings = new HashMap<String, String>();
		//dependencies = new ArrayList<Dependency>();
		dbSettings = new HashMap();
		dependencies = new ArrayList();
	}
	
	public boolean loadSettings()
	{
		DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
		DocumentBuilder db;
		Document doc;
		try
		{
			db = dbf.newDocumentBuilder();
		}
		catch (ParserConfigurationException e)
		{
			return false;
		}
		try
		{
			doc = db.parse(fileName);
		}
		catch (IOException e)
		{
			// System.out.println("File not found!");
			return false;
		}
		catch (SAXException e)
		{
			// System.out.println("Error parsing file!");
			return false;
		}
		
		NodeList dbSettings = doc.getElementsByTagName("db");

		if (dbSettings.getLength() == 1)
		{
			loadDBSettings(dbSettings.item(0));
		}
		else
		{
			return false;
		}
		
		
		NodeList dependencies = doc.getElementsByTagName("rule");
		
		if (dependencies.getLength() > 0)
		{
			loadDependencies(dependencies);
		}
		else
		{
			return false;
		}
		
		return true;
	}
	
	private boolean loadDBSettings(Node aRoot)
	{
		NodeList children = aRoot.getChildNodes();
		for (int i = 0; i < children.getLength(); ++i)
		{
			Node child = children.item(i);
			if (child.getNodeType() != Node.ELEMENT_NODE)
			{
				continue;
			}
			dbSettings.put(child.getNodeName(), child.getFirstChild().getNodeValue());		
		}
		return true;
	}
	
	private boolean loadDependencies(NodeList aRules)
	{
		for (int i = 0; i < aRules.getLength(); ++i)
		{
			if (aRules.item(i).getNodeType() == Node.ELEMENT_NODE)
			{
				loadDep(aRules.item(i));
			}
		}
		
		return true;
	}
	
	private boolean loadDep(Node aDep)
	{
		NodeList ruleProperties = aDep.getChildNodes();
		
		int i = 0;
		
		// Get the dependency's type
		while (ruleProperties.item(i).getNodeType() != Node.ELEMENT_NODE)
		{
			++i;
		}
		
		String type = ruleProperties.item(i).getFirstChild().getNodeValue();
		i++;
		
		if (type.equals("fd"))
		{
			// System.out.println("Functional dependency!");
			FDependency fd = new FDependency();
			// Load properties of the dependency
			while (ruleProperties.item(i).getNodeType() != Node.ELEMENT_NODE)
			{
				++i;
			}
			// System.out.println(ruleProperties.item(i).getNodeName());
			// Get the variables on the left-hand side of the dependency
			NodeList leftVars = ruleProperties.item(i).getChildNodes();
			
			// System.out.println("Leftvars: " + leftVars.getLength());

			for (int j = 0; j < leftVars.getLength(); ++j)
			{
				if (leftVars.item(j).getNodeType() != Node.ELEMENT_NODE)
				{
					// System.out.println("Skipping");
					continue;
				}
				// System.out.println(leftVars.item(j).getNodeName());
				String varName = leftVars.item(j).getFirstChild().getNodeValue();
				// System.out.println(varName);
				fd.left.add(varName);
			}
			
			++i;
			
			// Skip text nodes
			while (ruleProperties.item(i).getNodeType() != Node.ELEMENT_NODE)
			{
				++i;
			}
			
			Node rightVar = ruleProperties.item(i);
			String rightVarName = rightVar.getFirstChild().getNodeValue();
			fd.right.add(rightVarName);
			
			dependencies.add(fd);
		}
		else if (type.equals("eq"))
		{
			// System.out.println("Equality-generating dependency!");
			EQDependency eqd = new EQDependency();
			// TODO: load properties of the dependency
			
			// Skip text nodes
			while (ruleProperties.item(i).getNodeType() != Node.ELEMENT_NODE)
			{
				++i;
			}
			
			// Load if-part of dependency
			Node ifNode = ruleProperties.item(i);
			// System.out.println(ifNode.getNodeName());
			++i;
			NodeList ifTerms = ifNode.getChildNodes();
			for (int j = 0; j < ifTerms.getLength(); ++j)
			{
				if (ifTerms.item(j).getNodeType() != Node.ELEMENT_NODE)
				{
					continue;
				}
				Term term = loadTerm(ifTerms.item(j));
				// System.out.println(term.toString());
				eqd.left.add(term);
			}
			
			// Skip text nodes
			while (ruleProperties.item(i).getNodeType() != Node.ELEMENT_NODE)
			{
				++i;
			}

			// Load then-part of dependency
			Node thenNode = ruleProperties.item(i);
			// System.out.println(thenNode.getNodeName());

			NodeList thenTerms = thenNode.getChildNodes();
			for (int j = 0; j < thenTerms.getLength(); ++j)
			{
				if (thenTerms.item(j).getNodeType() != Node.ELEMENT_NODE)
				{
					continue;
				}
				
				Term term = loadTerm(thenTerms.item(j));
				// System.out.println(term.toString());
				eqd.right.add(term);
			}
			dependencies.add(eqd);			
		}

		return true;
	}
	
	/*
	 * 
	 */
	private Term loadTerm(Node aTermNode)
	{
		String left = null;
		String op = null;
		String right = null;

		NodeList termProperties = aTermNode.getChildNodes();
		for (int i = 0; i < termProperties.getLength(); ++i)
		{
			if (termProperties.item(i).getNodeType() != Node.ELEMENT_NODE)
			{
				continue;
			}
			if (termProperties.item(i).getNodeName().equals("left"))
			{
				left = termProperties.item(i).getFirstChild().getNodeValue();
				// System.out.println(left);
			}
			else if (termProperties.item(i).getNodeName().equals("op"))
			{
				op = termProperties.item(i).getFirstChild().getNodeValue();
				// System.out.println(op);
			}
			else // (termProperties.item(i).getNodeName().equals("right"))
			{
				right = termProperties.item(i).getFirstChild().getNodeValue();
				// System.out.println(right);
			}
		}
		if (left == null || op == null || right == null)
		{
			return null;
		}
		
		Term result = new Term(left, op, right);
		return result;
	}
	
	public String getDBSetting(String aParameter)
	{
		if (dbSettings.containsKey(aParameter))
		{
			return dbSettings.get(aParameter).toString();
		}
		return null;
	}
}