mindswap/utils/Utils.java

// The MIT License
//
// Copyright (c) 2004 Evren Sirin
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to
// deal in the Software without restriction, including without limitation the
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
// sell copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
// IN THE SOFTWARE.

package org.mindswap.utils;

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.Reader;
import java.io.StringReader;
import java.io.StringWriter;
import java.net.URL;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.Map;

import org.apache.xml.serialize.OutputFormat;
import org.apache.xml.serialize.XMLSerializer;
import org.mindswap.owl.vocabulary.RDF;
import org.w3c.dom.Attr;
import org.w3c.dom.Document;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.ErrorHandler;
import org.xml.sax.SAXParseException;

public class Utils {
    public static boolean DEBUG = false;

    public static Object getHashtableKey(Hashtable h, Object value) {
        Iterator e = h.entrySet().iterator();
        while(e.hasNext()) {
            Map.Entry entry = (Map.Entry) e.next();

            if(entry.getValue().equals(value))
                return entry.getKey();
        }

        return null;
    }


    public static void printTime(String msg) {
        System.out.println("Time: (" + System.currentTimeMillis() + ") " + msg);
    }

    public static String toString(Object[] array) {
        String s = "[Array ";
        if(array != null && array.length > 0) {
            s += array[0];
            for(int i = 1; i < array.length; i++)
                s += "," + array[i];
        }
        s += "]";

        return s;
    }

    public static Node getAsNode(String in) {
        try {
            org.apache.xerces.parsers.DOMParser parser =
                new org.apache.xerces.parsers.DOMParser();

            parser.setErrorHandler(new ErrorHandler() {
                public void warning(SAXParseException exception) {
                    if(DEBUG) System.err.println(exception);
                }

                public void error(SAXParseException exception) {
                    if(DEBUG) System.err.println(exception);
                }

                public void fatalError(SAXParseException exception) {
                    if(DEBUG) System.err.println(exception);
                }
            });

            parser.parse(new org.xml.sax.InputSource(
                new StringReader(in)));

            return parser.getDocument().getDocumentElement();
        } catch(Exception e) {
            //System.out.println("Invalid XML " + in + " " + e);
            //e.printStackTrace();
        }

        return null;
    }

    public static boolean getBoolean(String str) {
        return (str == null) ? false :
                str.toLowerCase().equals("true") ||
                str.equals("1");
    }

    public static String toString(boolean b) {
        return b ? "true" : "false";
    }

    public static String readURL(URL fileURL) throws IOException {
        return readAll(new InputStreamReader(fileURL.openStream()));
    }

    public static String readFile(String fileName) throws FileNotFoundException, IOException {
        return readAll(new FileReader(fileName));
    }

    public static String readAll(Reader reader) throws IOException {
        StringBuffer buffer = new StringBuffer();

        BufferedReader in = new BufferedReader(reader);
        int ch;
        while ((ch = in.read()) > -1) {
            buffer.append((char)ch);
        }
        in.close();

        return buffer.toString();
    }

    public static String formatXML( Node node ) {
        try {
            StringWriter out = new StringWriter();
            Document doc = node.getOwnerDocument();
            OutputFormat format  = new OutputFormat( doc );
            format.setIndenting( true );
            format.setLineWidth( 0 );
            format.setPreserveSpace( false );
            format.setOmitXMLDeclaration( false );

            XMLSerializer serial = new XMLSerializer( out, format );
            serial.asDOMSerializer();

            serial.serialize( doc );

            return out.toString();
        }
        catch( IOException e ) {
            System.err.println( "Problem serializing node " + e );

            return "Problem serializing node " + e;
        }
    }

    public static String formatRDF(String rdf) {
        Node node = getAsNode(rdf);

        if(node == null)
            return rdf;
        else
            return formatNode(node, " ").substring(System.getProperty("line.separator").length());
    }


    public static String formatNode(Node node, String indent) {
        String str = "";
        int type = node.getNodeType();

        if(type == Node.TEXT_NODE) {
            str = node.getNodeValue().trim();
        }
        else if(type == Node.ELEMENT_NODE) {
            if(!(node.getParentNode() instanceof org.w3c.dom.Document))
                str = System.getProperty("line.separator") + indent + node.getLocalName() + ": ";

            NodeList children = node.getChildNodes();
            int len = (children != null) ? children.getLength() : 0;

            for (int i = 0; i < len; i++) {
                str += formatNode(children.item(i), indent + "  ");
            }
            if(len == 0) {
                Node rdfResource = node.getAttributes().getNamedItemNS(RDF.getURI().toString(), "resource");

                if(rdfResource instanceof Attr)
                    str += URIUtils.getLocalName(((Attr)rdfResource).getValue());

            }
        }

        return str;
    }
}