package com.thalesgroup.mde.m2c.io.xml;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.List;

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

import org.eclipse.core.resources.IFile;
import org.eclipse.core.runtime.CoreException;
import org.w3c.dom.Document;
import org.w3c.dom.Element;

public class CheddarBridge_DOMVisitor extends CheddarBridge_AbstractVisitor {
	private Document cheddarDoc;
	private Element cheddarRoot;
	private Element cacheSystemsRoot;
	private Element coreUnitsRoot;
	private Element addressSpacesRoot;
	private Element processorsRoot;
	private Element tasksRoot;
	private Element messagesRoot;
	private Element buffersRoot;
	private Element resourcesRoot;
	private Element networksRoot;
	private Element dependenciesRoot;
	private Element eventAnalyzersRoot;
	private ArrayList<Element> parents;

	public CheddarBridge_DOMVisitor() {
		super();

		try  {
			DocumentBuilderFactory docFactory = DocumentBuilderFactory.newInstance();
			DocumentBuilder docBuilder = docFactory.newDocumentBuilder();

			cheddarDoc = docBuilder.newDocument();

			cheddarRoot = cheddarDoc.createElement("Cheddar");
			cacheSystemsRoot = cheddarDoc.createElement("Cache_Systems");
			coreUnitsRoot = cheddarDoc.createElement("Core_Units");
			addressSpacesRoot = cheddarDoc.createElement("Address_Spaces");
			processorsRoot = cheddarDoc.createElement("Processors");
			tasksRoot = cheddarDoc.createElement("Tasks");
			messagesRoot = cheddarDoc.createElement("Messages");
			buffersRoot = cheddarDoc.createElement("Buffers");
			resourcesRoot = cheddarDoc.createElement("Resources");
			networksRoot = cheddarDoc.createElement("Networks");
			dependenciesRoot = cheddarDoc.createElement("Dependencies");
			eventAnalyzersRoot = cheddarDoc.createElement("Event_Analyzers");

			cheddarDoc.appendChild(cheddarRoot);
			cheddarRoot.appendChild(cacheSystemsRoot);
			cheddarRoot.appendChild(coreUnitsRoot);
			cheddarRoot.appendChild(addressSpacesRoot);
			cheddarRoot.appendChild(processorsRoot);
			cheddarRoot.appendChild(tasksRoot);
			cheddarRoot.appendChild(messagesRoot);
			cheddarRoot.appendChild(buffersRoot);
			cheddarRoot.appendChild(resourcesRoot);
			cheddarRoot.appendChild(networksRoot);
			cheddarRoot.appendChild(dependenciesRoot);
			cheddarRoot.appendChild(eventAnalyzersRoot);

			parents = new ArrayList<Element>();
		} catch (Exception e) {System.err.println(e.getMessage());}
	}

	public void toXMLFile(File file) {
		try {
			TransformerFactory transformerFactory = TransformerFactory.newInstance();
			Transformer transformer = transformerFactory.newTransformer();
			DOMSource source = new DOMSource(cheddarDoc);
			StreamResult result = new StreamResult(file);
			transformer.setOutputProperty(OutputKeys.INDENT, "yes");
			transformer.transform(source, result);
		} catch (Exception e) {}
	}

	public void toXMLFile(String fileName) {
		this.toXMLFile(new File(fileName));
	}

	public void toXMLFile(OutputStream stream) {
		try {
			TransformerFactory transformerFactory = TransformerFactory.newInstance();
			Transformer transformer = transformerFactory.newTransformer();
			DOMSource source = new DOMSource(cheddarDoc);
			StreamResult result = new StreamResult(stream);
			transformer.transform(source, result);
		} catch (Exception e) {}
	}
	
	public void toXMLFile(IFile theFile) {
		ByteArrayOutputStream outputStream = new ByteArrayOutputStream();

		try
		{
			TransformerFactory factory = TransformerFactory.newInstance();
			Transformer transformer = factory.newTransformer();

			transformer.setOutputProperty(OutputKeys.METHOD, "xml");
			transformer.setOutputProperty(OutputKeys.ENCODING, "UTF-8");
			transformer.setOutputProperty(OutputKeys.INDENT, "yes");
			transformer.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "4");

			PrintWriter writer = new PrintWriter(outputStream);
			StreamResult result = new StreamResult(writer);
			
			transformer.transform(new DOMSource(cheddarDoc), result);

			writer.flush();
		} catch (Exception e) {}
		
		InputStream source = new ByteArrayInputStream(outputStream.toByteArray());
		
