/*
* The Apache Software License, Version 1.1
*
*
* Copyright (c) 1999 The Apache Software Foundation. All rights
* reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
*
* 3. The end-user documentation included with the redistribution,
* if any, must include the following acknowledgment:
* "This product includes software developed by the
* Apache Software Foundation (http://www.apache.org/)."
* Alternately, this acknowledgment may appear in the software itself,
* if and wherever such third-party acknowledgments normally appear.
*
* 4. The names "Xalan" and "Apache Software Foundation" must
* not be used to endorse or promote products derived from this
* software without prior written permission. For written
* permission, please contact apache@apache.org.
*
* 5. Products derived from this software may not be called "Apache",
* nor may "Apache" appear in their name, without prior written
* permission of the Apache Software Foundation.
*
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
* ====================================================================
*
* This software consists of voluntary contributions made by many
* individuals on behalf of the Apache Software Foundation and was
* originally based on software copyright (c) 1999, Lotus
* Development Corporation., http://www.lotus.com. For more
* information on the Apache Software Foundation, please see
* <http://www.apache.org/>.
*/
package org.apache.xalan.xpath.xdom;
import java.net.*;
import java.io.*;
import java.util.*;
import org.apache.xerces.dom.*;
import org.apache.xerces.parsers.*;
import org.apache.xerces.framework.*;
import org.xml.sax.*;
import org.w3c.dom.*;
import org.apache.xalan.xpath.xml.*;
import org.apache.xalan.xpath.*;
import org.apache.xpath.res.XPATHErrorResources;
import org.apache.xalan.res.XSLMessages;
import javax.xml.transform.TransformerException;
import javax.xml.parsers.*;
/**
* <meta name="usage" content="general"/>
* Provides XSLTProcessor an interface to the Xerces XML parser. This
* liaison should be used if Xerces DOM nodes are being process as
* the source tree or as the result tree.
* @see org.apache.xalan.xslt.XSLTProcessor
* @see org.apache.xml.parsers
* @deprecated This compatibility layer will be removed in later releases.
*/
public class XercesLiaison extends XMLParserLiaisonDefault //implements XPathSupport
{
/**
* Return a string suitible for telling the user what parser is being used.
*/
public String getParserDescription()
{
return "XML4J Version "+ getXML4JVersionString();
}
private org.xml.sax.ErrorHandler m_errorHandler;
/**
* Constructor that takes SAX ErrorHandler as an argument. The error handler
* is registered with the XML Parser. Any XML-related errors will be reported
* to the calling application using this error handler.
*
* @param errorHandler SAX ErrorHandler instance.
*/
public XercesLiaison(org.xml.sax.ErrorHandler errorHandler)
{
m_errorHandler = errorHandler;
}
/**
* Construct an instance.
*
public XercesLiaison(XPathEnvSupport envSupport)
{
m_envSupport = envSupport;
}*/
/**
* Construct an instance.
*/
public XercesLiaison()
{
}
/**
* <meta name="usage" content="internal"/>
* Check node to see if it matches this liaison.
*/
public void checkNode(Node node)
throws TransformerException
{
if(!(node instanceof org.apache.xerces.dom.NodeImpl))
throw new TransformerException(XSLMessages.createXPATHMessage(XPATHErrorResources.ER_XERCES_CANNOT_HANDLE_NODES, new Object[]{((Object)node).getClass()})); //"XercesLiaison can not handle nodes of type"
//+((Object)node).getClass());
}
/**
* Returns true that this implementation does support
* the SAX DocumentHandler interface.
*/
public boolean supportsSAX()
{
return true;
}
/**
* <meta name="usage" content="internal"/>
* Get Xerces version field... we have to do this 'cause
* the "public static final" fields seem to get bound
* at compile time otherwise.
*/
private String getXML4JVersionString()
{
// return Version.fVersion;
String version = "";
try
{
java.lang.reflect.Field versionField = Version.class.getField("fVersion");
version = (String)versionField.get(null);
}
catch(Exception e)
{
}
return version;
}
/**
* <meta name="usage" content="internal"/>
* Get one of the Xerces version numbers...
* we have to do this 'cause the "public static final"
* fields seem to get bound at compile time otherwise.
*/
private int getXML4JVersionNum(int field)
{
int versionNum = 0;
String ver = getXML4JVersionString();
StringTokenizer tokenizer = new StringTokenizer(ver, " .");
for(int i = 0; tokenizer.hasMoreTokens(); i++)
{
String tok = tokenizer.nextToken();
if(field == i)
{
versionNum = Integer.parseInt(tok);
}
}
return versionNum;
}
/**
* Pool the DOM parsers for reuse.
*
private ObjectPool m_domParserPool = new ObjectPool(DOMParser.class);
/**
* Pool the SAX parsers for reuse.
*
private ObjectPool m_saxParserPool = new ObjectPool(SAXParser.class);
/**
* Count the parses since the last garbage collection. GC every
* 10 parses or so. (This might be a bad idea, but it seems to
* help...)
*
protected int m_parseCountSinceGC = 0;
*/
/**
* <meta name="usage" content="internal"/>
* Parse an XML document.
*
* <p>The application can use this method to instruct the SAX parser
* to begin parsing an XML document from any valid input
* source (a character stream, a byte stream, or a URI).</p>
*
* <p>Applications may not invoke this method while a parse is in
* progress (they should create a new Parser instead for each
* additional XML document). Once a parse is complete, an
* application may reuse the same Parser object, possibly with a
* different input source.</p>
*
* @param source The input source for the top-level of the
* XML document.
* @exception org.xml.sax.SAXException Any SAX exception, possibly
* wrapping another exception.
* @exception java.io.IOException An IO exception from the parser,
* possibly from a byte stream or character stream
* supplied by the application.
* @see org.xml.sax.InputSource
* @see #parse(java.lang.String)
* @see #setEntityResolver
* @see #setDTDHandler
* @see #setDocumentHandler
* @see #setErrorHandler
*/
public void parse (InputSource source)
throws javax.xml.transform.TransformerException
{
try
{
// I guess I should use JAXP factory here... when it's legal.
// org.apache.xerces.parsers.DOMParser parser
// = new org.apache.xerces.parsers.DOMParser();
DocumentBuilderFactory builderFactory =
DocumentBuilderFactory.newInstance();
builderFactory.setNamespaceAware(true);
DocumentBuilder parser = builderFactory.newDocumentBuilder();
if (m_errorHandler == null)
parser.setErrorHandler(new org.apache.xml.utils.DefaultErrorHandler());
else
parser.setErrorHandler(m_errorHandler);
// if(null != m_entityResolver)
// {
// System.out.println("Setting the entity resolver.");
// parser.setEntityResolver(m_entityResolver);
// }
setDocument(parser.parse(source));
}
catch (org.xml.sax.SAXException se)
{
throw new TransformerException(se);
}
catch (ParserConfigurationException pce)
{
throw new TransformerException(pce);
}
catch (IOException ioe)
{
throw new TransformerException(ioe);
}
}
public void copyFromOtherLiaison(XMLParserLiaisonDefault from)
throws SAXException
{
//super.copyFromOtherLiaison(from);
if(null != from) // defensive
{
if(from instanceof XercesLiaison)
this.m_useDOM2getNamespaceURI = ((XercesLiaison)from).m_useDOM2getNamespaceURI;
}
}
/**
* Create an empty DOM Document. Mainly used for creating an
* output document. Implementation of XMLParserLiaison
* interface method.
*/
static public Document createDocument()
{
org.apache.xerces.dom.DocumentImpl doc = new org.apache.xerces.dom.DocumentImpl();
return doc;
}
/**
* Given an ID, return the element.
*/
public Element getElementByID(String id, Document doc)
{
return ((DocumentImpl)doc).getIdentifier(id);
}
/**
* Tell if the node is ignorable whitespace.
* @deprecated
*/
public boolean isIgnorableWhitespace(Text node)
{
boolean isIgnorable;
if( node instanceof org.apache.xerces.dom.TextImpl)
{
isIgnorable = ((org.apache.xerces.dom.TextImpl)node).isIgnorableWhitespace();
}
else
{
isIgnorable = false;
}
return isIgnorable;
}
protected boolean m_useDOM2getNamespaceURI = true;
/**
* Set whether or not getNamespaceOfNode should use the Xerces/DOM2
* getNamespaceURI. This has to be set to true if the
* http://xml.org/sax/features/namespaces is set to false, or if
* the tree is mutated.
*/
public void setUseDOM2getNamespaceURI(boolean b)
{
m_useDOM2getNamespaceURI = b;
}
/**
* Get the namespace of the node. Calls org.apache.xerces.dom.NodeImpl's
* getNamespaceURI() if setUseDOM2getNamespaceURI(true) has been called.
*/
public String getNamespaceOfNode(Node n)
{
return(m_useDOM2getNamespaceURI) ?
((org.apache.xerces.dom.NodeImpl)n).getNamespaceURI()
: super.getNamespaceOfNode(n);
}
/**
* Returns the local name of the given node.
*/
// public String getLocalNameOfNode(Node n)
// {
// return ((org.apache.xerces.dom.NodeImpl)n).getLocalName();
// }
/**
* Returns the element name with the namespace expanded.
*/
// public String getExpandedElementName(Element elem)
// {
// String namespace = getNamespaceOfNode(elem);
// return (null != namespace) ? namespace+":"+ getLocalNameOfNode(elem)
// : getLocalNameOfNode(elem);
// }
/**
* Returns the attribute name with the namespace expanded.
*/
// public String getExpandedAttributeName(Attr attr)
// {
// String namespace = getNamespaceOfNode(attr);
// return (null != namespace) ? namespace+":"+ getLocalNameOfNode(attr)
// : getLocalNameOfNode(attr);
// }
/**
* Get the parent of a node.
*/
static public Node getParentOfNode(Node node)
throws RuntimeException
{
return (Node.ATTRIBUTE_NODE == node.getNodeType())
? ((Attr)node).getOwnerElement() : node.getParentNode();
}
}