Metacat

package edu.ucsb.nceas.metacat;

import java.net.URL;

import java.net.MalformedURLException;

import java.util.*;

import java.io.*;

import java.lang.reflect.*;

import org.w3c.dom.*;

import org.xml.sax.*;

import org.xml.sax.Parser;

import com.arbortext.catalog.*;

/**

 * Name: GenericXMLValidate.java

 *       Purpose: A Class that validates XML documents

 * 			   This class is designed to be 'parser independent

 *    			   i.e. it uses only org.xml.sax classes

 * 			   It is tied to SAX 1.0 methods

 *     Copyright: 2000 Regents of the University of California and the

 *                National Center for Ecological Analysis and Synthesis

 *                April 28, 2000

 * 

 * @author Dan Higgins

 * @version 1.0

 */

public class GenericXMLValidate{

    static int WARNING = 0;

    static int ERROR=1;

    static int FATAL_ERROR=2;

    static String defaultCatalog = "/home/httpd/html/xmltodb/catalog.txt";   

    Parser parser;

    ErrorStorer ef;

    String xml_doc; // document to be parsed

    public GenericXMLValidate( Parser parse)  {

        parser = parse;

        CatalogEntityResolver cer = new CatalogEntityResolver();

        try {

            Catalog myCatalog = new Catalog();

            myCatalog.loadSystemCatalogs();

            myCatalog.parseCatalog(defaultCatalog);

            cer.setCatalog(myCatalog);

        }

        catch (Exception e) {System.out.println("Problem creating Catalog!");}

        parser.setEntityResolver(cer);

/*            Class defaultParserClass = Class.forName(DEFAULT_PARSER_NAME);

            Object par = defaultParserClass.newInstance();

            Class[] parameterTypes = new Class[] {boolean.class};

            Method set_validation;

            Object[] arguments = new Object[] {new Boolean(true)};

            try {

                  set_validation = defaultParserClass.getMethod("setValidationMode", parameterTypes);

                  set_validation.invoke(par, arguments);

                } catch (NoSuchMethodException e) {

                    System.out.println(e);

                } catch (IllegalAccessException e) {

                    System.out.println(e);

                } catch (InvocationTargetException e) {

                    System.out.println(e);

                }

            parser = (Parser)par;

*/

    }

    public boolean validate(String doc) {

        xml_doc = doc;    

        ef = new ErrorStorer();

        ef.resetErrors();

        parser.setErrorHandler(ef);

        try {

            parser.parse((createURL(xml_doc)).toString());

        }

        catch (IOException e) {

            System.out.println("IOException:Could not parse :"+xml_doc);

            ParseError eip = null;

            eip = new ParseError("",0,0,"","IOException:Could not parse :"+xml_doc);

            if (ef.errorNodes == null)  ef.errorNodes = new Vector();

            ef.errorNodes.addElement(eip);

        } catch (Exception e) {} // {System.out.println("Exception parsing:Could not parse :"+xml_doc);} 

        if (ef != null && ef.getErrorNodes()!=null && ef.getErrorNodes().size() > 0 ) {

            return false; 

        }

        else {return true;}

    }

    public boolean validateString(String xmldoc) {

    // string is actual XML here, NOT URL or file name    

        ef = new ErrorStorer();

        ef.resetErrors();

        parser.setErrorHandler(ef);

        InputSource is = new InputSource(new StringReader(xmldoc));

        try {

            parser.parse(is);

        }

        catch (Exception e) {System.out.println("Error in parsing!");}

        if (ef != null && ef.getErrorNodes()!=null && ef.getErrorNodes().size() > 0 ) {

            return false; 

        }

        else {return true;}

    }

    public String returnErrors() {

        String errorstring = "";

        if (ef != null && ef.getErrorNodes()!=null && ef.getErrorNodes().size() > 0 ) {

            Vector errors = ef.getErrorNodes();

            for (Enumeration e = errors.elements() ; e.hasMoreElements() ;) {

                errorstring = errorstring +((ParseError)(e.nextElement())).getMsg()+"\n";

                errorstring = errorstring + "----\n";

            }

        }

        else {errorstring = "No errors were detected!!!";}

        return errorstring;

    }

    //

    // Create a URL object from either a URL string or a plain file name.

    //

    private URL createURL(String name) throws Exception {

        try {

                URL u = new URL(name);

                return u;

        } catch (MalformedURLException ex) {

        }

        URL u = new URL("file:" + new File(name).getAbsolutePath());

        return u;

    }    

    /**

     * ErrorStorer has been revised here to simply create a Vector of 

     * ParseError objects

     *

     */

    class ErrorStorer 

        implements ErrorHandler

    {

        //

        // Data

        //

        Vector errorNodes = null;

        /**

         * Constructor

         */

        public ErrorStorer() {

        }

        /**

         * The client is is allowed to get a reference to the Hashtable,

         * and so could corrupt it, or add to it...

         */

        public Vector getErrorNodes() {

            return errorNodes;

        }

        /**

         * The ParseError object for the node key is returned.

         * If the node doesn't have errors, null is returned.

         */

        public Object getError() {

            if (errorNodes == null)

                return null;

            return errorNodes;

        }

        /**

         * Reset the error storage.

         */

        public void resetErrors() {

            if (errorNodes != null)

            errorNodes.removeAllElements();

        }

        /***/

        public void warning(SAXParseException ex) {

            handleError(ex, WARNING);

        }

        public void error(SAXParseException ex) {

            handleError(ex, ERROR);

        }

        public void fatalError(SAXParseException ex) throws SAXException {

            handleError(ex, FATAL_ERROR);

        }

        private void handleError(SAXParseException ex, int type) {

   //         System.out.println("!!! handleError: "+ex.getMessage());

            StringBuffer errorString = new StringBuffer();

            errorString.append("at line number, ");

            errorString.append(ex.getLineNumber());

            errorString.append(": ");

            errorString.append(ex.getMessage());

            if (errorNodes == null)  errorNodes = new Vector();

            ParseError eip = null;

            eip = new ParseError(ex.getSystemId(),ex.getLineNumber(),ex.getColumnNumber(),"",errorString.toString());

            // put it in the Hashtable.

            errorNodes.addElement(eip);

        }

    }

    /**

     * The ParseError class wraps up all the error info from

     * the ErrorStorer's error method.

     *

     * @see ErrorStorer

     */

    class ParseError extends Object {

        //

        // Data

        //

        String fileName;

        int lineNo;

        int charOffset;

        Object key;

        String msg;

        /**

         * Constructor

         */

        public ParseError(String fileName, int lineNo, int charOffset,

                           Object key, 

                           String msg)

        {

            this. fileName=fileName;

            this. lineNo=lineNo;

            this. charOffset=charOffset;

            this. key=key;

            this. msg=msg;

        }

        //

        // Getters...

        //

        public String getFileName() { return fileName; }

        public int getLineNo() { return lineNo; }

        public int getCharOffset() { return charOffset;}

        public Object getKey() { return key; }

        public String getMsg() { return msg; }

        public void setMsg(String s) { msg = s; }

    }

}