src/dochelper/Main.java

Go to the documentation of this file.

/*
 * Main.java
 *
 * Created on February 3, 2009, 3:33 PM
 *
 * To change this template, choose Tools | Template Manager
 * and open the template in the editor.
 */

package dochelper;

import dochelper.exceptions.DocumentParseException;
import dochelper.exceptions.IllegalParamterTypeException;
import dochelper.exceptions.InitializationException;
import dochelper.exceptions.InvalidValueException;
import dochelper.exceptions.MissingArgumentException;
import dochelper.exceptions.ResourceUnavailableException;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.net.URI;
import java.net.URL;
import java.net.URLClassLoader;

import java.util.ArrayList;
import java.util.Hashtable;
import java.util.List;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.DocumentBuilder;

import javax.xml.parsers.ParserConfigurationException;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;


public class Main {
    
    private static final String USAGE = "DocHelper v 1.0. Usage: \n "
                                      + "  Usage: java -jar dochelper.jar [args...] \n "
                                      + "         java -jar dochelper.jar [path to docdef] \n\n"
                                      + "  where args are: \n"
                                      + "  docdef: Document Definition file that follows the Dochelper standard. This \n" 
                                      + "          is a required argument.\n\n";


    private static final String ERROR = "There was an error parsing the document definition file.\n"
                                      + "Please check the file and try again. Error Info : ";
    
    public Main() {
    }

    static String docdefPath;
    static final String PKG = "dochelper.";

    //Hold a reference to each instance keyed on Name
    static Hashtable<String, DocPattern> patterns = new Hashtable();
    static Hashtable<String, RecordSet> recordsets = new Hashtable();
    static Hashtable<String, Renderer> renderers = new Hashtable();
    static Hashtable<String, Processor> processors = new Hashtable();
    static ArrayList<DocumentDefinition> documents = new ArrayList();
    public static void main(String[] argv) throws ParserConfigurationException, SAXException, IOException {
        
        //STEP 0: Make sure that the parameters that were passed in are valid:
        // argv[0] - Document Definition
        // argv[1] - Temp dir, optional
        checkParams(argv);

        //STEP 1: get the Document Definition File
        File xmlDefinition = new File(docdefPath);
        DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
        DocumentBuilder db = dbf.newDocumentBuilder();
        Document doc = db.parse(xmlDefinition);
        doc.getDocumentElement().normalize();

        //STEP 2: Parse the Document Definition file generating a list of documents
        try {
            parseDocumentDefintion(doc);
        }
        catch(DocumentParseException dpe) {
            System.err.println(ERROR + dpe.getMessage());
            System.exit(1);
        }
        catch(InvalidValueException ive) {
            System.err.println(ERROR + ive.getMessage());
            System.exit(1);
        }
        catch(IllegalParamterTypeException ilpe) {
            System.err.println(ERROR + ilpe.getMessage());
            System.exit(1);
        }
        catch(MissingArgumentException mae) {
            System.err.println(ERROR + mae.getMessage());
            System.exit(1);
        }


        //STEP 3: invoke the execute method of the documents
        for(DocumentDefinition document : documents) {

            //execute the document
            document.execute();

            //perform any transform
            document.executeProcessors();

            //perform rendering
            document.render();

        }
        
    }
    
    static void checkParams(String argv[]) {
        
            try {
                
                if(argv.length == 0 || argv[0] == null || argv[0].length() < 1) {
                    System.out.println("Error: Document Definition File not specified\n");
                    System.out.println(USAGE);
                    System.exit(1);
                }
                
                File f = new File(argv[0]);
                
                if(!f.isFile()) {
                    System.out.println("Error: Document Definition File not valid\n");
                    System.out.println(USAGE);                    
                    System.exit(1);
                }
                
                //Doc Def Ok
                docdefPath = argv[0];
                
            }
            catch(Exception e) {
                System.out.println(USAGE);
                e.printStackTrace();
                return;
            }
        
    }

