translator.java

无线传感器网络中,基于ns2仿真平台,mannasim的源代码,研究ns2必不可少的

package xml2tcl;

import gui.TclFields;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.Result;
import javax.xml.transform.Source;
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 javax.xml.transform.stream.StreamSource;

import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.xml.sax.SAXException;

/**
 * This class translates the TclFields from and to an XML document. It also
 * exports those fields to a TCL script for NS-2.
 * 
 * @author J煤lio C茅sar e Melo
 * @since Nov. 2005
 * @version 0.1
 * 
 * This version doesn't work well with antenna settings.
 */
public class Translator
{
    private final String xsltFileName = "mannasim-tcl.xsl";
    private final String absolutePositionElement = "position";
    private final String accessPointElement = "accessPoint";
    private final String applicationElement = "application";
    private final String avgMeasureElement = "avgMeasure";
    private final String clusterHeadElement = "clusterHead";
    private final String commonNodeElement = "commonNode";
    private final String dataGeneratorElement = "dataGenerator";
    private final String defaultNetworkElement = "defaultNetwork";
    private final String disseminatingElement = "disseminatingType";
    private final String linkLayerElement = "linkLayer";
    private final String macLayerElement = "mac";
    private final String maximumDataElement = "max";
    private final String nodeEnergyElement = "energy";
    private final String nodeNetworkArchitectureElement = "network";
    private final String omniAntennaElement = "omniAntenna";
    private final String antennaElement = "antenna";
    private final String processingElement = "processing";
    private final String queueElement = "queue";
    private final String queueLengthAttribute = "queueLengthAttribute";
    private final String routingProtocolElement = "routingProtocol";
    private final String propagationElement = "propagation";
    private final String energyModelElement = "energyModel";
    private final String scenarioElement = "scenario";
    private final String sensingIntervalElement = "sensingInterval";
    private final String sensingTypeElement = "sensingType";
    private final String stdDeviationElement = "stdDeviation";
    private final String timeElement = "time";
    private final String traceElement = "trace";
    private final String wirelessPhyElement = "wirelessPhy";

    // Before chaning this, see createAbsolutePosition().
    private final String[] absolutePositions = new String[] { "CENTER",
            "UP LEFT CORNER", "DOWN LEFT CORNER", "UP RIGHT CORNER",
            "DOWN RIGHT CORNER", };

    /*
     * private final String [] distributedPositions = new String [] { "GRID",
     * "RANDOM" };
     */

    private TclFields fields;

    private Document document;

    public Translator(TclFields tclFields)
    {
        this.fields = tclFields;
        document = null;
    }

    public void open(File file) throws SAXException, IOException,
            ParserConfigurationException
    {
        DocumentBuilderFactory documentFactory = DocumentBuilderFactory
                .newInstance();
        DocumentBuilder documentBuilder = documentFactory.newDocumentBuilder();

        document = documentBuilder.parse(file);

        importDocument();
    }

    public void save(String fileName) throws FileNotFoundException,
            TransformerConfigurationException, TransformerException,
            IOException, ParserConfigurationException
    {
        createDocument();

        FileOutputStream outputFile = new FileOutputStream(fileName);
        Source xmlSource = new DOMSource(document);
        Result result = new StreamResult(outputFile);
        TransformerFactory transFactory = TransformerFactory.newInstance();
        Transformer transformer = transFactory.newTransformer();

        transformer.transform(xmlSource, result);

        outputFile.close();
    }

    /**
     * Create Xml document.
     */
    private void createDocument() throws ParserConfigurationException
    {
        DocumentBuilderFactory documentFactory = DocumentBuilderFactory
                .newInstance();
        DocumentBuilder documentBuilder = documentFactory.newDocumentBuilder();
        Element simulation;

        document = documentBuilder.newDocument();

        simulation = document.createElement("simulation");

        appendChildIfNotNull(simulation, createTrace());
        simulation.appendChild(createTime());
        simulation.appendChild(createScenario());
        simulation.appendChild(createDefaultNetwork());
        simulation.appendChild(createAccessPoint());

        if (fields.getClusterHeadNumber() > 0)
            simulation.appendChild(createClusterHead());

        simulation.appendChild(createCommonNode());

        document.appendChild(simulation);
    }

    private void importDocument()
    {
        importTrace((Element) document.getElementsByTagName(traceElement).item(
                0));
        importTime((Element) document.getElementsByTagName(timeElement).item(0));
        importScenario((Element) document.getElementsByTagName(scenarioElement)
                .item(0));
        importDefaultNetwork((Element) document.getElementsByTagName(
                defaultNetworkElement).item(0));
        importAccessPoint((Element) document.getElementsByTagName(
                accessPointElement).item(0));
        importClusterHead((Element) document.getElementsByTagName(
                clusterHeadElement).item(0));
        importCommonNode((Element) document.getElementsByTagName(
                commonNodeElement).item(0));
    }

