Metacat

/**

 *  '$RCSfile$'

 *    Purpose: A Class that handles the SAX XML events as they

 *             are generated from XML documents

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

 *             National Center for Ecological Analysis and Synthesis

 *    Authors: Matt Jones, Jivka Bojilova

 *    Release: @release@

 *

 *   '$Author: sgarg $'

 *     '$Date: 2004-09-16 11:04:35 -0700 (Thu, 16 Sep 2004) $'

 * '$Revision: 2289 $'

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or

 * (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 */

package edu.ucsb.nceas.metacat;

import java.sql.PreparedStatement;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.sql.Statement;

import java.util.EmptyStackException;

import java.util.Enumeration;

import java.util.Hashtable;

import java.util.Stack;

import java.util.Vector;

import edu.ucsb.nceas.morpho.datapackage.Triple;

import edu.ucsb.nceas.morpho.datapackage.TripleCollection;

import org.xml.sax.Attributes;

import org.xml.sax.SAXException;

import org.xml.sax.SAXParseException;

import org.xml.sax.ext.DeclHandler;

import org.xml.sax.ext.LexicalHandler;

import org.xml.sax.helpers.DefaultHandler;

/**

 * A database aware Class implementing callback bethods for the SAX parser to

 * call when processing the XML stream and generating events.

 */

public class DBSAXHandler extends DefaultHandler implements LexicalHandler,

        DeclHandler, Runnable

