JetWebXMLReader.java

Go to the documentation of this file.

package cedar.jetweb.xml;

import cedar.jetweb.util.JetWebFile;
import org.jdom.Document;
import org.jdom.JDOMException;
import org.jdom.input.*;
import org.xml.sax.*;
    
//import org.jdom.input.SAXBuilder;;


import java.io.*;
import java.util.zip.GZIPInputStream;

public class JetWebXMLReader {
    protected static final String NAMESPACES_FEATURE_ID = "http://xml.org/sax/features/namespaces";

    protected static final String VALIDATION_FEATURE_ID = "http://xml.org/sax/features/validation";

    protected static final String SCHEMA_VALIDATION_FEATURE_ID = "http://apache.org/xml/features/validation/schema";

    protected static final String SCHEMA_FULL_CHECKING_FEATURE_ID = "http://apache.org/xml/features/validation/schema-full-checking";
    
    protected static final String DYNAMIC_VALIDATION_FEATURE_ID = "http://apache.org/xml/features/validation/dynamic";
    
    protected static final String LOAD_EXTERNAL_DTD_FEATURE_ID = "http://apache.org/xml/features/nonvalidating/load-external-dtd";

    // default settings

    protected static final String DEFAULT_PARSER_NAME = "org.apache.xerces.parsers.SAXParser";

    protected static final boolean DEFAULT_NAMESPACES = true;

    protected static final boolean DEFAULT_VALIDATION = false;
    
    protected static final boolean DEFAULT_LOAD_EXTERNAL_DTD = true;

    protected static final boolean DEFAULT_SCHEMA_VALIDATION = false;

    protected static final boolean DEFAULT_SCHEMA_FULL_CHECKING = false;
    
    protected static final boolean DEFAULT_DYNAMIC_VALIDATION = false;

    protected static final boolean DEFAULT_CANONICAL = false;

  
    private String filename;
    private Document doc;

    private boolean validate = false;
    private boolean validateSchema = false;

    public JetWebXMLReader(String filename) throws JetWebXMLException {
        // Load filename
        this.filename = filename;

        // Create an instance 
    try {
        //validation switched off
        SAXBuilder builder = new SAXBuilder(DEFAULT_PARSER_NAME,false);
        //read the document and read in the plot element
        try {
        builder.setFeature(LOAD_EXTERNAL_DTD_FEATURE_ID, false);
        builder.setFeature(VALIDATION_FEATURE_ID, false);
        builder.setFeature(DYNAMIC_VALIDATION_FEATURE_ID, false);
        builder.setFeature(SCHEMA_VALIDATION_FEATURE_ID, false);

        }
        catch (Exception e) {
        System.err.println("warning: Parser does not support feature ("
                   +LOAD_EXTERNAL_DTD_FEATURE_ID+")");
        }
        /*
        builder.setEntityResolver(new EntityResolver()
        {
            public InputSource resolveEntity(String publicId, String systemId)
            {
                return new InputSource(
                           new ByteArrayInputStream("<?xml version='1.0' encoding='UTF-8'?>".getBytes()));
            }
        });
        */
        doc = builder.build(filename);
        
    } catch (Exception e) {
        //System.out.println(e);
        throw new JetWebXMLException(e);
    }    
    
    }//JetWebXMLReader(String)

    public JetWebXMLReader(String fname,boolean zipped) throws JetWebXMLException {
        // Load filename
        this.filename = fname;

    //first check that file exists
    if (!exists(filename)){
        throw new JetWebXMLException("XMLFileReader: file not found","Name was: "+filename);
    }

    String val =System.getProperty("validateXML");
    if ( val!=null && val.equalsIgnoreCase("true")){
        validate =true;
    }
    String valS =System.getProperty("validateSchema");
    if ( valS!=null && valS.equalsIgnoreCase("true")){
        validateSchema =true;
    }

    //testing 
    //validate=true;

    if (validate || validateSchema){
        String newFilename=filename;
        if (zipped){
        newFilename =getUnzippedSource(filename).getPath();
        } 

        String[] args=new String[]{"-v","-s",newFilename};

        System.out.println("About to call dom.Writer.main");

        //dom.Writer.main(args);

        System.out.println("Success!");

        //JDOM validation is really crap, I give up!
        //buildAndValidate(filename,zipped,DEFAULT_PARSER_NAME);
        //return;
    }


         
    try {
        //validation switched off
        SAXBuilder builder = new SAXBuilder(DEFAULT_PARSER_NAME,false);
        if (zipped){
        readZipped(builder,filename);
        return;
        }
        doc = builder.build(filename);
        
    } catch (Exception e) {
        //System.out.println(e);
        throw new JetWebXMLException(e);
    }    
    
    }//JetWebXMLReader(String,boolean,boolean)