		if (theFile.exists()) {
			try {
				theFile.setContents(source, true, true, null);
			} catch (CoreException e) {}
		} else {
			try {
				theFile.create(source, true, null);
			} catch (CoreException e) {}
		}
	}

	@Override
	public void accept(Generic_Object e) {
		super.accept(e);

		Element object = null;

		if (!parents.isEmpty()) {
			object = parents.remove(parents.size() - 1);
		} else {
			object = cheddarDoc.createElement("Generic_Object");
		}

		object.setAttribute("id", e.getName());
		this.buildXMLNode(object, "name", e.getName());
		this.buildXMLNode(object, "object_type", e.getObjectType());
	}

	@Override
	public void accept(Offset_Type e) {
		super.accept(e);
		
		Element offset = cheddarDoc.createElement("offset_type");
		
		this.buildXMLNode(offset, "offset_value", e.getOffsetValue());
		this.buildXMLNode(offset, "activation", e.getActivation());

		Element parent = parents.remove(parents.size() - 1);
		parent.appendChild(offset);
	}

	@Override
	public void accept(Generic_Cache e) {
		super.accept(e);
		
		Element cache = null;

		if (!parents.isEmpty() && (parents.get(parents.size() - 1).getNodeName().equalsIgnoreCase("Data_Cache") 
				|| parents.get(parents.size() - 1).getNodeName().equalsIgnoreCase("Instruction_Cache")
				|| parents.get(parents.size() - 1).getNodeName().equalsIgnoreCase("Data_Instruction_Cache"))) {
			cache = parents.get(parents.size() - 1);
		} else {
			cache = cheddarDoc.createElement("generic_cache");
			parents.add(cache);
		}
		
		// Legacy properties
		this.accept((Generic_Object) e);
		
		this.buildXMLNode(cache, "number_of_block", e.getNumberOfBlock());
		this.buildXMLNode(cache, "block_size", e.getBlockSize());
		this.buildXMLNode(cache, "associativity", e.getAssociativity());
		this.buildXMLNode(cache, "cache_replacement", e.getCacheReplacement());

		Element parent = parents.remove(parents.size() - 1);
		parent.appendChild(cache);
	}

	@Override
	public void accept(Data_Cache e) {
		super.accept(e);
		
		Element dataCache = null;

		if (!parents.isEmpty() && (parents.get(parents.size() - 1).getNodeName().equalsIgnoreCase("Data_Instruction_Cache"))) {
			dataCache = parents.get(parents.size() - 1);
		} else {
			dataCache = cheddarDoc.createElement("data_cache");
			parents.add(dataCache);
		}

		// Legacy properties
		this.accept((Generic_Cache) e);
		
		this.buildXMLNode(dataCache, "write_policy", e.getWritePolicy());
	}

	@Override
	public void accept(Data_Instruction_Cache e) {
		super.accept(e);
		
		Element dataInstructionCache = cheddarDoc.createElement("data_instruction_cache");
		
		// Legacy properties
		parents.add(dataInstructionCache);
		this.accept((Data_Cache) e);
	}

	@Override
	public void accept(Instruction_Cache e) {
		super.accept(e);
		
		Element instructionCache = cheddarDoc.createElement("instruction_cache");
		
		// Legacy properties
		parents.add(instructionCache);
		this.accept((Generic_Cache) e);
	}

	@Override
	public void accept(Cache_System e) {
		super.accept(e);
		
		Element cacheSystem = cheddarDoc.createElement("Cache_System");
		
		// Legacy properties
		parents.add(cacheSystem);
		this.accept((Generic_Object) e);
		
		Element caches = this.buildXMLNode(cacheSystem, "caches", "");
		for (Generic_Cache cache : e.getCaches()) {
			parents.add(caches);
			
			if (cache instanceof Data_Instruction_Cache) {
				this.accept((Data_Instruction_Cache) cache);
			} else if (cache instanceof Data_Cache) {
				this.accept((Data_Cache) cache);
			} else if (cache instanceof Instruction_Cache) {
				this.accept((Instruction_Cache) cache);
			} else {
				this.accept(cache);
			}
		}
		cacheSystem.appendChild(caches);
		
		cacheSystemsRoot.appendChild(cacheSystem);
	}

	@Override
	public void accept(Core_Unit e) {
		super.accept(e);

		Element coreUnit = cheddarDoc.createElement("Core_Unit");

		// Legacy properties
		parents.add(coreUnit);
		this.accept((Generic_Object) e);

		// scheduling
		Generic_Scheduler scheduler = new Generic_Scheduler();
		scheduler.setParameters(e.getScheduling());
		parents.add(coreUnit);
		this.accept(scheduler);

		this.buildXMLNode(coreUnit, "speed", e.getSpeed());
		this.buildXMLNode(coreUnit, "l1_cache_system_name", e.getL1CacheSystemName());

		coreUnitsRoot.appendChild(coreUnit);
	}

	@Override
	public void accept(Generic_Processor e) {
		super.accept(e);

		Element processor = null;

		if (!parents.isEmpty() && (parents.get(parents.size() - 1).getNodeName().equalsIgnoreCase("Mono_Core_Processor") || parents.get(parents.size() - 1).getNodeName().equalsIgnoreCase("Multi_Cores_Processor"))) {
			processor = parents.get(parents.size() - 1);
		} else {
			processor = cheddarDoc.createElement("Generic_Processor");
			parents.add(processor);
		}

		// Legacy properties
		this.accept((Generic_Object) e);

		this.buildXMLNode(processor, "network", e.getNetwork());
		this.buildXMLNode(processor, "processor_type", e.getProcessorType());
		this.buildXMLNode(processor, "migration_type", e.getMigrationType());
		
		processorsRoot.appendChild(processor);
	}

	@Override
	public void accept(Mono_Core_Processor e) {
		super.accept(e);

		Element monoCoreProcessor = cheddarDoc.createElement("Mono_Core_Processor");

		// Legacy properties
		parents.add(monoCoreProcessor);
		this.accept((Generic_Processor) e);

		this.buildXMLNode(monoCoreProcessor, "core", e.getCore());
	}

	@Override
	public void accept(Multi_Cores_Processor e) {
		super.accept(e);

		Element multiCoresProcessor = cheddarDoc.createElement("Multi_Cores_Processor");

		// Legacy properties
		parents.add(multiCoresProcessor);
		this.accept((Generic_Processor) e);

		// List property
		Element cores = this.buildXMLNode(multiCoresProcessor, "cores", "");
		this.buildXMLNode(cores, "core", e.getCores());
		
		this.buildXMLNode(multiCoresProcessor, "l2_cache_system_name", e.getL2CacheSystemName());
	}

	@Override
	public void accept(Buffer_Role e) {
		super.accept(e);
		
		Element param = cheddarDoc.createElement("Buffer_Role");
		
		this.buildXMLNode(param, "the_role", e.getTheRole());
		this.buildXMLNode(param, "size", e.getSize());
		this.buildXMLNode(param, "time", e.getTime());

		Element parent = parents.remove(parents.size() - 1);
		parent.appendChild(param);
	}

	@Override
	public void accept(Buffer e) {
		super.accept(e);

		Element buffer = cheddarDoc.createElement("Buffer");

		// Legacy properties
		parents.add(buffer);
		this.accept((Generic_Object) e);

		this.buildXMLNode(buffer, "cpu_name", e.getCpuName());
		this.buildXMLNode(buffer, "address_space_name", e.getAddressSpaceName());
		this.buildXMLNode(buffer, "queueing_system_type", e.getQueueingSystemType());
		this.buildXMLNode(buffer, "size", e.getSize());
		
		Element rolesList = this.buildXMLNode(buffer, "roles", "");
		for (Buffer_Role role : e.getRoles()) {
			parents.add(rolesList);
			this.accept(role);
		}
		buffer.appendChild(rolesList);
		
		this.buildXMLNode(buffer, "x", e.getX());
		this.buildXMLNode(buffer, "y", e.getY());
		
		buffersRoot.appendChild(buffer);
	}

	@Override
	public void accept(Affected_Task_Lists e) {
		super.accept(e);
		
		Element data = cheddarDoc.createElement("data");
		
		this.buildXMLNode(data, "task_begin", e.getTaskBegin());
		this.buildXMLNode(data, "task_end", e.getTaskEnd());
		
		Element parent = parents.remove(parents.size() - 1);
		parent.appendChild(data);
	}

	@Override
	public void accept(Task_List_Element e) {
		super.accept(e);
		
		Element taskListElt = cheddarDoc.createElement("task_list_element");
		
		taskListElt.setTextContent(e.getIndex());
		this.buildXMLNode(taskListElt, "index", e.getIndex());
		
		parents.add(taskListElt);
		this.accept(e.getData());
		
		Element parent = parents.remove(parents.size() - 1);
		parent.appendChild(taskListElt);
	}

	@Override
	public void accept(Generic_Resource e) {
		super.accept(e);

		Element resource = null;

		if (!parents.isEmpty() && (parents.get(parents.size() - 1).getNodeName().equalsIgnoreCase("Np_Resource") 
				|| parents.get(parents.size() - 1).getNodeName().equalsIgnoreCase("Priority_Constrained_Resource")
				|| parents.get(parents.size() - 1).getNodeName().equalsIgnoreCase("IPcp_Resource")
				|| parents.get(parents.size() - 1).getNodeName().equalsIgnoreCase("Pcp_Resource")
				|| parents.get(parents.size() - 1).getNodeName().equalsIgnoreCase("Pip_Resource"))) {
			resource = parents.get(parents.size() - 1);
		} else {
			resource = cheddarDoc.createElement("Generic_Resource");
			parents.add(resource);
		}

		// Legacy properties
		this.accept((Generic_Object) e);
		
		this.buildXMLNode(resource, "state", e.getState());
		this.buildXMLNode(resource, "size", e.getSize());
		this.buildXMLNode(resource, "address", e.getAddress());
		this.buildXMLNode(resource, "protocol", e.getProtocol());
		
		Element taskTab = this.buildXMLNode(resource, "task_tab", "");
		for (Task_List_Element taskListElt : e.getTaskTab()) {
			parents.add(taskTab);
			this.accept(taskListElt);
		}
		resource.appendChild(taskTab);
		
		this.buildXMLNode(resource, "cpu_name", e.getCpuName());
		this.buildXMLNode(resource, "address_space_name", e.getAddressSpaceName());
		
		resourcesRoot.appendChild(resource);
	}

	@Override
	public void accept(Np_Resource e) {
		super.accept(e);
		
		Element npResource = cheddarDoc.createElement("Np_Resource");

		// Legacy properties
		parents.add(npResource);
		this.accept((Generic_Resource) e);
	}

	@Override
	public void accept(Priority_Constrained_Resource e) {
		super.accept(e);
		
		Element priorityConstrainedResource = null;

		if (!parents.isEmpty() && (parents.get(parents.size() - 1).getNodeName().equalsIgnoreCase("Pip_Resource")
				|| parents.get(parents.size() - 1).getNodeName().equalsIgnoreCase("Pcp_Resource")
				|| parents.get(parents.size() - 1).getNodeName().equalsIgnoreCase("IPcp_Resource"))) {
			priorityConstrainedResource = parents.get(parents.size() - 1);
		} else {
			priorityConstrainedResource = cheddarDoc.createElement("Priority_Constrained_Resource");
			parents.add(priorityConstrainedResource);
		}
		
		// Legacy properties
		this.accept((Generic_Resource) e);
		
		this.buildXMLNode(priorityConstrainedResource, "ceiling_priority", e.getCeilingPriority());
	}

	@Override
	public void accept(Pip_Resource e) {
		super.accept(e);
		
		Element pipResource = cheddarDoc.createElement("Pip_Resource");
		
		// Legacy properties
		parents.add(pipResource);
		this.accept((Priority_Constrained_Resource) e);
	}

	@Override
	public void accept(Pcp_Resource e) {
		super.accept(e);
		
		Element pcpResource = cheddarDoc.createElement("Pcp_Resource");
		
		// Legacy properties
		parents.add(pcpResource);
		this.accept((Priority_Constrained_Resource) e);
	}

	@Override
	public void accept(IPcp_Resource e) {
		super.accept(e);
		
		Element ipipResource = cheddarDoc.createElement("IPcp_Resource");
		
		// Legacy properties
		parents.add(ipipResource);
		this.accept((Priority_Constrained_Resource) e);
	}

	@Override
	public void accept(Generic_Task e) {
		super.accept(e);

		Element task = null;

		if (!parents.isEmpty() && (parents.get(parents.size() - 1).getNodeName().equalsIgnoreCase("Aperiodic_Task") 
				|| parents.get(parents.size() - 1).getNodeName().equalsIgnoreCase("Periodic_Task")
				|| parents.get(parents.size() - 1).getNodeName().equalsIgnoreCase("Poisson_Task")
				|| parents.get(parents.size() - 1).getNodeName().equalsIgnoreCase("Parametric_Task")
				|| parents.get(parents.size() - 1).getNodeName().equalsIgnoreCase("Sporadic_Task"))) {
			task = parents.get(parents.size() - 1);
		} else {
			task = cheddarDoc.createElement("Generic_Task");
			parents.add(task);
		}

		// Legacy properties
		this.accept((Generic_Object) e);
		
		this.buildXMLNode(task, "task_type", e.getTaskType());
		this.buildXMLNode(task, "cpu_name", e.getCpuName());
		this.buildXMLNode(task, "address_space_name", e.getAddressSpaceName());
		this.buildXMLNode(task, "capacity", e.getCapacity());
		this.buildXMLNode(task, "deadline", e.getDeadline());
		this.buildXMLNode(task, "start_time", e.getStartTime());
		this.buildXMLNode(task, "priority", e.getPriority());
		this.buildXMLNode(task, "blocking_time", e.getBlockingTime());
		this.buildXMLNode(task, "policy", e.getPolicy());
		this.buildXMLNode(task, "x", e.getX());
		this.buildXMLNode(task, "y", e.getY());
		
		Element offsetList = this.buildXMLNode(task, "offset", "");
		for (Offset_Type offset : e.getOffset()) {
			parents.add(offsetList);
			this.accept(offset);
		}
		task.appendChild(offsetList);
		
		this.buildXMLNode(task, "text_memory_size", e.getTextMemorySize());
		this.buildXMLNode(task, "stack_memory_size", e.getStackMemorySize());
		
		Element paramList = this.buildXMLNode(task, "param", "");
		for (Parameter param : e.getParam()) {
			parents.add(paramList);
			this.accept(param);
		}
		task.appendChild(paramList);
		
		this.buildXMLNode(task, "criticality", e.getCriticality());
		this.buildXMLNode(task, "context_switch_overhead", e.getContextSwitchOverhead());

		tasksRoot.appendChild(task);
	}

	@Override
	public void accept(Periodic_Task e) {
		super.accept(e);
		
		Element periodicTask = null;

		if (!parents.isEmpty() && (parents.get(parents.size() - 1).getNodeName().equalsIgnoreCase("Poisson_Task")
				|| parents.get(parents.size() - 1).getNodeName().equalsIgnoreCase("Parametric_Task")
				|| parents.get(parents.size() - 1).getNodeName().equalsIgnoreCase("Sporadic_Task"))) {
			periodicTask = parents.get(parents.size() - 1);
		} else {
			periodicTask = cheddarDoc.createElement("Periodic_Task");
			parents.add(periodicTask);
		}
		
		// Legacy properties
		this.accept((Generic_Task) e);
		
		this.buildXMLNode(periodicTask, "period", e.getPeriod());
		this.buildXMLNode(periodicTask, "jitter", e.getJitter());
	}

	@Override
	public void accept(Aperiodic_Task e) {
		super.accept(e);
		
		Element aperiodicTask = null;
		
		if (!parents.isEmpty() && (parents.get(parents.size() - 1).getNodeName().equalsIgnoreCase("Poisson_Task")
				|| parents.get(parents.size() - 1).getNodeName().equalsIgnoreCase("Parametric_Task")
				|| parents.get(parents.size() - 1).getNodeName().equalsIgnoreCase("Sporadic_Task"))) {
			aperiodicTask = parents.get(parents.size() - 1);
		} else {
			aperiodicTask = cheddarDoc.createElement("Aperiodic_Task");
			parents.add(aperiodicTask);
		}
		
		// Legacy properties
		this.accept((Generic_Task) e);
	}

	@Override
	public void accept(Poisson_Task e) {
		super.accept(e);
		
		Element poissonTask = null;
		
		if (!parents.isEmpty() && (parents.get(parents.size() - 1).getNodeName().equalsIgnoreCase("Parametric_Task")
				|| parents.get(parents.size() - 1).getNodeName().equalsIgnoreCase("Sporadic_Task"))) {
			poissonTask = parents.get(parents.size() - 1);
		} else {
			poissonTask = cheddarDoc.createElement("Poisson_Task");
			parents.add(poissonTask);
		}
		
		// Legacy properties
		this.accept((Periodic_Task) e);
		
		this.buildXMLNode(poissonTask, "seed", e.getSeed());
		this.buildXMLNode(poissonTask, "preditable", e.getPredictable());
	}

	@Override
	public void accept(Sporadic_Task e) {
		super.accept(e);
		
		Element parametricTask = cheddarDoc.createElement("Sporadic_Task");
		
		// Legacy properties
		parents.add(parametricTask);
		this.accept((Poisson_Task) e);
	}

	@Override
	public void accept(Parametric_Task e) {
		super.accept(e);
		
		Element parametricTask = cheddarDoc.createElement("Parametric_Task");
		
		// Legacy properties
		parents.add(parametricTask);
		this.accept((Poisson_Task) e);
		
		this.buildXMLNode(parametricTask, "activation_rule", e.getActivationRule());
	}

	@Override
	public void accept(Generic_Message e) {
		super.accept(e);

		Element message = null;

		if (!parents.isEmpty() && (parents.get(parents.size() - 1).getNodeName().equalsIgnoreCase("Aperiodic_Message") 
				|| parents.get(parents.size() - 1).getNodeName().equalsIgnoreCase("Periodic_Message"))) {
			message = parents.get(parents.size() - 1);
		} else {
			message = cheddarDoc.createElement("Generic_Task");
			parents.add(message);
		}

		// Legacy properties
		this.accept((Generic_Object) e);
		
		this.buildXMLNode(message, "message_type", e.getMessageType());
		this.buildXMLNode(message, "x", e.getX());
		this.buildXMLNode(message, "y", e.getY());
		
		Element paramList = this.buildXMLNode(message, "param", "");
		for (Parameter param : e.getParam()) {
			parents.add(paramList);
			this.accept(param);
		}
		message.appendChild(paramList);
		
		this.buildXMLNode(message, "deadline", e.getDeadline());
		this.buildXMLNode(message, "size", e.getSize());
		this.buildXMLNode(message, "response_time", e.getResponseTime());
		this.buildXMLNode(message, "communication_time", e.getCommunicationTime());
		
		messagesRoot.appendChild(message);
	}

	@Override
	public void accept(Periodic_Message e) {
		super.accept(e);
		
		Element periodicMessage = cheddarDoc.createElement("Periodic_Message");
		
		// Legacy properties
		parents.add(periodicMessage);
		this.accept((Generic_Message) e);
		
		this.buildXMLNode(periodicMessage, "period", e.getPeriod());
		this.buildXMLNode(periodicMessage, "jitter", e.getJitter());
	}

	@Override
	public void accept(Aperiodic_Message e) {
		super.accept(e);
		
		Element aperiodicMessage = cheddarDoc.createElement("Aperiodic_Message");
		
		// Legacy properties
		parents.add(aperiodicMessage);
		this.accept((Generic_Message) e);
	}

	@Override
	public void accept(Synchronous_Data_Flow_Dependency_type e) {
		super.accept(e);
		
		Element dependency = parents.remove(parents.size() - 1);
		
		this.buildXMLNode(dependency, "synchronous_data_flow_sink", e.getSynchronousDataFlowSink());
		this.buildXMLNode(dependency, "synchronous_data_flow_source", e.getSynchronousDataFlowSource());
		this.buildXMLNode(dependency, "timing_property", e.getTimingProperty());
	}

	@Override
	public void accept(Precedence_Dependency_type e) {
		super.accept(e);
		
		Element dependency = parents.remove(parents.size() - 1);
		
		this.buildXMLNode(dependency, "precedence_sink", e.getPrecedenceSink());
		this.buildXMLNode(dependency, "precedence_source", e.getPrecedenceSource());
	}

	@Override
	public void accept(Buffer_Dependency_type e) {
		super.accept(e);
		
		Element dependency = parents.remove(parents.size() - 1);
		
		this.buildXMLNode(dependency, "buffer_dependent_task", e.getBufferDependentTask());
		this.buildXMLNode(dependency, "buffer_orientation", e.getBufferOrientation());
		this.buildXMLNode(dependency, "buffer_dependency_object", e.getBufferDependencyObject());
	}

	@Override
	public void accept(Resource_Dependency_Type e) {
		super.accept(e);
		
		Element dependency = parents.remove(parents.size() - 1);
		
		this.buildXMLNode(dependency, "resource_dependency_resource", e.getResourceDependencyResource());
		this.buildXMLNode(dependency, "resource_dependency_task", e.getResourceDependencyTask());
	}

	@Override
	public void accept(Communication_Dependency_type e) {
		super.accept(e);
		
		Element dependency = parents.remove(parents.size() - 1);
		
		this.buildXMLNode(dependency, "communication_task", e.getCommunicationDependentTask());
		this.buildXMLNode(dependency, "communication_orientation", e.getCommunicationOrientation());
		this.buildXMLNode(dependency, "communication_dependency_object", e.getCommunicationDependencyObject());
	}

	@Override
	public void accept(Dependency_Union e) {
		super.accept(e);
		
		if (e.getBufferDependency() != null) {
			this.accept(e.getBufferDependency());
		} else if (e.getCommunicationDependency() != null) {
			this.accept(e.getCommunicationDependency());
		} else if (e.getPrecedenceDependency() != null) {
			this.accept(e.getPrecedenceDependency());
		} else if (e.getResourceDependency() != null) {
			this.accept(e.getResourceDependency());
		} else if (e.getSynchronousDataFlowDependency() != null) {
			this.accept(e.getSynchronousDataFlowDependency());
		}
	}

	@Override
	public void accept(Dependency e) {
		super.accept(e);
		
		Element dependency = cheddarDoc.createElement("dependency");
		
		dependency.setAttribute("dependency_type", e.getPtype().name());
		
		parents.add(dependency);
		this.accept(e.getUnion());

		dependenciesRoot.appendChild(dependency);
	}

	@Override
	public void accept(Address_Space e) {
		super.accept(e);

		Element addressSpace = cheddarDoc.createElement("Address_Space");
		addressSpace.setAttribute("id", e.getName());

		// Legacy properties
		parents.add(addressSpace);
		this.accept((Generic_Object) e);

		// cpu_name
		this.buildXMLNode(addressSpace, "cpu_name", e.getCpuName());

		// text_memory_size
		this.buildXMLNode(addressSpace, "text_memory_size", e.getTextMemorySize());

		// stack_memory_size
		this.buildXMLNode(addressSpace, "stack_memory_size", e.getStackMemorySize());

		// data_memory_size
		this.buildXMLNode(addressSpace, "data_memory_size", e.getDataMemorySize());

		// heap_memory_size
		this.buildXMLNode(addressSpace, "heap_memory_size", e.getHeapMemorySize());

		// scheduling
		Generic_Scheduler scheduler = new Generic_Scheduler();
		scheduler.setParameters(e.getScheduling());
		parents.add(addressSpace);
		this.accept(scheduler);

		addressSpacesRoot.appendChild(addressSpace);
	}

	@Override
	public void accept(Network e) {
		super.accept(e);
		
		Element network = cheddarDoc.createElement("Network");
		
		// Legacy properties
		parents.add(network);
		this.accept((Generic_Object) e);
		
		this.buildXMLNode(network, "network_type", e.getNetworkType());
		
		networksRoot.appendChild(network);
	}

	@Override
	public void accept(Start_Of_Task_Capacity_Type e) {
		// TODO Auto-generated method stub
		super.accept(e);
	}

	@Override
	public void accept(End_Of_Task_Capacity_Type e) {
		// TODO Auto-generated method stub
		super.accept(e);
	}

	@Override
	public void accept(Write_To_Buffer_Type e) {
		// TODO Auto-generated method stub
		super.accept(e);
	}

	@Override
	public void accept(Read_From_Buffer_Type e) {
		// TODO Auto-generated method stub
		super.accept(e);
	}

	@Override
	public void accept(Context_Switch_Overhead_Type e) {
		// TODO Auto-generated method stub
		super.accept(e);
	}

	@Override
	public void accept(Running_Task_Type e) {
		// TODO Auto-generated method stub
		super.accept(e);
	}

	@Override
	public void accept(Task_Activation_Type e) {
		// TODO Auto-generated method stub
		super.accept(e);
	}

	@Override
	public void accept(Allocate_Resource_Type e) {
		// TODO Auto-generated method stub
		super.accept(e);
	}

	@Override
	public void accept(Release_Resource_Type e) {
		// TODO Auto-generated method stub
		super.accept(e);
	}

	@Override
	public void accept(Wait_For_Resource_Type e) {
		// TODO Auto-generated method stub
		super.accept(e);
	}

	@Override
	public void accept(Send_Message_Type e) {
		// TODO Auto-generated method stub
		super.accept(e);
	}

	@Override
	public void accept(Receive_Message_Type e) {
		// TODO Auto-generated method stub
		super.accept(e);
	}

	@Override
	public void accept(Time_Unit_Event_Union e) {
		// TODO Auto-generated method stub
		super.accept(e);
	}

	@Override
	public void accept(Time_Unit_Event e) {
		// TODO Auto-generated method stub
		super.accept(e);
	}

	@Override
	public void accept(Generic_Scheduler e) {
		super.accept(e);

		Element scheduler = cheddarDoc.createElement("scheduler");
		//scheduler.setAttribute("type", e.getParameters().getSchedulerType().toString());
		scheduler.setAttribute("type", "Generic_Scheduler");

		// parameters
		parents.add(scheduler);
		this.accept(e.getParameters());

		Element parent = parents.remove(parents.size() - 1);
		parent.appendChild(scheduler);
	}

	@Override
	public void accept(Aperiodic_Task_Server_Protocol e) {
		// TODO Auto-generated method stub
		super.accept(e);
	}

	@Override
	public void accept(Polling_Server_Protocol e) {
		// TODO Auto-generated method stub
		super.accept(e);
	}

	@Override
	public void accept(Deferred_Server_Protocol e) {
		// TODO Auto-generated method stub
		super.accept(e);
	}

	@Override
	public void accept(Sporadic_Server_Protocol e) {
		// TODO Auto-generated method stub
		super.accept(e);
	}

	@Override
	public void accept(Hierarchical_Protocol e) {
		// TODO Auto-generated method stub
		super.accept(e);
	}

	@Override
	public void accept(Compiled_User_Defined_Protocol e) {
		// TODO Auto-generated method stub
		super.accept(e);
	}

	@Override
	public void accept(Automata_User_Defined_Protocol e) {
		// TODO Auto-generated method stub
		super.accept(e);
	}

	@Override
	public void accept(Pipeline_User_Defined_Protocol e) {
		// TODO Auto-generated method stub
		super.accept(e);
	}

	@Override
	public void accept(User_Defined_Protocol e) {
		// TODO Auto-generated method stub
		super.accept(e);
	}

	@Override
	public void accept(Earliest_Deadline_First_Protocol e) {
		// TODO Auto-generated method stub
		super.accept(e);
	}

	@Override
	public void accept(Least_Laxity_First_Protocol e) {
		// TODO Auto-generated method stub
		super.accept(e);
	}

	@Override
	public void accept(Rate_Monotonic_Protocol e) {
		// TODO Auto-generated method stub
		super.accept(e);
	}

	@Override
	public void accept(Deadline_Monotonic_Protocol e) {
		// TODO Auto-generated method stub
		super.accept(e);
	}

	@Override
	public void accept(Round_Robin_Protocol e) {
		// TODO Auto-generated method stub
		super.accept(e);
	}

	@Override
	public void accept(Time_Sharing_Based_On_Wait_Time_Protocol e) {
		// TODO Auto-generated method stub
		super.accept(e);
	}

	@Override
	public void accept(Posix_1003_Highest_Priority_First_Protocol e) {
		// TODO Auto-generated method stub
		super.accept(e);
	}

	@Override
	public void accept(D_Over_Protocol e) {
		// TODO Auto-generated method stub
		super.accept(e);
	}

	@Override
	public void accept(Maximum_Urgency_First_Based_On_Laxity_Protocol e) {
		// TODO Auto-generated method stub
		super.accept(e);
	}

	@Override
	public void accept(Maximum_Urgency_First_Based_On_Deadline_Protocol e) {
		// TODO Auto-generated method stub
		super.accept(e);
	}

	@Override
	public void accept(Time_Sharing_Based_On_Cpu_Usage_Protocol e) {
		// TODO Auto-generated method stub
		super.accept(e);
	}

	@Override
	public void accept(No_Scheduling_Protocol e) {
		// TODO Auto-generated method stub
		super.accept(e);
	}

	@Override
	public void accept(Hierarchical_Cyclic_Protocol e) {
		// TODO Auto-generated method stub
		super.accept(e);
	}

	@Override
	public void accept(Hierarchical_Round_Robin_Protocol e) {
		// TODO Auto-generated method stub
		super.accept(e);
	}

	@Override
	public void accept(Hierarchical_Fixed_Priority_Protocol e) {
		// TODO Auto-generated method stub
		super.accept(e);
	}

	@Override
	public void accept(Fixed_Priority_Protocol e) {
		// TODO Auto-generated method stub
		super.accept(e);
	}

	@Override
	public void accept(Dynamic_Priority_Protocol e) {
		// TODO Auto-generated method stub
		super.accept(e);
	}

	@Override
	public void accept(Scheduling_Parameters e) {
		super.accept(e);

		Element scheduler = parents.remove(parents.size() - 1);

		this.buildXMLNode(scheduler, "scheduler_type", e.getSchedulerType());
		this.buildXMLNode(scheduler, "quantum", e.getQuantum());
		this.buildXMLNode(scheduler, "preemptive_type", e.getPreemptiveType());
		this.buildXMLNode(scheduler, "automaton_name", e.getAutomatonName());
		this.buildXMLNode(scheduler, "capacity", e.getCapacity());
		this.buildXMLNode(scheduler, "period", e.getPeriod());
		this.buildXMLNode(scheduler, "priority", e.getPriority());
		this.buildXMLNode(scheduler, "user_defined_scheduler_source", e.getUserDefinedSchedulerSource());
		this.buildXMLNode(scheduler, "user_defined_scheduler_source_file_name", e.getUserDefinedSchedulerSourceFileName());
		this.buildXMLNode(scheduler, "start_time", e.getStartTime());
	}

	@Override
	public void accept(Boolean_Parameter_Type e) {
		super.accept(e);
		
		Element param = parents.remove(parents.size() - 1);

		this.buildXMLNode(param, "boolean_value", e.getBooleanValue());
	}

	@Override
	public void accept(Integer_Parameter_Type e) {
		super.accept(e);
		
		Element param = parents.remove(parents.size() - 1);

		this.buildXMLNode(param, "integer_value", e.getIntegerValue());
	}

	@Override
	public void accept(Double_Parameter_Type e) {
		super.accept(e);
		
		Element param = parents.remove(parents.size() - 1);

		this.buildXMLNode(param, "double_value", e.getDoubleValue());
	}

	@Override
	public void accept(String_Parameter_Type e) {
		super.accept(e);
		
		Element param = parents.remove(parents.size() - 1);

		this.buildXMLNode(param, "string_value", e.getStringValue());
	}

	@Override
	public void accept(Parameter_Union e) {
		super.accept(e);
		
		if (e.getBooleanParameter() != null) {
			this.accept(e.getBooleanParameter());
		} else if (e.getDoubleParameter() != null) {
			this.accept(e.getDoubleParameter());
		} else if (e.getIntegerParameter() != null) {
			this.accept(e.getIntegerParameter());
		} else if (e.getStringParameter() != null) {
			this.accept(e.getStringParameter());
		}
	}

	@Override
	public void accept(Parameter e) {
		super.accept(e);
		
		Element param = cheddarDoc.createElement("parameter");
		
		parents.add(param);
		this.accept(e.getUnion());
		
		this.buildXMLNode(param, "name", e.getName());

		Element parent = parents.remove(parents.size() - 1);
		parent.appendChild(param);
	}

	@Override
	public void accept(Framework_Request e) {
		// TODO Auto-generated method stub
		super.accept(e);
	}

	@Override
	public void accept(Framework_Response e) {
		// TODO Auto-generated method stub
		super.accept(e);
	}

	@Override
	public void accept(Binding_Record_Type e) {
		// TODO Auto-generated method stub
		super.accept(e);
	}

	@Override
	public void accept(Event_Analyzer e) {
		super.accept(e);

		Element eventAnalyzer = cheddarDoc.createElement("Event_Analyzer");
		eventAnalyzer.setAttribute("parametric_file_name", e.getName());

		eventAnalyzersRoot.appendChild(eventAnalyzer);
	}

	/* Implementation methods */

	private Element buildXMLNode(Element parent, String nodeName, Integer value) {
		return buildXMLNode(parent, nodeName, value.toString());
	}

	private Element buildXMLNode(Element parent, String nodeName, Double value) {
		return buildXMLNode(parent, nodeName, value.toString());
	}

	@SuppressWarnings({ "rawtypes" })
	private Element buildXMLNode(Element parent, String nodeName, Enum value) {
		return buildXMLNode(parent, nodeName, value.name());
	}
	
	private Element buildXMLNode(Element parent, String nodeName, Boolean value) {
		return buildXMLNode(parent, nodeName, value.toString());
	}

	private Element buildXMLNode(Element parent, String nodeName, String value) {
		Element xmlElement = cheddarDoc.createElement(nodeName);
		xmlElement.appendChild(cheddarDoc.createTextNode(value));
		parent.appendChild(xmlElement);
		return xmlElement;
	}

	private Element buildXMLNode(Element parent, String nodeName, Generic_Object reference) {
		Element xmlElement = cheddarDoc.createElement(nodeName);
		xmlElement.setAttribute("ref", reference.getName());
		parent.appendChild(xmlElement);
		return xmlElement;
	}

	@SuppressWarnings("rawtypes")
	private void buildXMLNode(Element parent, String nodeName, List references) {
		for (Object object : references) {
			this.buildXMLNode(parent, nodeName, (Generic_Object) object);
		}
	}
}