{

    protected boolean atFirstElement;

    protected boolean processingDTD;

    protected String docname = null;

    protected String doctype;

    protected String systemid;

    private boolean stackCreated = false;

    protected Stack nodeStack;

    protected Vector nodeIndex;

    protected DBConnection connection = null;

    protected DocumentImpl currentDocument;

    protected DBSAXNode rootNode;

    protected String action = null;

    protected String docid = null;

    protected String revision = null;

    protected String user = null;

    protected String[] groups = null;

    protected String pub = null;

    protected Thread xmlIndex;

    private boolean endDocument = false;

    protected int serverCode = 1;

    protected Hashtable namespaces = new Hashtable();

    protected boolean hitTextNode = false; // a flag to hit text node

    // a buffer to keep all text nodes for same element

    // it is for element was splited

    protected StringBuffer textBuffer = new StringBuffer();

    protected Stack textBufferStack = new Stack();

    protected static final int MAXDATACHARS = 4000;

    //protected static final int MAXDATACHARS = 50;

    protected static final long INDEXDELAY = 10000;

    // methods writeChildNodeToDB, setAttribute, setNamespace,

    // writeTextForDBSAXNode will increase endNodeId.

    protected long endNodeId = -1; // The end node id for a substree

    // DOCTITLE attr cleared from the db

    //   private static final int MAXTITLELEN = 1000;

    //HandlerTriple stuff

    TripleCollection tripleList = new TripleCollection();

    Triple currentTriple = new Triple();

    boolean startParseTriple = false;

    boolean hasTriple = false;

    public static final String ECOGRID = "ecogrid://";

    /**

     * Construct an instance of the handler class

     *

     * @param conn the JDBC connection to which information is written

     */

    private DBSAXHandler(DBConnection conn)

    {

        this.connection = conn;

        this.atFirstElement = true;

        this.processingDTD = false;

        // Create the stack for keeping track of node context

        // if it doesn't already exist

        if (!stackCreated) {

            nodeStack = new Stack();

            nodeIndex = new Vector();

            stackCreated = true;

        }

    }

    /**

     * Construct an instance of the handler class

     *

     * @param conn the JDBC connection to which information is written

     * @param action - "INSERT" or "UPDATE"

     * @param docid to be inserted or updated into JDBC connection

     * @param user the user connected to MetaCat servlet and owns the document

     * @param groups the groups to which user belongs

     * @param pub flag for public "read" access on document

     * @param serverCode the serverid from xml_replication on which this

     *            document resides.

     *

     */

/* TODO excise this constructor because not used anywhere in project

    public DBSAXHandler(DBConnection conn, String action, String docid,

            String user, String[] groups, String pub, int serverCode)

    {

        this(conn);

        this.action = action;

        this.docid = docid;

        this.user = user;

        this.groups = groups;

        this.pub = pub;

        this.serverCode = serverCode;

        this.xmlIndex = new Thread(this);

    }

*/

    /**

     * Construct an instance of the handler class In this constructor, user can

     * specify the version need to upadate

     *

     * @param conn the JDBC connection to which information is written

     * @param action - "INSERT" or "UPDATE"

     * @param docid to be inserted or updated into JDBC connection

     * @param revision, the user specified the revision need to be update

     * @param user the user connected to MetaCat servlet and owns the document

     * @param groups the groups to which user belongs

     * @param pub flag for public "read" access on document

     * @param serverCode the serverid from xml_replication on which this

     *            document resides.

     *

     */

    public DBSAXHandler(DBConnection conn, String action, String docid,

            String revision, String user, String[] groups, String pub,

            int serverCode)

    {

        this(conn);

        this.action = action;

        this.docid = docid;

        this.revision = revision;

        this.user = user;

        this.groups = groups;

        this.pub = pub;

        this.serverCode = serverCode;

        this.xmlIndex = new Thread(this);

    }

    /** SAX Handler that receives notification of beginning of the document */

    public void startDocument() throws SAXException

    {

        MetaCatUtil.debugMessage("start Document", 50);

        // Create the document node representation as root

        rootNode = new DBSAXNode(connection, this.docid);

        // Add the node to the stack, so that any text data can be

        // added as it is encountered

        nodeStack.push(rootNode);

    }

    /** SAX Handler that receives notification of end of the document */

    public void endDocument() throws SAXException

    {

        MetaCatUtil.debugMessage("end Document", 50);

        // Starting new thread for writing XML Index.

        // It calls the run method of the thread.

        //if it is data package insert triple into relationtion table;

        if (doctype != null

                && MetaCatUtil.getOptionList(

                        MetaCatUtil.getOption("packagedoctype")).contains(

                        doctype) && hasTriple) {

            try {

                //initial handler and write into relationdb

                RelationHandler handler = new RelationHandler(docid, doctype,

                        connection, tripleList);

            } catch (Exception e) {

                MetaCatUtil.debugMessage(

                        "Failed to write triples into relation table"

                                + e.getMessage(), 30);

                throw new SAXException(

                        "Failed to write triples into relation table "

                                + e.getMessage());

            }

        }

        boolean useXMLIndex =

            (new Boolean(MetaCatUtil.getOption("usexmlindex"))).booleanValue();

        if (useXMLIndex) {

            try {

                xmlIndex.start();

            } catch (NullPointerException e) {

                xmlIndex = null;

                throw new SAXException(

                        "Problem with starting thread for writing XML Index. "

                                + e.getMessage());

            }

        }

    }

    /** SAX Handler that is called at the start of Namespace */

    public void startPrefixMapping(String prefix, String uri)

            throws SAXException

    {

        MetaCatUtil.debugMessage("NAMESPACE", 50);

        namespaces.put(prefix, uri);

    }

    /** SAX Handler that is called at the start of each XML element */

    public void startElement(String uri, String localName, String qName,

            Attributes atts) throws SAXException

    {

        // for element <eml:eml...> qname is "eml:eml", local name is "eml"

        // for element <acl....> both qname and local name is "eml"

        // uri is namesapce

        MetaCatUtil.debugMessage("Start ELEMENT(qName) " + qName, 50);

        MetaCatUtil.debugMessage("Start ELEMENT(localName) " + localName, 50);

        MetaCatUtil.debugMessage("Start ELEMENT(uri) " + uri, 50);

        DBSAXNode parentNode = null;

        DBSAXNode currentNode = null;

        // Get a reference to the parent node for the id

        try {

            parentNode = (DBSAXNode) nodeStack.peek();

        } catch (EmptyStackException e) {

            parentNode = null;

        }

        // If hit a text node, we need write this text for current's parent

        // node

        // This will happend if the element is mixted

        if (hitTextNode && parentNode != null) {

            // write the textbuffer into db for parent node.

            endNodeId = writeTextForDBSAXNode(endNodeId, textBuffer, parentNode);

            // rest hitTextNode

            hitTextNode = false;

            // reset textbuffer

            textBuffer = null;

            textBuffer = new StringBuffer();

        }

        // Document representation that points to the root document node

        if (atFirstElement) {

            atFirstElement = false;

            // If no DOCTYPE declaration: docname = root element

            // doctype = root element name or name space

            if (docname == null) {

                docname = localName;

                // if uri isn't null doctype = uri(namespace)

                // othewise root element

                if (uri != null && !(uri.trim()).equals("")) {

                    doctype = uri;

                } else {

                    doctype = docname;

                }

                MetaCatUtil.debugMessage("DOCNAME-a: " + docname, 30);

                MetaCatUtil.debugMessage("DOCTYPE-a: " + doctype, 30);

            } else if (doctype == null) {

                // because docname is not null and it is declared in dtd

                // so could not be in schema, no namespace

                doctype = docname;

                MetaCatUtil.debugMessage("DOCTYPE-b: " + doctype, 30);

            }

            rootNode.writeNodename(docname);

            try {

                // for validated XML Documents store a reference to XML DB

                // Catalog

                // Because this is select statement and it needn't to roll back

                // if

                // insert document action fialed.

                // In order to decrease DBConnection usage count, we get a new

                // dbconnection from pool

                String catalogid = null;

                DBConnection dbConn = null;

                int serialNumber = -1;

                if (systemid != null) {

                    try {

                        // Get dbconnection

                        dbConn = DBConnectionPool

                                .getDBConnection("DBSAXHandler.startElement");

                        serialNumber = dbConn.getCheckOutSerialNumber();

                        Statement stmt = dbConn.createStatement();

                        ResultSet rs = stmt

                                .executeQuery("SELECT catalog_id FROM xml_catalog "

                                        + "WHERE entry_type = 'DTD' "

                                        + "AND public_id = '" + doctype + "'");

                        boolean hasRow = rs.next();

                        if (hasRow) {

                            catalogid = rs.getString(1);

                        }

                        stmt.close();

                    }//try

                    finally {

                        // Return dbconnection

                        DBConnectionPool.returnDBConnection(dbConn,

                                serialNumber);

                    }//finally

                }

                //create documentImpl object by the constructor which can

                // specify

                //the revision

                currentDocument = new DocumentImpl(connection, rootNode

                        .getNodeID(), docname, doctype, docid, revision,

                        action, user, this.pub, catalogid, this.serverCode);

            } catch (Exception ane) {

                throw (new SAXException("Error in DBSaxHandler.startElement "

                        + action, ane));

            }

        }

        // Create the current node representation

        currentNode = new DBSAXNode(connection, qName, localName, parentNode,

                currentDocument.getRootNodeID(), docid, currentDocument

                        .getDoctype());

        // Add all of the namespaces

        String prefix;

        String nsuri;

        Enumeration prefixes = namespaces.keys();

        while (prefixes.hasMoreElements()) {

            prefix = (String) prefixes.nextElement();

            nsuri = (String) namespaces.get(prefix);

            currentNode.setNamespace(prefix, nsuri, docid);

        }

        namespaces = null;

        namespaces = new Hashtable();

        // Add all of the attributes

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

            String attributeName = atts.getQName(i);

            String attributeValue = atts.getValue(i);

            endNodeId = currentNode.setAttribute(attributeName, attributeValue,

                    docid);

            // To handle name space and schema location if the attribute name

            // is

            // xsi:schemaLocation. If the name space is in not in catalog table

            // it will be regeistered.

            if (attributeName != null

                    && attributeName

                            .indexOf(MetaCatServlet.SCHEMALOCATIONKEYWORD) != -1) {

                SchemaLocationResolver resolver = new SchemaLocationResolver(

                        attributeValue);

                resolver.resolveNameSpace();

            }

        }

        // Add the node to the stack, so that any text data can be

        // added as it is encountered

        nodeStack.push(currentNode);

        // Add the node to the vector used by thread for writing XML Index

        nodeIndex.addElement(currentNode);

        // start parsing triple

        if (doctype != null

                && MetaCatUtil.getOptionList(

                        MetaCatUtil.getOption("packagedoctype")).contains(

                        doctype) && localName.equals("triple")) {

            startParseTriple = true;

            hasTriple = true;

            currentTriple = new Triple();

        }

    }

    /* The run method of xmlIndex thread. It writes XML Index for the document. */

    public void run()

    {

        DBSAXNode currNode = null;

        DBSAXNode prevNode = null;

        DBConnection dbConn = null;

        int serialNumber = -1;

        String doctype = currentDocument.getDoctype();

        int step = 0;

        int counter = 0;

        try {

            // stop 5 second

            Thread.sleep(5000);

            // Opening separate db connection for writing XML Index

            dbConn = DBConnectionPool.getDBConnection("DBSAXHandler.run");

            serialNumber = dbConn.getCheckOutSerialNumber();

            dbConn.setAutoCommit(false);

            //make sure record is done

            checkDocumentTable();

            // Going through the elements of the document and writing its Index

            Enumeration nodes = nodeIndex.elements();

            while (nodes.hasMoreElements()) {

                currNode = (DBSAXNode) nodes.nextElement();

                currNode.updateNodeIndex(dbConn, docid, doctype);

            }

            dbConn.commit();

        } catch (Exception e) {

            try {

                dbConn.rollback();

                //dbconn.close();

            } catch (SQLException sqle) {

            }

            MetaCatUtil.debugMessage("Error in DBSAXHandler.run "

                    + e.getMessage(), 30);

        } finally {

            DBConnectionPool.returnDBConnection(dbConn, serialNumber);

        }//finally

    }

    /*

     * method to make sure insert is finished before create index table If new

     * version of record is in xml_documents every thing will be fine

     */

    private void checkDocumentTable() throws Exception

    {

        DBConnection dbConn = null;

        int serialNumber = -1;

        try {

            // Opening separate db connection for writing XML Index

            dbConn = DBConnectionPool

                    .getDBConnection("DBSAXHandler.checkDocumentTable");

            serialNumber = dbConn.getCheckOutSerialNumber();

            // the following while loop construct checks to make sure that

            // the docid of the document that we are trying to index is already

            // in the xml_documents table. if this is not the case, the foreign

            // key relationship between xml_documents and xml_index is

            // temporarily broken causing multiple problems.

            boolean inxmldoc = false;

            long startTime = System.currentTimeMillis();

            while (!inxmldoc) {

                String xmlDocumentsCheck = "select distinct docid from xml_documents"

                        + " where docid ='"

                        + docid

                        + "' and "

                        + " rev ='"

                        + revision + "'";

                PreparedStatement xmlDocCheck = dbConn

                        .prepareStatement(xmlDocumentsCheck);

                // Increase usage count

                dbConn.increaseUsageCount(1);

                xmlDocCheck.execute();

                ResultSet doccheckRS = xmlDocCheck.getResultSet();

                boolean tableHasRows = doccheckRS.next();

                if (tableHasRows) {

                    MetaCatUtil.debugMessage(

                            "=========== find the correct document", 35);

                    inxmldoc = true;

                }

                doccheckRS.close();

                xmlDocCheck.close();

                // make sure the while loop will be ended in reseaonable time

                long stopTime = System.currentTimeMillis();

                if ((stopTime - startTime) > INDEXDELAY) { throw new Exception(

                        "Couldn't find the docid for index build in"

                                + "reseaonable time!"); }

            }//while

        } catch (Exception e) {

            try {

                dbConn.rollback();

                //dbconn.close();

            } catch (SQLException sqle) {

            }

            MetaCatUtil.debugMessage("Error in DBSAXHandler.run "

                    + e.getMessage(), 30);

        } finally {

            DBConnectionPool.returnDBConnection(dbConn, serialNumber);

        }//finally

    }

    /** SAX Handler that is called for each XML text node */

    public void characters(char[] cbuf, int start, int len) throws SAXException

    {

        MetaCatUtil.debugMessage("CHARACTERS", 50);

        // buffer all text nodes for same element. This is for text was splited

        // into different nodes

        textBuffer.append(new String(cbuf, start, len));

        // set hittextnode true

        hitTextNode = true;

        // if text buffer .size is greater than max, write it to db.

        // so we can save memory

        if (textBuffer.length() > MAXDATACHARS) {

            MetaCatUtil.debugMessage("Write text into DB in charaters"

                    + " when text buffer size is greater than maxmum number",

                    50);

            DBSAXNode currentNode = (DBSAXNode) nodeStack.peek();

            endNodeId = writeTextForDBSAXNode(endNodeId, textBuffer,

                    currentNode);

            textBuffer = null;

            textBuffer = new StringBuffer();

        }

    }

    /**

     * SAX Handler that is called for each XML text node that is Ignorable

     * white space

     */

    public void ignorableWhitespace(char[] cbuf, int start, int len)

            throws SAXException

    {

        // When validation is turned "on", white spaces are reported here

        // When validation is turned "off" white spaces are not reported here,

        // but through characters() callback

        MetaCatUtil.debugMessage("IGNORABLEWHITESPACE", 50);

        DBSAXNode currentNode = (DBSAXNode) nodeStack.peek();

        String data = null;

        int leftover = len;

        int offset = start;

        boolean moredata = true;

        // This loop deals with the case where there are more characters

        // than can fit in a single database text field (limit is

        // MAXDATACHARS). If the text to be inserted exceeds MAXDATACHARS,

        // write a series of nodes that are MAXDATACHARS long, and then the

        // final node contains the remainder

        while (moredata) {

            if (leftover > MAXDATACHARS) {

                data = new String(cbuf, offset, MAXDATACHARS);

                leftover -= MAXDATACHARS;

                offset += MAXDATACHARS;

            } else {

                data = new String(cbuf, offset, leftover);

                moredata = false;

            }

            // Write the content of the node to the database

            endNodeId = currentNode.writeChildNodeToDB("TEXT", null, data,

                    docid);

        }

    }

    /**

     * SAX Handler called once for each processing instruction found: node that

     * PI may occur before or after the root element.

     */

    public void processingInstruction(String target, String data)

            throws SAXException

    {

        MetaCatUtil.debugMessage("PI", 50);

        DBSAXNode currentNode = (DBSAXNode) nodeStack.peek();

        endNodeId = currentNode.writeChildNodeToDB("PI", target, data, docid);

    }

    /** SAX Handler that is called at the end of each XML element */

    public void endElement(String uri, String localName, String qName)

            throws SAXException

    {

        MetaCatUtil.debugMessage("End ELEMENT " + qName, 50);

        // write buffered text nodes into db (so no splited)

        DBSAXNode currentNode = (DBSAXNode) nodeStack.peek();

        // If before the end element, the parser hit text nodes and store them

        // into the buffer, write the buffer to data base. The reason we put

        // write database here is for xerces some time split text node

        if (hitTextNode) {

            MetaCatUtil.debugMessage("Write text into DB in End Element", 50);

            endNodeId = writeTextForDBSAXNode(endNodeId, textBuffer,

                    currentNode);

            //if it is triple parsing process

            if (startParseTriple) {

                String content = textBuffer.toString().trim();

                if (localName.equals("subject")) { //get the subject content

                    currentTriple.setSubject(content);

                } else if (localName.equals("relationship")) { //get the

                                                               // relationship

                                                               // content

                    currentTriple.setRelationship(content);

                } else if (localName.equals("object")) { //get the object

                                                         // content

                    currentTriple.setObject(content);

                }

            }

        }//if

        //set hitText false

        hitTextNode = false;

        // reset textbuff

        textBuffer = null;

        textBuffer = new StringBuffer();

        // Get the node from the stack

        currentNode = (DBSAXNode) nodeStack.pop();

        //finishing parsing single triple

        if (startParseTriple && localName.equals("triple")) {

            // add trip to triple collection

            tripleList.addTriple(currentTriple);

            //rest variable

            currentTriple = null;

            startParseTriple = false;

        }

    }

    //

    // the next section implements the LexicalHandler interface

    //

    /** SAX Handler that receives notification of DOCTYPE. Sets the DTD */

    public void startDTD(String name, String publicId, String systemId)

            throws SAXException

    {

        docname = name;

        doctype = publicId;

        systemid = systemId;

        processingDTD = true;

        DBSAXNode currentNode = (DBSAXNode) nodeStack.peek();

        //create a DTD node and write docname,publicid and system id into db

        // we don't put the dtd node into node stack

        DBSAXNode dtdNode = new DBSAXNode(connection, name, publicId, systemId,

                currentNode, currentNode.getRootNodeID(), docid);

        MetaCatUtil.debugMessage("Start DTD", 50);

        MetaCatUtil.debugMessage("Setting processingDTD to true", 50);

        MetaCatUtil.debugMessage("DOCNAME: " + docname, 50);

        MetaCatUtil.debugMessage("DOCTYPE: " + doctype, 50);

        MetaCatUtil.debugMessage("  SYSID: " + systemid, 50);

    }

    /**

     * SAX Handler that receives notification of end of DTD

     */

    public void endDTD() throws SAXException

    {

        processingDTD = false;

        MetaCatUtil.debugMessage("Setting processingDTD to false", 50);

        MetaCatUtil.debugMessage("end DTD", 50);

    }

    /**

     * SAX Handler that receives notification of comments in the DTD

     */

    public void comment(char[] ch, int start, int length) throws SAXException

    {

        MetaCatUtil.debugMessage("COMMENT", 50);

        if (!processingDTD) {

            DBSAXNode currentNode = (DBSAXNode) nodeStack.peek();

            endNodeId = currentNode.writeChildNodeToDB("COMMENT", null,

                    new String(ch, start, length), docid);

        }

    }

    /**

     * SAX Handler that receives notification of the start of CDATA sections

     */

    public void startCDATA() throws SAXException

    {

        MetaCatUtil.debugMessage("start CDATA", 50);

    }

    /**

     * SAX Handler that receives notification of the end of CDATA sections

     */

    public void endCDATA() throws SAXException

    {

        MetaCatUtil.debugMessage("end CDATA", 50);

    }

    /**

     * SAX Handler that receives notification of the start of entities

     */

    public void startEntity(String name) throws SAXException

    {

        MetaCatUtil.debugMessage("start ENTITY: " + name, 50);

        //System.out.println("start ENTITY: " + name);

        if (name.equals("[dtd]")) {

            processingDTD = true;

        }

    }

    /**

     * SAX Handler that receives notification of the end of entities

     */

    public void endEntity(String name) throws SAXException

    {

        MetaCatUtil.debugMessage("end ENTITY: " + name, 50);

        //System.out.println("end ENTITY: " + name);

        if (name.equals("[dtd]")) {

            processingDTD = false;

        }

    }

    /**

     * SAX Handler that receives notification of element declarations

     */

    public void elementDecl(String name, String model)

            throws org.xml.sax.SAXException

    {

        //System.out.println("ELEMENTDECL: " + name + " " + model);

        MetaCatUtil.debugMessage("ELEMENTDECL: " + name + " " + model, 50);

    }

    /**

     * SAX Handler that receives notification of attribute declarations

     */

    public void attributeDecl(String eName, String aName, String type,

            String valueDefault, String value) throws org.xml.sax.SAXException

    {

        //System.out.println("ATTRIBUTEDECL: " + eName + " "

        //                        + aName + " " + type + " " + valueDefault + " "

        //                        + value);

        MetaCatUtil.debugMessage("ATTRIBUTEDECL: " + eName + " " + aName + " "

                + type + " " + valueDefault + " " + value, 50);

    }

    /**

     * SAX Handler that receives notification of internal entity declarations

     */

    public void internalEntityDecl(String name, String value)

            throws org.xml.sax.SAXException

    {

        //System.out.println("INTERNENTITYDECL: " + name + " " + value);

        MetaCatUtil.debugMessage("INTERNENTITYDECL: " + name + " " + value, 50);

    }

    /**

     * SAX Handler that receives notification of external entity declarations

     */

    public void externalEntityDecl(String name, String publicId, String systemId)

            throws org.xml.sax.SAXException

    {

        //System.out.println("EXTERNENTITYDECL: " + name + " " + publicId

        //                              + " " + systemId);

        MetaCatUtil.debugMessage("EXTERNENTITYDECL: " + name + " " + publicId

                + " " + systemId, 50);

        // it processes other external entity, not the DTD;

        // it doesn't signal for the DTD here

        processingDTD = false;

    }

    //

    // the next section implements the ErrorHandler interface

    //

    /**

     * SAX Handler that receives notification of fatal parsing errors

     */

    public void fatalError(SAXParseException exception) throws SAXException

    {

        MetaCatUtil.debugMessage("FATALERROR: " + exception.getMessage(), 50);

        throw (new SAXException("Fatal processing error.", exception));

    }

    /**

     * SAX Handler that receives notification of recoverable parsing errors

     */

    public void error(SAXParseException exception) throws SAXException

    {

        MetaCatUtil.debugMessage("ERROR: " + exception.getMessage(), 50);

        throw (new SAXException("Error in processing EML.", exception));

    }

    /**

     * SAX Handler that receives notification of warnings

     */

    public void warning(SAXParseException exception) throws SAXException

    {

        MetaCatUtil.debugMessage("WARNING: " + exception.getMessage(), 50);

        throw (new SAXException("Warning.", exception));

    }

    //

    // Helper, getter and setter methods

    //

    /**

     * get the document name

     */

    public String getDocname()

    {

        return docname;

    }

    /**

     * get the document processing state

     */

    public boolean processingDTD()

    {

        return processingDTD;

    }

    /* Method to write a text buffer for DBSAXNode */

    protected long writeTextForDBSAXNode(long previousEndNodeId,

            StringBuffer strBuffer, DBSAXNode node) throws SAXException

    {

        long nodeId = previousEndNodeId;

        // Check parameter

        if (strBuffer == null || node == null) { return nodeId; }

        boolean moredata = true;

        String data = null;

        int bufferSize = strBuffer.length();

        int start = 0;

        // if there are some cotent in buffer, write it

        if (bufferSize > 0) {

            MetaCatUtil.debugMessage("Write text into DB", 50);

            // This loop deals with the case where there are more characters

            // than can fit in a single database text field (limit is

            // MAXDATACHARS). If the text to be inserted exceeds MAXDATACHARS,

            // write a series of nodes that are MAXDATACHARS long, and then the

            // final node contains the remainder

            while (moredata) {

                bufferSize = strBuffer.length();

                if (bufferSize > MAXDATACHARS) {

                    data = strBuffer.substring(start, MAXDATACHARS);

                    // cut the stringbuffer part that already written into db

                    strBuffer = strBuffer.delete(start, MAXDATACHARS);

                } else {

                    data = strBuffer.substring(start, bufferSize);

                    moredata = false;

                }

                // Write the content of the node to the database

                nodeId = node.writeChildNodeToDB("TEXT", null, data, docid);

            }//while

        }//if

        return nodeId;

    }

}