translator.java

来自「无线传感器网络中,基于ns2仿真平台,mannasim的源代码,研究ns2必不可」· Java 代码 · 共 958 行 · 第 1/3 页

                linkLayerElement).item(0));
        importRoutingProtocol((Element) defaultNetwork.getElementsByTagName(
                routingProtocolElement).item(0));
        importPropagation((Element) defaultNetwork.getElementsByTagName(
        		propagationElement).item(0));
        importEnergyModel((Element) defaultNetwork.getElementsByTagName(
        		energyModelElement).item(0));
    }

//    /**
//     * Create an omni antenna.
//     * 
//     * Xml path: /simulation/defaultNetwork/omniAntenna
//     */
//    private Element createOmniAntenna()
//    {
//        Element omniAntenna = document.createElement(omniAntennaElement);
//
//        omniAntenna.setAttribute("x", "0");
//        omniAntenna.setAttribute("y", "0");
//        omniAntenna.setAttribute("z", "1.5");
//        omniAntenna.setAttribute("gt", "1.0");
//        omniAntenna.setAttribute("gr", "1.0");
//
//        return omniAntenna;
//    }
    
    /**
     * Create an antenna.
     * 
     * Xml path: /simulation/defaultNetwork/antenna
     */
    private Element createAntenna()
    {
    	Element antenna = document.createElement(antennaElement);
    	
    	antenna.setAttribute("name", fields.getAntenna());
    	antenna.setAttribute("x", "0");
        antenna.setAttribute("y", "0");
        antenna.setAttribute("z", "1.5");
        antenna.setAttribute("gt", "1.0");
        antenna.setAttribute("gr", "1.0");
        
        return antenna;
    }
    
    private void importAntenna(Element antenna)
    {
    	if (antenna != null)
    	{
    		fields.setAntenna(antenna.getAttribute("name"));
    	}
    }

    /**
     * Create a wireless phy based on profile.
     * 
     * Xml path: /simulation/defaultNetwork/wirelessPhy
     */
    private Element createWirelessPhy()
    {
        return createWirelessPhy(fields.getPhyLayer(), fields
                .getCommonNodeTransmissionRange());
    }

    private Element createWirelessPhy(String profile, double range)
    {
        Element wirelessPhy = document.createElement(wirelessPhyElement);

        if (profile == "Phy/WirelessPhy - Mica2")
            wirelessPhy.setAttribute("profile", "mica2");
        else
            wirelessPhy.setAttribute("profile", profile);

        wirelessPhy.setAttribute("range", Double.toString(range));

        return wirelessPhy;
    }

    private void importWirelessPhy(Element wirelessPhy)
    {
        fields.setPhyLayer(wirelessPhy.getAttribute("profile"));
        fields
                .setCommonNodeTransmissionRange(importWirelessPhyRange(wirelessPhy));
    }

    private double importWirelessPhyRange(Element wirelessPhy)
    {
        return Double.parseDouble(wirelessPhy.getAttribute("range"));
    }

    /**
     * Create a mac.
     * 
     * Xml path: /simulation/defaultNetwork/mac
     */
    private Element createMacLayer()
    {
        Element mac = document.createElement(macLayerElement);

        mac.appendChild(document.createTextNode(fields.getMacLayer()));

        return mac;
    }

    private void importMacLayer(Element mac)
    {
        fields.setMacLayer(mac.getFirstChild().getNodeValue());
    }

    /**
     * Create a queue.
     * 
     * Xml path: /simulation/defaultNetwork/queue
     */
    private Element createQueue()
    {
        Element queue = document.createElement(queueElement);

        queue.appendChild(document.createTextNode(fields.getIfq()));
        queue.setAttribute(queueLengthAttribute, Integer.toString(fields
                .getIfqLen()));

        return queue;
    }

    private void importQueue(Element queue)
    {
        fields.setIfq(queue.getFirstChild().getNodeValue());
        fields.setIfqLen(Integer.parseInt(queue
                .getAttribute(queueLengthAttribute)));
    }

    /**
     * Create link layer.
     * 
     * Xml path: /simulation/defaultNetwork/link
     */
    private Element createLinkLayer()
    {
        Element link = document.createElement(linkLayerElement);

        link.appendChild(document.createTextNode(fields.getLinkLayer()));

        return link;
    }

    private void importLinkLayer(Element link)
    {
        fields.setLinkLayer(link.getFirstChild().getNodeValue());
    }

    /**
     * Create routing protocol.
     * 
     * Xml path: /simulation/defaultNetwork/routingProtocol
     */
    private Element createRoutingProtocol()
    {
        Element routing = document.createElement(routingProtocolElement);

        routing.appendChild(document
                .createTextNode(fields.getRoutingProtocol()));

        return routing;
    }

    private void importRoutingProtocol(Element routing)
    {
        fields.setRoutingProtocol(routing.getFirstChild().getNodeValue());
    }
    
    private Element createPropagation()
    {
    	Element propagation = document.createElement(propagationElement);
    	
    	propagation.appendChild(document
    			.createTextNode(fields.getPropagation()));
    	
    	return propagation;
    }
    
    private void importPropagation(Element propagation)
    {
    	fields.setPropagation(propagation.getFirstChild().getNodeValue());
    }
    
    private Element createEnergyModel()
    {
    	Element energyModel = document.createElement(energyModelElement);
    	
    	energyModel.appendChild(document
    			.createTextNode(fields.getBattery()));
    	
    	return energyModel;
    }
    
    private void importEnergyModel(Element energyModel)
    {
    	fields.setBattery(energyModel.getFirstChild().getNodeValue());
    }

    /**
     * Creates an access point.
     * 
     * Xml path: /simulation/accessPoint
     */
    private Element createAccessPoint()
    {
        Element accessPoint = document.createElement(accessPointElement);

        accessPoint.appendChild(createNodeNetwork(fields
                .getAccessPointTransmissionRange()));
        accessPoint
                .appendChild(createNodeEnergy(fields.getAccessPointEnergy()));

        if (isAbsolutePosition(fields.getAccessPointLocation()))
            accessPoint.appendChild(createAbsolutePositon(fields
                    .getAccessPointLocation()));
        else
            accessPoint.setAttribute("distribution", fields
                    .getAccessPointLocation().toLowerCase());

        accessPoint.appendChild(createApplication(fields
                .getAccessPointApplication()));

        accessPoint.setAttribute("times", Integer.toString(fields
                .getAccessPointNumber()));

        return accessPoint;
    }

    private void importAccessPoint(Element accessPoint)
    {
        fields
                .setAccessPointTransmissionRange(importNodeTransmissionRange(accessPoint));
        fields.setAccessPointEnergy(importNodeEnergy(accessPoint));
        fields.setAccessPointLocation(importNodePosition(accessPoint));
        fields.setAccessPointApplication(importNodeApplication(accessPoint));
        fields.setAccessPointNumber(importNodeTimes(accessPoint));
    }

    private Element createCommonNode()
    {
        Element node = document.createElement(commonNodeElement);

        node.appendChild(createNodeNetwork(fields
                .getCommonNodeTransmissionRange(), fields
                .getCommonNodeDissType(), fields.getCommonNodeDissInterval()));
        node.appendChild(createNodeEnergy(fields.getCommonNodeEnergy()));

        if (isAbsolutePosition(fields.getCommonNodeLocation()))
            node.appendChild(createAbsolutePositon(fields
                    .getCommonNodeLocation()));
        else
            node.setAttribute("distribution", fields.getCommonNodeLocation()
                    .toLowerCase());

        node.appendChild(createApplication(fields.getCommonNodeApplication()));
        node
                .appendChild(createProcessing(fields
                        .getCommonNodeProcessingType()));
        node.appendChild(createDataGenerator(fields
                .getCommonNodeDataGeneratorType(), fields
                .getCommonNodeSensingInterval(), fields
                .getCommonNodeSensingType(), fields.getCommonNodeDataAverage(),
                fields.getCommonNodeDataDeviation(), fields
                        .getCommonNodeMaximumData()));

        node.setAttribute("times", Integer.toString(fields
                .getCommonNodeNumber()));

        return node;
    }

    private void importCommonNode(Element commonNode)
    {
        Element dataGenerator;

        dataGenerator = (Element) commonNode.getElementsByTagName(
                dataGeneratorElement).item(0);

        fields
                .setCommonNodeTransmissionRange(importNodeTransmissionRange(commonNode));
        fields.setCommonNodeDissType(importNodeDisseminatingType(commonNode));
        fields
                .setCommonNodeDissInterval(importNodeDisseminatingInterval(commonNode));
        fields.setCommonNodeEnergy(importNodeEnergy(commonNode));
        fields.setCommonNodeLocation(importNodePosition(commonNode));
        fields.setCommonNodeApplication(importNodeApplication(commonNode));
        fields.setCommonNodeProcessingType(importNodeProcessing(commonNode));
        fields
                .setCommonNodeDataGeneratorType(importDataGeneratorType(dataGenerator));
        fields
                .setCommonNodeSensingInterval(importDataGeneratorSensingInterval(dataGenerator));
        fields
                .setCommonNodeSensingType(importDataGeneratorSensingType(dataGenerator));
        fields
                .setCommonNodeDataAverage(importDataGeneratorAvgMeasure(dataGenerator));
        fields
                .setCommonNodeDataDeviation(importDataGeneratorStdDeviation(dataGenerator));
        fields.setCommonNodeMaximumData(importDataGeneratorMax(dataGenerator));
    }

    private Element createClusterHead()
    {
        Element clusterHead = document.createElement(clusterHeadElement);

        clusterHead
                .appendChild(createNodeNetwork(fields
                        .getClusterHeadTransmissionRange(), fields
                        .getClusterHeadDissType(), fields
                        .getClusterHeadDissInterval()));
        clusterHead
                .appendChild(createNodeEnergy(fields.getClusterHeadEnergy()));

        if (isAbsolutePosition(fields.getClusterHeadLocation()))
            clusterHead.appendChild(createAbsolutePositon(fields
                    .getClusterHeadLocation()));
        else