/**
* Create a IncrementalSAXSource_Xerces, and create a SAXParser to go with it. Xerces2 incremental
* parsing is only supported if this constructor is used, due to limitations in the Xerces2 API
* (as of Beta 3). If you don't like that restriction, tell the Xerces folks that there should be
* a simpler way to request incremental SAX parsing.
*/
public IncrementalSAXSource_Xerces() throws NoSuchMethodException {
try {
// Xerces-2 incremental parsing support (as of Beta 3)
// ContentHandlers still get set on fIncrementalParser (to get
// conversion from XNI events to SAX events), but
// _control_ for incremental parsing must be exercised via the config.
//
// At this time there's no way to read the existing config, only
// to assert a new one... and only when creating a brand-new parser.
//
// Reflection is used to allow us to continue to compile against
// Xerces1. If/when we can abandon the older versions of the parser,
// this will simplify significantly.
Class me = this.getClass();
// If we can't get the magic constructor, no need to look further.
Class xniConfigClass = me.forName("org.apache.xerces.xni.parser.XMLParserConfiguration");
Class[] args1 = {xniConfigClass};
Constructor ctor = SAXParser.class.getConstructor(args1);
// Build the parser configuration object. StandardParserConfiguration
// happens to implement XMLPullParserConfiguration, which is the API
// we're going to want to use.
Class xniStdConfigClass = me.forName("org.apache.xerces.parsers.StandardParserConfiguration");
fPullParserConfig = xniStdConfigClass.newInstance();
Object[] args2 = {fPullParserConfig};
fIncrementalParser = (SAXParser) ctor.newInstance(args2);
// Preload all the needed the configuration methods... I want to know they're
// all here before we commit to trying to use them, just in case the
// API changes again.
Class fXniInputSourceClass = me.forName("org.apache.xerces.xni.parser.XMLInputSource");
Class[] args3 = {fXniInputSourceClass};
fConfigSetInput = xniStdConfigClass.getMethod("setInputSource", args3);
Class[] args4 = {String.class, String.class, String.class};
fConfigInputSourceCtor = fXniInputSourceClass.getConstructor(args4);
Class[] args5 = {java.io.InputStream.class};
fConfigSetByteStream = fXniInputSourceClass.getMethod("setByteStream", args5);
Class[] args6 = {java.io.Reader.class};
fConfigSetCharStream = fXniInputSourceClass.getMethod("setCharacterStream", args6);
Class[] args7 = {String.class};
fConfigSetEncoding = fXniInputSourceClass.getMethod("setEncoding", args7);
Class[] argsb = {Boolean.TYPE};
fConfigParse = xniStdConfigClass.getMethod("parse", argsb);
Class[] noargs = new Class[0];
fReset = fIncrementalParser.getClass().getMethod("reset", noargs);
} catch (Exception e) {
// Fallback if this fails (implemented in createIncrementalSAXSource) is
// to attempt Xerces-1 incremental setup. Can't do tail-call in
// constructor, so create new, copy Xerces-1 initialization,
// then throw it away... Ugh.
IncrementalSAXSource_Xerces dummy = new IncrementalSAXSource_Xerces(new SAXParser());
this.fParseSomeSetup = dummy.fParseSomeSetup;
this.fParseSome = dummy.fParseSome;
this.fIncrementalParser = dummy.fIncrementalParser;
}
}
/**
* Create a IncrementalSAXSource_Xerces wrapped around an existing SAXParser. Currently this works
* only for recent releases of Xerces-1. Xerces-2 incremental is currently possible only if we are
* allowed to create the parser instance, due to limitations in the API exposed by Xerces-2 Beta
* 3; see the no-args constructor for that code.
*
* @exception if the SAXParser class doesn't support the Xerces incremental parse operations. In
* that case, caller should fall back upon the IncrementalSAXSource_Filter approach.
*/
public IncrementalSAXSource_Xerces(SAXParser parser) throws NoSuchMethodException {
// Reflection is used to allow us to compile against
// Xerces2. If/when we can abandon the older versions of the parser,
// this constructor will simply have to fail until/unless the
// Xerces2 incremental support is made available on previously
// constructed SAXParser instances.
fIncrementalParser = parser;
Class me = parser.getClass();
Class[] parms = {InputSource.class};
fParseSomeSetup = me.getMethod("parseSomeSetup", parms);
parms = new Class[0];
fParseSome = me.getMethod("parseSome", parms);
// Fallback if this fails (implemented in createIncrementalSAXSource) is
// to use IncrementalSAXSource_Filter rather than Xerces-specific code.
}