    private void buildAndValidate(String filename,boolean zipped,String inputParserName) throws JetWebXMLException {

        // Load filename 
        this.filename = filename;

    boolean validation = validate;
    boolean schemaValidation = validateSchema;
    boolean schemaFullChecking = validateSchema;


    boolean namespaces = DEFAULT_NAMESPACES;
    boolean externalDTD = DEFAULT_LOAD_EXTERNAL_DTD;
    boolean dynamicValidation = DEFAULT_DYNAMIC_VALIDATION;
    boolean canonical = DEFAULT_CANONICAL;

    String parserName;

    if (inputParserName==null){
        parserName=DEFAULT_PARSER_NAME;
    } else {
        parserName=inputParserName;
    }
    
    try {

        //validation switched on
        SAXBuilder parser = new SAXBuilder(parserName,true);
        
        // set parser features
        try{
        parser.setFeature(NAMESPACES_FEATURE_ID, namespaces);
        }
        catch (Exception e) {
        System.err.println
            ("warning: Parser does not support feature (" + 
             NAMESPACES_FEATURE_ID + ")");
        }
        try {
        parser.setFeature(VALIDATION_FEATURE_ID, validation);
        }
        catch (Exception e) {
        System.err.println("warning: Parser does not support feature ("+VALIDATION_FEATURE_ID+")");
        }
        try {
        parser.setFeature(LOAD_EXTERNAL_DTD_FEATURE_ID, externalDTD);
        }
        catch (Exception e) {
        System.err.println("warning: Parser does not support feature ("+LOAD_EXTERNAL_DTD_FEATURE_ID+")");
        }
        try {
        parser.setFeature(SCHEMA_VALIDATION_FEATURE_ID, schemaValidation);
        }
        catch (Exception e) {
        System.err.println("warning: Parser does not support feature ("+SCHEMA_VALIDATION_FEATURE_ID+")");
        }
        try {
        parser.setFeature(SCHEMA_FULL_CHECKING_FEATURE_ID, schemaFullChecking);
        }
        catch (Exception e) {
        System.err.println("warning: Parser does not support feature ("+SCHEMA_FULL_CHECKING_FEATURE_ID+")");
        }
        try {
        parser.setFeature(DYNAMIC_VALIDATION_FEATURE_ID, dynamicValidation);
        }
        catch (Exception e) {
        System.err.println("warning: Parser does not support feature ("+DYNAMIC_VALIDATION_FEATURE_ID+")");
        }

         if (zipped){
         doc = parser.build(getUnzippedSource(filename));

        } else {
        doc = parser.build(filename);
        }
         

    } catch (Exception e) {
        System.out.println(e);
        throw new JetWebXMLException(e);
    }    
    
    }//validate

    private File getUnzippedSource(String filename) throws JetWebXMLException {

    File tempFile = null;
    JetWebFile testFile = new JetWebFile(filename);
    try {
        tempFile = File.createTempFile("tmp",".tmp",new File("xml"));
        tempFile.deleteOnExit();
        if (testFile.isZipped()){
        BufferedReader reader = new BufferedReader(
                    new InputStreamReader(
                        new GZIPInputStream(
                    new FileInputStream(filename))));

        PrintWriter writer = new PrintWriter(
                     new BufferedWriter(
                     new OutputStreamWriter(
                     new FileOutputStream(tempFile))));         

        String line;

        while ((line=reader.readLine())!=null){
            //write line to temp file
            writer.println(line);
        }
        writer.close();
        reader.close();

            
        } else {
        throw new JetWebXMLException("XMLFile error: unzipped file.",filename);
        
        }
            
            
    } catch (java.io.IOException e1) {
        System.out.println("XMLReader: Problem reading file "+e1);  
        System.out.println("File should be "+filename); 
        System.out.println("Ought to delete this - no files exist!");   
        throw new JetWebXMLException(e1);
        //valid(false);
    }   
    
    return tempFile;
    }
    
    private void readZipped(SAXBuilder builder,String filename) throws JetWebXMLException {

    JetWebFile testFile = new JetWebFile(filename);

    try {
        if (testFile.isZipped()){
            // Load filename 
        this.filename = filename;

            // Create an instance 
            //SAXBuilder builder = new SAXBuilder(DEFAULT_PARSER_NAME,false);
            //read the document and read in the plot element
        doc = builder.build(new java.util.zip.GZIPInputStream
                    (new java.io.FileInputStream(filename)));
        } else {
            throw new JetWebXMLException
            ("XMLFile error: unzipped file.",filename);
            
        }


        } catch (JDOMException e) {
        //System.out.println(e);
        throw new JetWebXMLException(e);
        } catch (java.io.IOException e1) {
        System.out.println("XMLReader: Problem reading file "+e1);  
        System.out.println("File should be "+filename); 
        System.out.println("Ought to delete this - no files exist!");   
        //valid(false);
        }   
            
        
    
    }//readZipped

    
    
    

    protected Document getDocument() {
    //if (doc==null) throw new JetWebXMLException("XML Reader not initialised: Document is null",null);
    return doc;
    }
    protected String getFileName()  {
    //if (filename==null) throw new JetWebXMLException("XML Reader not initialised: No Filename provided",null);
    return filename;
    }

    private boolean exists(String filename){
    boolean exists=false;
    JetWebFile test = new JetWebFile(filename);
    return test.exists();

    }
}//JetWebXMLReader

Generated Wed Jan 17 09:14:27 GMT 2007