xmlwriter.java

一个用于排队系统仿真的开源软件,有非常形象的图象仿真过程!

/**    
  * Copyright (C) 2006, Laboratorio di Valutazione delle Prestazioni - Politecnico di Milano

  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 2 of the License, or
  * (at your option) any later version.

  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.

  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  */
  
package jmt.gui.common.xml;

import jmt.engine.random.EmpiricalEntry;
import jmt.gui.common.CommonConstants;
import jmt.gui.common.definitions.CommonModel;
import jmt.gui.common.distributions.Distribution;
import jmt.gui.common.routingStrategies.ProbabilityRouting;
import jmt.gui.common.routingStrategies.RoutingStrategy;
import jmt.gui.common.serviceStrategies.LDStrategy;
import jmt.gui.common.serviceStrategies.ZeroStrategy;

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

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.*;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import java.io.File;
import java.io.OutputStream;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Vector;

/**
 * Created by IntelliJ IDEA.
 * User: orsotronIII
 * Date: 15-lug-2005
 * Time: 10.56.01
 * Modified by Bertoli Marco
 */
public class XMLWriter implements CommonConstants, XMLConstantNames{

    /*defines matching between gui representation and engine names for queue
    strategies, e.g. FCFS = TailStrategy.*/
    protected static final HashMap queuePutStrategyNamesMatchings = new HashMap(){
        {
            put(QUEUE_STRATEGY_FCFS, "TailStrategy");
            put(QUEUE_STRATEGY_LCFS, "HeadStrategy");
            put(QUEUE_STRATEGY_FCFS_PRIORITY, "TailStrategyPriority");
            put(QUEUE_STRATEGY_LCFS_PRIORITY , "HeadStrategyPriority");
        }
    };
    
    /*defines matching between gui representation and engine names for drop
    rules.*/
    protected static final HashMap dropRulesNamesMatchings = new HashMap(){
        {
            put(FINITE_DROP, "drop");
            put(FINITE_WAITING, "waiting queue");
            put(FINITE_BLOCK, "BAS blocking");
        }
    };
    

    public static final String strategiesClasspathBase = "jmt.engine.NetStrategies.";
    public static final String queuegetStrategiesSuffix = "QueueGetStrategies.";
    public static final String queueputStrategiesSuffix = "QueuePutStrategies.";
    public static final String routingStrategiesSuffix = "RoutingStrategies.";
    public static final String serviceStrategiesSuffix = "ServiceStrategies.";

    public static void writeXML(String fileName, CommonModel model){
        writeToResult(new StreamResult(new File(fileName)), model, fileName);
    }

    public static void writeXML(File xmlFile, CommonModel model){
        writeToResult(new StreamResult(xmlFile), model, xmlFile.getName());
    }

    public static void writeXML(OutputStream out, CommonModel model){
        writeToResult(new StreamResult(out), model, "model");
    }

    public static void writeXML(String fileName, Document doc) {
        if(doc == null) return;
        try {
            Transformer transformer = TransformerFactory.newInstance().newTransformer();
            transformer.setOutputProperty("indent", "yes");
            transformer.setOutputProperty("encoding", ENCODING);
            transformer.transform(new DOMSource(doc),
                    new StreamResult(new File(fileName)));
        } catch (TransformerConfigurationException e) {
            e.printStackTrace();  //To change body of catch statement use Options | File Templates.
        } catch (TransformerFactoryConfigurationError transformerFactoryConfigurationError) {
            transformerFactoryConfigurationError.printStackTrace();  //To change body of catch statement use Options | File Templates.
        } catch (TransformerException e) {
            e.printStackTrace();  //To change body of catch statement use Options | File Templates.
        }
    }

    public static Document getDocument(CommonModel model, String modelName){
        DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
        DocumentBuilder docBuilder;
        try {
            docBuilder = dbf.newDocumentBuilder();
        } catch (ParserConfigurationException e) {
            e.printStackTrace();
            return null;
        }
        Document modelDoc = docBuilder.newDocument();
        writeModel(modelDoc, model, modelName);
        return modelDoc;
    }



    private static void writeToResult(Result res, CommonModel model, String modelName){
        Document modelDoc = getDocument(model, modelName);
        if(modelDoc == null) return;
        try {
            Transformer transformer = TransformerFactory.newInstance().newTransformer();
            transformer.setOutputProperty("indent", "yes");
            transformer.setOutputProperty("encoding", ENCODING);
            transformer.transform(new DOMSource(modelDoc),
                    res);
        } catch (TransformerConfigurationException e) {
            e.printStackTrace();  //To change body of catch statement use Options | File Templates.
        } catch (TransformerFactoryConfigurationError transformerFactoryConfigurationError) {
            transformerFactoryConfigurationError.printStackTrace();  //To change body of catch statement use Options | File Templates.
        } catch (TransformerException e) {
            e.printStackTrace();  //To change body of catch statement use Options | File Templates.
        }
    }

