/**
   * 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.
 }