    //TODO: Handle Exceptions?
    static void parseDocumentDefintion(Document doc) throws DocumentParseException, InvalidValueException,
                                        IllegalParamterTypeException, MissingArgumentException, ResourceUnavailableException {

        //Make Patterns
        NodeList nodeList = doc.getElementsByTagName("pattern");

        for (int i = 0; i < nodeList.getLength(); i++) {
            Element node = (Element)nodeList.item(i);
            DocPattern p = parsePattern(node);
            p.setName(node.getAttribute("name"));
            patterns.put(node.getAttribute("name"), p);
        }

        //Make record sets
        nodeList = doc.getElementsByTagName("recordset");

        for (int i = 0; i < nodeList.getLength(); i++) {
            Element node = (Element)nodeList.item(i);
            RecordSet r = parseRecordSet(node, node.getAttribute("name"));            
            recordsets.put(node.getAttribute("name"), r);
        }

        //Make Processors
        nodeList = doc.getElementsByTagName("processor");

        for (int i = 0; i < nodeList.getLength(); i++) {
            Element node = (Element)nodeList.item(i);
            Processor p = parseProcessor(node);

            processors.put(node.getAttribute("name"), p);

        }

        //Make Renderers
        nodeList = doc.getElementsByTagName("renderer");

        for (int i = 0; i < nodeList.getLength(); i++) {
            Element node = (Element)nodeList.item(i);
            Renderer r = parseRenderer(node);
            renderers.put(node.getAttribute("name"), r);
        }

        //Make Documents
        nodeList = doc.getElementsByTagName("documentdef");

        for (int i = 0; i < nodeList.getLength(); i++) {

            Element dElem = (Element)nodeList.item(i);
            DocumentDefinition document = new DocumentDefinition(dElem.getAttribute("name"));

            //get all referenced record sets
            NodeList rss = dElem.getElementsByTagName("recordsetref");

            for(int j=0;j<rss.getLength(); j++) {

                Element rElem = (Element)rss.item(j);
                String rsName = rElem.getAttribute("name");
                
                //Fetch the recordset from the reference
                RecordSet rs = recordsets.get(rsName);

                //clear patterns
                rs.clearPatterns();

                //add all the referenced patterns
                NodeList ps = rElem.getElementsByTagName("patternref");
                
                for(int h = 0; h < ps.getLength(); h++) {

                    Element pElem = (Element)ps.item(h);
                    String pName = pElem.getAttribute("name");

                    //fetch the ppatern
                    DocPattern pattern = patterns.get(pName);

                    //add the pattern to the record set
                    rs.addPattern(pattern);

                }

                //add the rs to the document definition
                document.addRecordSet(rs);

            }

            //get all referenced processors
            NodeList processorrefs = dElem.getElementsByTagName("processorref");
            for(int j=0;j<processorrefs.getLength(); j++) {

                Element rElem = (Element)processorrefs.item(j);

                //Fetch the processor from the reference
                String key = rElem.getAttribute("name") + "||" +  ( (Element)rElem.getParentNode()).getAttribute("name");

                Processor processor = processors.get(rElem.getAttribute("name"));
                document.addProcessor(key, processor);

            }


            //get all referenced renderers
            NodeList renderrefs = dElem.getElementsByTagName("renderref");
            for(int j=0;j<renderrefs.getLength(); j++) {

                Element rElem = (Element)renderrefs.item(j);
                String rName = rElem.getAttribute("name");

                //Fetch the renderer from the reference
                Renderer renderref = renderers.get(rName);
                document.addRenderer(renderref);

            }

            //add the document to the document list
            documents.add(document);
        }
        
    }
   
    private static DocPattern parsePattern(Element node) throws DocumentParseException {

        String name = "";
        name = node.getAttribute("name");

        try {
            //STEP 1: Make the transform defintion
            NodeList tList = node.getElementsByTagName("transform");
            Element tElement = (Element)tList.item(0);

            String className = tElement.getAttribute("class");
            Class cons_param_types[] = {String.class};
            Class transformClass = Class.forName(PKG + className);
            String tValue = tElement.getTextContent();

            //file or regular
            if(className.equals("FileTransformDefinition"))
                tValue = tElement.getAttribute("file");

            //get the appropriate constructor
            Object cons_args[] = {tValue};
            Constructor constructor = transformClass.getDeclaredConstructor(cons_param_types);

            //make the transform
            TransformDefinition ndi = (TransformDefinition)constructor.newInstance(cons_args);

            //STEP 2: get the expression for the pattern
            tList = node.getElementsByTagName("expression");
            tElement = (Element)tList.item(0);

            //Instantiate a Pattern
            DocPattern p = new DocPattern(tElement.getTextContent(), ndi);

            //set the name
            p.setName(node.getAttribute("name"));

            return p;
        }
        catch(ClassNotFoundException cnfe ) {
            String error = "No class was found for the transform specified for pattern : " + name;
            throw new DocumentParseException(error + "\n" + cnfe.getMessage());
        }
        catch(NoSuchMethodException nsme) {
            String error = "The class for the transform specified for pattern : " + name;
            error += " does not contain an appropriate constructor.";
            throw new DocumentParseException(error + "\n" + nsme.getMessage());
        }
        catch(Exception ie) {
            String error = "Error instantiating transform specified for pattern : " + name;
            throw new DocumentParseException(error + "\n" + ie.getMessage());
        }
    }

    private static Processor parseProcessor(Element node)  throws DocumentParseException, InvalidValueException,
                                        IllegalParamterTypeException, MissingArgumentException, ResourceUnavailableException {
        return (Processor)parseConfigurable(node);
    }

