jremconfigwriter.java

JRemoteControl is a simple Java&#8482 driven bluetooth remote control.It allows you to initiate virt

package fildiv.jremcntl.server.core;
/*
 * JRemCntl - Copyright (C) 2007 Filippo Di Vattimo <[e-mail]>
 * See COPYING
 */

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.util.Collection;
import java.util.Iterator;
import java.util.Vector;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerConfigurationException;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;

import org.w3c.dom.Document;
import org.w3c.dom.Element;

import fildiv.jremcntl.common.core.Command;
import fildiv.jremcntl.common.core.Config;
import fildiv.jremcntl.common.core.ConfigIntegrityInfo;
import fildiv.jremcntl.common.core.Context;
import fildiv.jremcntl.common.core.Extension;
import fildiv.jremcntl.common.core.JRemRuntimeException;
import fildiv.jremcntl.common.core.Logger;
import fildiv.jremcntl.server.core.JRemPropertyMapper.JRemPropertyValueMapper;

public class JRemConfigWriter {

	private JRemEnv env;
	private Config config;
	private Document xmlDoc = null;
	private JRemPropertyInvoker invoker;
	private JRemPropertyMapper pm;
	private Logger logger;

	public JRemConfigWriter(Config config) {
	
		env = JRemEnv.getInstance();
		
		if (config == null)
			throw new IllegalArgumentException();
		
		ConfigIntegrityInfo cii = config.checkValid();
		if (!cii.isValid())
			throw new JRemRuntimeException(
					"Invalid configuration : " + cii.toString());			
		
		logger = JRemEnv.getInstance().getLogger();
		invoker = new JRemPropertyInvoker();
		pm = env.getPropertiesMapper();
		
		this.config = config;
		
		xmlDoc = buildDocument();
		
	}
	
	public void writeToFile(String filePath) {
		
		OutputStream out = null;
		
		try {
			out = new FileOutputStream(filePath);
			writeXML(xmlDoc, out);
		} catch (Exception e) {
			throw new JRemRuntimeException(e);
			
		} finally {
		
			if (out != null) {
				try {
					out.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
		
	}
	
    public static void writeXML(Document doc, OutputStream os)
    	throws TransformerConfigurationException, TransformerException {

	    DOMSource ds = new DOMSource(doc);
	    StreamResult sr = new StreamResult(os);
	
	    Transformer t = TransformerFactory.newInstance().newTransformer();
		t.setOutputProperty(OutputKeys.ENCODING, "UTF-8");		
		t.setOutputProperty(OutputKeys.INDENT, "yes");
	    t.transform(ds, sr);
    }	

	private Document buildDocument() {
		DocumentBuilderFactory factory =
            DocumentBuilderFactory.newInstance();
		
		try {
			DocumentBuilder db = factory.newDocumentBuilder();
			
			Document doc = db.newDocument();
			Element configElement = doc.createElement("config");
			doc.appendChild(configElement);
			
			writeConfig(doc, configElement);
			
			return doc;
			
		} catch(Exception e) {
			throw new JRemRuntimeException("Parser error", e);
		}
	}

	protected void writeProperties(String objName, Object obj, Element element) {
		
		Collection c = pm.getSupportedProperties(objName);
		
		for (Iterator i = c.iterator(); i.hasNext(); ) {
	
			JRemProperty property = (JRemProperty) i.next();
			JRemPropertyValueMapper pvm = property.getPropertyValueMapper();
			
			try {
				Object clsValue = 
					invoker.invokeGet(property.getClsPropName(), obj);
				
				String name = property.getXmlPropName();
				String value = pvm.toXml(clsValue);
				element.setAttribute(name, value);
				
			} catch(Exception e) {
				logger.error(e);
				throw new JRemRuntimeException(e);
			}
		}
		
	}
	
	private void writeConfig(Document doc, Element configElement) {

		writeProperties(JRemConfigProperties.OBJ_CONFIG_NAME,
				config, configElement);

		writeExtension(doc, config.getExtension(false), configElement);

		Element contextsElement = doc.createElement("contexts");
		configElement.appendChild(contextsElement);
		
		Vector contexts = config.getContexts();
		for (int index = 0; index < contexts.size(); ++index) {
			Context ctx = (Context) contexts.get(index);
			
			writeContext(doc, contextsElement, ctx);	
		}
	}

	private void writeContext(Document doc, Element contextsElement, Context ctx) {

		Element contextElement = doc.createElement("context");
		contextsElement.appendChild(contextElement);
		
		writeProperties(JRemConfigProperties.OBJ_CONTEXT_NAME, 
				ctx, contextElement);
		
		writeExtension(doc, ctx.getExtension(false), contextElement);
		
		Vector commands = ctx.getCommands();
		for (int index = 0; index < commands.size(); ++index) {
			Command command = (Command) commands.get(index);
			
			writeCommand(doc, contextElement, command);			
		}
	}

	private void writeCommand(Document doc, Element contextElement, Command command) {

		Element commandElement = doc.createElement("command");
		contextElement.appendChild(commandElement);

		writeProperties(JRemConfigProperties.OBJ_COMMAND_NAME, 
				command, commandElement);
		writeExtension(doc, command.getExtension(false), commandElement);

	}	

	private void writeExtension(Document doc, Extension ext, Element rootElement) {

		if (ext == null)
			return;

		Element extElem = doc.createElement("extension");
		writeProperties(JRemConfigProperties.OBJ_EXTENSION_NAME, 
				ext, extElem);

		Object extImpl = ext.getImplObj();
		rootElement.appendChild(extElem);
		
		writeProperties(ext.getID(), extImpl, extElem);
	}
}