Changeset 18434 for greenstone3/trunk/src/java/org/greenstone/gsdl3/util/XMLConverter.java

Timestamp:

2009-01-30T16:58:40+13:00 (15 years ago)

Author:

max

Message:

1. Provides a new DOM method that allows a document to be created with a specified DOCTYPE.
2. Reusable ErrorHandler class for parsing, that will deal with warnings, fatal and regular errors that may occur when parsing XML.
3. XMLConverter's parse object has an ErrorHandler attached to it when initialised.

File:

• greenstone3/trunk/src/java/org/greenstone/gsdl3/util/XMLConverter.java (modified) (6 diffs)

greenstone3/trunk/src/java/org/greenstone/gsdl3/util/XMLConverter.java

@@ -20 +20 @@
 
 // XML classes
+import org.w3c.dom.DOMImplementation;
 import org.w3c.dom.Document; 
 import org.w3c.dom.DocumentType; 
@@ -28 +29 @@
 import org.xml.sax.InputSource;
 import org.xml.sax.EntityResolver;
+import org.xml.sax.ErrorHandler;
+import org.xml.sax.SAXParseException;
 import org.apache.xerces.parsers.DOMParser;
-import org.apache.xerces.dom.DocumentImpl; // for new Documents
+import org.apache.xerces.dom.*; // for new Documents
 
 // other java classes
@@ -70 +73 @@
         // http://www.sosnoski.com/opensrc/xmlbench/conclusions.html
         this.parser.setFeature("http://apache.org/xml/features/dom/defer-node-expansion", false);
+        // add an errorhandler to the parser which will store useful a error message on encountering fatal errors, errors and warnings when parsing
+        // this errormessage can then be converted to xhtml and displayed in a browser.
+        this.parser.setErrorHandler(new ParseErrorHandler());
     } catch (Exception e) {
         logger.error(e.getMessage());
@@ -163 +169 @@
     return doc;
     }
+    
+    /**
+     * This method's parameters represent the parts of the Doctype of this
+     * Document that is to be created.
+     * For more info see 
+     * http://xerces.apache.org/xerces-j/apiDocs/org/apache/xerces/dom/DocumentTypeImpl.html#DocumentTypeImpl(org.apache.xerces.dom.CoreDocumentImpl,%20java.lang.String)
+     * 
+     * */
+    public static Document newDOM(String qualifiedName, String publicID, String systemID) {
+        // create empty DOM document
+        DocumentImpl docImpl = new DocumentImpl(); 
+        
+        // Need to use the document to create the docType for it
+        DocumentType myDocType = new DocumentTypeImpl(docImpl, qualifiedName, publicID, systemID);
+        
+        // Although we have created the docType using the document, we need to still 
+        // put it into the empty document we just created 
+        try{
+            docImpl.appendChild(myDocType);
+        } catch(Exception e) {
+            System.out.println("Could not append docType because: " + e) ;      
+        }
+        
+        // return the document containing a DocType
+        return docImpl;     
+    }
 
     /** returns the Node as a String */
@@ -199 +231 @@
         Document xmlDocNode = (Document)xmlNode;
         
-        if (xmlDocNode.getDoctype() == null) {
-        System.err.println("Doctype is null.");
-        }
-        else {
-        
+        //if (xmlDocNode.getDoctype() == null) {
+        //System.err.println("Doctype is null.");
+        //}
+        //else {
+        if (xmlDocNode.getDoctype() != null) {
         DocumentType dt = xmlDocNode.getDoctype();
         
@@ -378 +410 @@
     return type;
     }
+    
+    // returns null if there no error occurred during parsing, or else returns the error message
+    public String getParseErrorMessage() {
+        ParseErrorHandler errorHandler = (ParseErrorHandler)this.parser.getErrorHandler();
+        return errorHandler.getErrorMessage();
+    }
+    
+    // Errorhandler for SAXParseExceptions that are errors, fatal errors or warnings. This class can be used to 
+    // register a handler for any fatal errors, errors and warnings that may occur when parsing an xml file. The
+    // errors are printed both to the greenstone.log and to the tomcat console (System.err), and the error message
+    // is stored in the errorMessage variable so that it can be retrieved and be used to generate an xhtml error page.
+    static public class ParseErrorHandler implements ErrorHandler {
+        protected String errorMessage = null;
+    
+        //  Receive notification of a recoverable error.
+        public void error(SAXParseException exception) {
+            handleError("Error:\n", exception);
+        }
+        //   Receive notification of a non-recoverable error.
+        public void fatalError(SAXParseException exception) {
+            handleError("Fatal Error:\n", exception);
+        }
+        // Receive notification of a warning.
+        public void warning(SAXParseException exception) {
+            handleError("Warning:\n", exception);
+        }
+        
+        public String toString(SAXParseException e) {
+            String msg = e.getMessage();
+            msg += "\nOn line(column): " + e.getLineNumber() + "(" + e.getColumnNumber() + ")";
+            msg += (e.getPublicId() != null) ? ("\npublic ID: " + e.getPublicId()) : "\nNo public ID";
+            msg += (e.getSystemId() != null) ? ("\nsystem ID: " + e.getSystemId()) : "\nNo system ID";
+                    
+            return msg;
+        }
+        
+        // clears the errorPage variable after first call to this method
+        public String getErrorMessage() {
+            String errMsg = this.errorMessage;
+            if(this.errorMessage != null) {
+                this.errorMessage = null;
+            }
+            return errMsg;
+        }
+        
+        // sets the errorMessage member variable to the data stored in the exception
+        // and writes the errorMessage to the logger and tomcat's System.err
+        protected void handleError(String errorType, SAXParseException exception) {
+            this.errorMessage = errorType + toString(exception); 
+            System.err.println("\n****Error parsing xml:\n" + this.errorMessage + "\n****\n");
+            logger.error(this.errorMessage);
+        }
+    }
 }