    static protected void writeModel(Document modelDoc, CommonModel model, String modelName){
        Element elem = modelDoc.createElement(XML_DOCUMENT_ROOT);
        modelDoc.appendChild(elem);
        elem.setAttribute(XML_A_ROOT_NAME, modelName);
        elem.setAttribute("xsi:noNamespaceSchemaLocation", XML_DOCUMENT_XSD);
        elem.setAttribute("xmlns:xsi", "http://www.w3.org/2001/XMLSchema-instance");
        // Simulation seed - Bertoli Marco
        if (!model.getUseRandomSeed())
            elem.setAttribute(XML_A_ROOT_SEED, model.getSimulationSeed().toString());
        // Max simulation time - Bertoli Marco
        if (model.getMaximumDuration().longValue() > 0)
            elem.setAttribute(XML_A_ROOT_DURATION, model.getMaximumDuration().toString());
        // Polling interval - Bertoli Marco
        elem.setAttribute(XML_A_ROOT_POLLING, Double.toString(model.getPollingInterval()));
        // Max Samples - Bertoli Marco
        elem.setAttribute(XML_A_ROOT_MAXSAMPLES, model.getMaxSimulationSamples().toString());
        // Disable Statistic
        elem.setAttribute(XML_A_ROOT_DISABLESTATISTIC, model.getDisableStatistic().toString());
        // Write all elements
        writeClasses(modelDoc, elem, model);
        writeStations(modelDoc, elem, model);
        writeMeasures(modelDoc, elem, model);
        writeConnections(modelDoc, elem, model);
        writeBlockingRegions(modelDoc, elem, model);
        writePreload(modelDoc, elem, model);
    }

/*-----------------------------------------------------------------------------------
*--------------------- Methods for construction of user classes ---------------------
*-----------------------------------------------------------------------------------*/

    static protected void writeClasses(Document doc, Node simNode, CommonModel model){
        Vector v = model.getClassKeys();
        for(int i=0; i<v.size(); i++){
            Object classKey = v.get(i);
            String classType =
                    model.getClassType(classKey)==CLASS_TYPE_CLOSED ? "closed" : "open";
            Element userClass = doc.createElement(XML_E_CLASS);
            String[] attrsNames = new String[]{
                XML_A_CLASS_NAME, XML_A_CLASS_TYPE, XML_A_CLASS_PRIORITY,
                XML_A_CLASS_CUSTOMERS, XML_A_CLASS_REFSOURCE
            };
            String[] attrsValues = new String[]{
                model.getClassName(classKey), classType,
                String.valueOf(model.getClassPriority(classKey)),
                String.valueOf(model.getClassPopulation(classKey)),
                getSourceNameForClass(classKey, doc, model),
            };
            for(int j=0; j<attrsNames.length; j++){
                if(attrsValues[j] != null && !"null".equals(attrsValues[j])){
                    userClass.setAttribute(attrsNames[j], attrsValues[j]);
                }
            }
            simNode.appendChild(userClass);
        }
    }


    /**This method returns the name of the reference source for a class to be inserted into
     * userclass elemnt's attribute.*/
    static protected String getSourceNameForClass(Object classKey, Document doc, CommonModel model){
        if (model.getClassRefStation(classKey) != null)
            return model.getStationName(model.getClassRefStation(classKey));
        else
            return null;
    }



/*-----------------------------------------------------------------------------------
*----------------------- Methods for construction of stations -----------------------
*-----------------------------------------------------------------------------------*/

    static protected void writeStations(Document doc, Node simNode, CommonModel model){
        Vector stations = model.getStationKeys();
        Element elem;
        for(int i=0; i<stations.size(); i++){
            elem = doc.createElement(XML_E_STATION);
            elem.setAttribute(XML_A_STATION_NAME, model.getStationName(stations.get(i)));
            Object stationKey = stations.get(i);
            String stationType = model.getStationType(stationKey);
            if(STATION_TYPE_DELAY.equals(stationType)){
                writeQueueSection(doc, elem, model, stationKey);
                writeDelaySection(doc, elem, model, stationKey);
                writeRouterSection(doc, elem, model, stationKey);
            }else if(STATION_TYPE_SERVER.equals(stationType)){
                writeQueueSection(doc, elem, model, stationKey);
                writeServerSection(doc, elem, model, stationKey);
                writeRouterSection(doc, elem, model, stationKey);
            }else if(STATION_TYPE_SOURCE.equals(stationType)){
                writeSourceSection(doc, elem, model, stationKey);
                writeTunnelSection(doc, elem, model, stationKey);
                writeRouterSection(doc, elem, model, stationKey);
            }else if(STATION_TYPE_TERMINAL.equals(stationType)){
                writeTerminalSection(doc, elem, model, stationKey);
                writeTunnelSection(doc, elem, model, stationKey);
                writeRouterSection(doc, elem, model, stationKey);
            }else if(STATION_TYPE_ROUTER.equals(stationType)){