    private void appendChildIfNotNull(Element root, Element child)
    {
        if (child != null)
            root.appendChild(child);
    }

    /**
     * Translate a xml document to tcl.
     * 
     * @param outputFileName
     *            Tcl script for ns.
     * 
     * @throws TransformerException
     */
    public void export(String outputFileName) throws TransformerException,
            FileNotFoundException, IOException, ParserConfigurationException
    {
        createDocument();

        FileOutputStream outputStream = new FileOutputStream(outputFileName);
        Source xmlSource = new DOMSource(document);
        Source xsltSource = new StreamSource(getClass().getResourceAsStream(
                xsltFileName));
        Result result = new StreamResult(outputStream);
        TransformerFactory transFactory = TransformerFactory.newInstance();
        Transformer transformer = transFactory.newTransformer(xsltSource);

        transformer.transform(xmlSource, result);

        outputStream.close();
    }

    /**
     * Create trace element.
     * 
     * Xml path: /simulation/trace
     */
    private Element createTrace()
    {
        if (fields.isTraceFile())
        {
            Element trace = document.createElement(traceElement);

            trace.appendChild(document
                    .createTextNode(fields.getTraceFileName()));

            trace.setAttribute("mac", fields.isTraceMac() ? "true" : "false");
            trace.setAttribute("agent", fields.isTraceAgent() ? "true"
                    : "false");
            trace.setAttribute("router", fields.isTraceRoute() ? "true"
                    : "false");

            return trace;
        }
        else
            return null;
    }

    private void importTrace(Element trace)
    {
        if (trace != null)
        {
            fields.setTraceFileName(trace.getFirstChild().getNodeValue());
            fields.setTraceMac(trace.getAttribute("mac").compareToIgnoreCase(
                    "true") == 0);
            fields.setTraceAgent(trace.getAttribute("agent")
                    .compareToIgnoreCase("true") == 0);
            fields.setTraceRoute(trace.getAttribute("router")
                    .compareToIgnoreCase("true") == 0);
        }
    }

    /**
     * Create time element.
     * 
     * Xml path: /simulation/time
     */
    private Element createTime()
    {
        Element time = document.createElement(timeElement);

        time
                .setAttribute("start", Double.toString(fields
                        .getSimulationStart()));
        time.appendChild(document.createTextNode(Double.toString(fields
                .getSimulationStop())));

        return time;
    }

    private void importTime(Element trace)
    {
        fields.setSimulationStart(Double.parseDouble(trace
                .getAttribute("start")));
        fields.setSimulationStop(Double.parseDouble(trace.getFirstChild()
                .getNodeValue()));
    }

    /**
     * Create scenario element from ScenarioX and ScenarioY.
     * 
     * Xml path: /simulation/scenario
     */
    private Element createScenario()
    {
        Element scenario = document.createElement(scenarioElement);

        scenario.setAttribute("width", Double.toString(fields.getScenarioX()));
        scenario.setAttribute("height", Double.toString(fields.getScenarioY()));

        return scenario;
    }

    private void importScenario(Element scenario)
    {
        fields.setScenarioX(Double.parseDouble(scenario.getAttribute("width")));
        fields
                .setScenarioY(Double.parseDouble(scenario
                        .getAttribute("height")));
    }

    /**
     * Create a default network settings.
     * 
     * Xml path: /simulation/defaultNetwork
     */
    private Element createDefaultNetwork()
    {
        Element defaultNetwork = document.createElement(defaultNetworkElement);

//        if (fields.getAntenna().compareToIgnoreCase("Antenna/OmniAntenna") == 0)
//            defaultNetwork.appendChild(createOmniAntenna());
//        else
        	defaultNetwork.appendChild(createAntenna());

        defaultNetwork.appendChild(createWirelessPhy());
        defaultNetwork.appendChild(createMacLayer());
        defaultNetwork.appendChild(createQueue());
        defaultNetwork.appendChild(createLinkLayer());
        defaultNetwork.appendChild(createRoutingProtocol());
        defaultNetwork.appendChild(createPropagation());
        defaultNetwork.appendChild(createEnergyModel());

        return defaultNetwork;
    }

    private void importDefaultNetwork(Element defaultNetwork)
    {
    	importAntenna((Element) defaultNetwork.getElementsByTagName(
                antennaElement).item(0));
        importWirelessPhy((Element) defaultNetwork.getElementsByTagName(
                wirelessPhyElement).item(0));
        importMacLayer((Element) defaultNetwork.getElementsByTagName(
                macLayerElement).item(0));
        importQueue((Element) defaultNetwork.getElementsByTagName(queueElement)
                .item(0));
        importLinkLayer((Element) defaultNetwork.getElementsByTagName(