    private static RecordSet parseRecordSet(Element node, String name) throws DocumentParseException, InvalidValueException,
                                        IllegalParamterTypeException, MissingArgumentException, ResourceUnavailableException {

        //STEP 1: Instantiate the Record Set
        String className = node.getAttribute("class");        
        Class cons_param_types[] = {String.class};
        Class rsClass;
        Constructor constructor;
        RecordSet rs;

        try {
            rsClass = Class.forName(PKG + className);

            //get the appropriate constructor
            constructor = rsClass.getDeclaredConstructor();

            //make the Record Set
            rs = (RecordSet)constructor.newInstance();
        }
        catch(ClassNotFoundException cnfe ) {
            String error = "The class " + className + " was not found. Unable to create RecordSet. ";
            throw new DocumentParseException(error + "\n" + cnfe.getMessage());
        }
        catch(NoSuchMethodException nsme) {
            String error = "An appropriate constructor was not found in class " + className;
            error += " unable to create RecordSet.";
            throw new DocumentParseException(error + "\n" + nsme.getMessage());
        }
        catch(Exception ie) {
            String error = "Error instantiating RecordSet : " + className;
            throw new DocumentParseException(error + "\n" + ie.getMessage());
        }        
        //set the name
        rs.setName(name);

        //STEP 2: Set params
        NodeList params = node.getElementsByTagName("param");
        for(int i = 0; i<params.getLength(); i++) {
            Element param = (Element)params.item(i);
            rs.setParam(param.getAttribute("name"), param.getTextContent());
        }
        
        //STEP 3: Check Param and Init Record Set
        rs.checkParams();

        //Initialize the Record Set, may throw InitializationException (Unchecked)
        rs.init();

        return rs;

    }

    private static Renderer parseRenderer(Element node) throws DocumentParseException, InvalidValueException, 
                                 IllegalParamterTypeException, MissingArgumentException, ResourceUnavailableException {

        //STEP 1: create renderer from configurable
        Renderer render = (Renderer)parseConfigurable(node);

        //STEP 2: Set Document Sections
        NodeList docsections = node.getElementsByTagName("docsection");

        for(int i = 0; i< docsections.getLength(); i++) {

            Element docsection = (Element)docsections.item(i);
            DocumentSection section = null;

            String file = docsection.getAttribute("file");
            if(file!=null && file.length() > 1) {
                try {
                    section = new DocumentSection(new File(file));
                }
                catch(FileNotFoundException fnfe) {
                    String error = "Error creating document section from file : " + file;
                    error += " File was not found";
                    throw new DocumentParseException(error);
                }
                catch(IOException ioe) {
                    String error = "Error creating document section from file : " + file;
                    error += " Error reading file.";
                    throw new DocumentParseException(error);
                }
            }
            else {
                String start = docsection.getFirstChild().getTextContent();
                String end = docsection.getLastChild().getTextContent();
                section = new DocumentSection(start, end);
            }

            render.addDocumentSection(section, docsection.getAttribute("ref"));
        }

        return render;
    }

    private static Configurable parseConfigurable(Element node) throws DocumentParseException, InvalidValueException,
                                        IllegalParamterTypeException, MissingArgumentException, ResourceUnavailableException {

        //STEP 1: Instantiate the Record Set
        String className = node.getAttribute("class");
        String name = node.getAttribute("name");

        Class cons_param_types[] = {String.class};
        Class rsClass;
        Constructor constructor;
        Configurable rs;

        try {
            rsClass = Class.forName(PKG + className);

            //get the appropriate constructor
            constructor = rsClass.getDeclaredConstructor();

            //make the Record Set
            rs = (Configurable)constructor.newInstance();
        }
        catch(ClassNotFoundException cnfe ) {
            String error = "The class " + className + " was not found. Unable to create Configurable " + name;
            throw new DocumentParseException(error + "\n" + cnfe.getMessage());
        }
        catch(NoSuchMethodException nsme) {
            String error = "An appropriate constructor was not found in class " + className;
            error += " unable to create Configurable " + name + ". ";
            throw new DocumentParseException(error + "\n" + nsme.getMessage());
        }
        catch(Exception ie) {
            String error = "Error instantiating Configurable " + name + " : " + className;
            throw new DocumentParseException(error + "\n" + ie.getMessage());
        }

        //STEP 2: Set params
        NodeList params = node.getElementsByTagName("param");
        for(int i = 0; i<params.getLength(); i++) {
            Element param = (Element)params.item(i);
            rs.setParam(param.getAttribute("name"), param.getTextContent());
        }

        //STEP 3: Check Param and Init Record Set
        rs.checkParams();

        //Initialize the Record Set
        rs.init();

        return rs;

    }

    
}

---