org/objectweb/proactive/benchmarks/timit/util/XMLHelper.java

/* 
 * ################################################################
 * 
 * ProActive: The Java(TM) library for Parallel, Distributed, 
 *            Concurrent computing with Security and Mobility
 * 
 * Copyright (C) 1997-2007 INRIA/University of Nice-Sophia Antipolis
 * Contact: proactive@objectweb.org
 * 
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or any later version.
 *  
 * This library 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
 * Lesser General Public License for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
 * USA
 *  
 *  Initial developer(s):               The ProActive Team
 *                        http://www.inria.fr/oasis/ProActive/contacts.html
 *  Contributor(s): 
 * 
 * ################################################################
 */ 
package org.objectweb.proactive.benchmarks.timit.util;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.jdom.Attribute;
import org.jdom.Document;
import org.jdom.Element;
import org.jdom.input.SAXBuilder;
import org.jdom.output.Format;
import org.jdom.output.XMLOutputter;

public class XMLHelper {

    public static Document readFile(String filename) {
        try {
            return new SAXBuilder().build(new File(filename));

        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    public static void writeFile(Document document, String filename) {
        try {
            XMLOutputter out = new XMLOutputter(Format.getPrettyFormat());
            File file = new File(filename);

            String path = file.getParent();
            if (path != null) {
                new File(path).mkdirs();
            }
            FileOutputStream fos = new FileOutputStream(file);
            out.output(document, fos);

        } catch (Exception e) {
            System.err.println("Unable to write file: " + filename);
            e.printStackTrace();
        }
    }

    public static void errorLog(String filename, String message) {
        try {
            File file = new File(filename);
            String path = file.getParent();
            if (path != null) {
                new File(path).mkdirs();
            }
            FileOutputStream fos = new FileOutputStream(file, true); // true->append
            String time = ""
                    + (new java.sql.Timestamp(System.currentTimeMillis()));
            message = time + "  " + message + "\n";
            fos.write(message.getBytes());
            fos.close();

        } catch (Exception e) {
            System.err.println("Unable to write file: " + filename);
            e.printStackTrace();
        }
    }

    public static void generateDescriptor(String inFilename,
            HashMap<String, String> gvars, HashMap<String, String> lvars,
            String outFilename) {

        // Read and modify ProActive descriptor base
        Document doc = XMLHelper.readFile(inFilename);
        Element eVariables = doc.getRootElement().getChild("variables");
        Iterator it = eVariables.getChildren().iterator();
        while (it.hasNext()) {
            Element var = (Element) it.next();
            String name = var.getAttributeValue("name");
            if (lvars.containsKey(name)) {
                var.setAttribute("value", lvars.get(name));
            } else if (gvars.containsKey(name)) {
                var.setAttribute("value", gvars.get(name));
            }
        }

        // Write the generated descriptor into file
        XMLHelper.writeFile(doc, outFilename);
    }

    public static void replaceAll(Element elt, String old, String value) {
        Iterator itAttr = elt.getAttributes().iterator();
        while (itAttr.hasNext()) {
            Attribute attr = (Attribute) itAttr.next();
            attr.setValue(attr.getValue().replaceAll(old, value));
        }
    }

    public static void replaceVariables(List serieList,
            HashMap<String, String> vars) {

        // Replace variables
        Pattern p = Pattern.compile("[^\\x24\\x7B\\x7D]*\\x24\\x7B" + // *${
                "([^\\x7D]*)" + // A,B,C
                "\\x7D[^\\x7D\\x24\\x7B]*"); // }*
        Iterator it = serieList.iterator();
        while (it.hasNext()) {
            Element serie = (Element) it.next();
            // Look for variables in Serie attributes
            replaceVariablesAttributes(serie, p, vars);

            // Look for variables in all descendants of Serie
            Iterator itSerie = serie.getDescendants();
            while (itSerie.hasNext()) {
                Object elt = itSerie.next();
                if (elt instanceof Element) {
                    replaceVariablesAttributes((Element) elt, p, vars);
                }
            }
        }
    }

    private static void replaceVariablesAttributes(Element elt, Pattern p,
            HashMap<String, String> vars) {
        Iterator itAttr = elt.getAttributes().iterator();
        while (itAttr.hasNext()) {
            Attribute attr = (Attribute) itAttr.next();
            String values = attr.getValue();
            Matcher m = p.matcher(values);
            while (m.find()) {
                String var = m.group(1);
                String resolve = vars.get(var);
                values = values.replaceAll("\\x24\\x7B" + var + "\\x7D", // ${*}
                        resolve.split(",").length == 1 ? resolve : "#{"
                                + resolve + "}");
                attr.setValue(values);
            }
        }
    }

    public static void tagFiltering(Element eTag, String[] values) {
        Arrays.sort(values);
        List<Element> children = eTag.getChildren();
        int i = 0;
        
        while( i<children.size() ) {
            Element elt = children.get(i);
            Element parent = elt.getParentElement();

            while( ! filter( elt, values ) ) {
                if( ! elt.getName().equals(parent.getName()) ) {
                    children = eTag.getChildren();
                    i--;
                    break;
                }
                elt = parent;
            }
            i++;
        }
    }
    
    private static boolean filter( Element eTag, String[] values ) {
        if (values.length == 0) {
            return true;
        }
        if (Arrays.binarySearch(values, eTag.getAttributeValue("name")) < 0) {
            // not in values --> remove this Element
            eTag.detach();
            return false;
        } else {
            List children = eTag.getChildren();
            for (int i = 0; i < children.size(); i++) {
                Element child = (Element) children.get(i);
                Element parent = child.getParentElement();
                while( ! filter(child, values) ) {
                    child = parent;
                }
            }
            return true; 
        }        
    }

    public static void printOut(Document doc) {
        XMLOutputter xmlOutputter = new XMLOutputter(Format.getPrettyFormat());
        try {
            xmlOutputter.output(doc, System.out);
        } catch (IOException ex) {
            ex.printStackTrace();
        }
    }
}

---