translator.java

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

            clusterHead.setAttribute("distribution", fields
                    .getClusterHeadLocation().toLowerCase());

        clusterHead.appendChild(createApplication(fields
                .getClusterHeadApplication()));
        clusterHead.appendChild(createProcessing(fields
                .getClusterHeadProcessingType()));

        clusterHead.setAttribute("times", Integer.toString(fields
                .getClusterHeadNumber()));

        return clusterHead;
    }

    private void importClusterHead(Element clusterHead)
    {
        if (clusterHead != null)
        {
            fields
                    .setClusterHeadTransmissionRange(importNodeTransmissionRange(clusterHead));
            fields
                    .setClusterHeadDissType(importNodeDisseminatingType(clusterHead));
            fields
                    .setClusterHeadDissInterval(importNodeDisseminatingInterval(clusterHead));
            fields.setClusterHeadEnergy(importNodeEnergy(clusterHead));
            fields.setClusterHeadLocation(importNodePosition(clusterHead));
            fields
                    .setClusterHeadApplication(importNodeApplication(clusterHead));
            fields
                    .setClusterHeadProcessingType(importNodeProcessing(clusterHead));
            fields.setClusterHeadNumber(importNodeTimes(clusterHead));
        }
    }

    /**
     * Creates a node network architecture.
     */
    private Element createNodeNetwork(double range)
    {
        Element network = document
                .createElement(nodeNetworkArchitectureElement);

        network.appendChild(createWirelessPhy(fields.getPhyLayer(), range));

        return network;
    }

    private int importNodeTimes(Element node)
    {
        return Integer.parseInt(node.getAttribute("times"));
    }

    /**
     * Imports the radio range from a node.
     * 
     * @param node
     *            AccessPoint, ClusterHead or CommonNode XML element.
     * 
     * @return Radio range.
     */
    private double importNodeTransmissionRange(Element node)
    {
        return importWirelessPhyRange((Element) getNodeNetwork(node)
                .getElementsByTagName(wirelessPhyElement).item(0));
    }

    private Element getNodeNetwork(Element node)
    {
        return (Element) node.getElementsByTagName(
                nodeNetworkArchitectureElement).item(0);
    }

    /**
     * Creates a node network architecture.
     */
    private Element createNodeNetwork(double range, String disseminatingType,
            double disseminatingInterval)
    {
        Element network = createNodeNetwork(range);

        network.appendChild(createDisseminating(disseminatingType,
                disseminatingInterval));

        return network;
    }

    private Element createDisseminating(String type, double interval)
    {
        Element disseminating = document.createElement(disseminatingElement);

        disseminating.appendChild(document.createTextNode(type.toLowerCase()));
        disseminating.setAttribute("interval", Double.toString(interval));

        return disseminating;
    }

    /**
     * Imports node disseminating type.
     * 
     * @param node
     *            AccessPoint, ClusterHead or CommoNode XML element.
     * 
     * @return Disseminating type.
     */
    private String importNodeDisseminatingType(Element node)
    {
        return ((Element) node.getElementsByTagName(disseminatingElement).item(
                0)).getFirstChild().getNodeValue();
    }

    private double importNodeDisseminatingInterval(Element node)
    {
        return Double.parseDouble(((Element) node.getElementsByTagName(
                disseminatingElement).item(0)).getAttribute("interval"));
    }

    /**
     * Creates a node initial energy.
     * 
     * @param energy
     *            Initial energy.
     */
    private Element createNodeEnergy(double energy)
    {
        Element energyElement = document.createElement(nodeEnergyElement);

        energyElement.appendChild(document.createTextNode(Double
                .toString(energy)));

        return energyElement;
    }

    private double importNodeEnergy(Element node)
    {
        return Double.parseDouble(node.getElementsByTagName(nodeEnergyElement)
                .item(0).getFirstChild().getNodeValue());
    }

    /**
     * Check if the string position is an absolute position.
     * 
     * @return Returns if "position" is an absolute position.
     */
    private boolean isAbsolutePosition(String position)
    {
        boolean itIs = false;

        for (int i = 0; i < absolutePositions.length; i++)
            itIs |= position == absolutePositions[i];

        return itIs;
    }

    /**
     * Creates an absolute position based on a string.
     * 
     * @return Xml absolute position element.
     */
    private Element createAbsolutePositon(String strPosition)
    {
        Element position = document.createElement(absolutePositionElement);
        double x = 0, y = 0;

        // "CENTER", "UP LEFT CORNER", "DOWN LEFT CORNER", "UP RIGHT CORNER",
        // "DOWN RIGHT CORNER",

        if (strPosition == absolutePositions[0]) // Centered
        {
            x = fields.getScenarioX() / 2;
            y = fields.getScenarioY() / 2;
        }
        else if (strPosition == absolutePositions[1]) // Top left
        {
            x = y = 0;
        }
        else if (strPosition == absolutePositions[2]) // Bottom left
        {
            x = 0;
            y = fields.getScenarioY();
        }
        else if (strPosition == absolutePositions[3]) // Top right
        {
            x = fields.getScenarioX();
            y = 0;
        }
        else if (strPosition == absolutePositions[4]) // Bottom right
        {
            x = fields.getScenarioX();
            y = fields.getScenarioY();
        }

        position.setAttribute("x", Double.toString(x));
        position.setAttribute("y", Double.toString(y));
        position.setAttribute("z", "0.0");
        position.setAttribute("description", strPosition);

        return position;
    }

    private String importNodePosition(Element node)
    {
        Element absolutePosition;

        absolutePosition = (Element) node.getElementsByTagName(
                absolutePositionElement).item(0);

        if (absolutePosition != null)
        {
            String description;

            description = ((Element) node.getElementsByTagName(
                    absolutePositionElement).item(0))
                    .getAttribute("description");

            if (description != null && description != "")
                return description;
        }

        return node.getAttribute("distribution");
    }

    private Element createApplication(String application)
    {
        Element appElement = document.createElement(applicationElement);

        appElement.appendChild(document.createTextNode(application));

        return appElement;
    }

    private String importNodeApplication(Element node)
    {
        return node.getElementsByTagName(applicationElement).item(0)
                .getFirstChild().getNodeValue();
    }

    private Element createProcessing(String type)
    {
        Element processing = document.createElement(processingElement);

        processing.appendChild(document.createTextNode(type));

        return processing;
    }

    private String importNodeProcessing(Element node)
    {
        return node.getElementsByTagName(processingElement).item(0)
                .getFirstChild().getNodeValue();
    }

    private Element createDataGenerator(String type, double sensingInterval,
            String sensingType, double avgMeasure, double stdDeviation,
            double max)
    {
        Element dataGenerator = document.createElement(dataGeneratorElement);
        Element eSensingInterval = document
                .createElement(sensingIntervalElement);
        Element eSensingType = document.createElement(sensingTypeElement);
        Element eAvgMeasure = document.createElement(avgMeasureElement);
        Element eStdDeviation = document.createElement(stdDeviationElement);
        Element eMax = document.createElement(maximumDataElement);

        eSensingInterval.appendChild(document.createTextNode(Double
                .toString(sensingInterval)));
        eSensingType.appendChild(document.createTextNode(sensingType.toLowerCase()));
        eAvgMeasure.appendChild(document.createTextNode(Double
                .toString(avgMeasure)));
        eStdDeviation.appendChild(document.createTextNode(Double
                .toString(stdDeviation)));
        eMax.appendChild(document.createTextNode(Double.toString(max)));

        dataGenerator.appendChild(eSensingInterval);
        dataGenerator.appendChild(eSensingType);
        dataGenerator.appendChild(eAvgMeasure);
        dataGenerator.appendChild(eStdDeviation);
        dataGenerator.appendChild(eMax);

        dataGenerator.setAttribute("type", type);

        return dataGenerator;
    }

    private String importDataGeneratorType(Element dataGenerator)
    {
        return dataGenerator.getAttribute("type");
    }

    private double importDataGeneratorSensingInterval(Element dataGenerator)
    {
        return Double.parseDouble(dataGenerator.getElementsByTagName(
                sensingIntervalElement).item(0).getFirstChild().getNodeValue());
    }

    private String importDataGeneratorSensingType(Element dataGenerator)
    {
        return dataGenerator.getElementsByTagName(sensingTypeElement).item(0)
                .getFirstChild().getNodeValue();
    }

    private double importDataGeneratorAvgMeasure(Element dataGenerator)
    {
        return Double.parseDouble(dataGenerator.getElementsByTagName(
                avgMeasureElement).item(0).getFirstChild().getNodeValue());
    }

    private double importDataGeneratorStdDeviation(Element dataGenerator)
    {
        return Double.parseDouble(dataGenerator.getElementsByTagName(
                stdDeviationElement).item(0).getFirstChild().getNodeValue());
    }

    private double importDataGeneratorMax(Element dataGenerator)
    {
        return Double.parseDouble(dataGenerator.getElementsByTagName(
                maximumDataElement).item(0).getFirstChild().getNodeValue());
    }
}