com.sun.org.apache.xerces.internal.parsers.SAXParser Java Examples

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

private synchronized void writeToSAX(ContentHandler handler) {
    // nothing must go wrong with this parse...
    SAXParser parser = fGrammar.getSAXParser();
    StringReader aReader = new StringReader(fData);
    InputSource aSource = new InputSource(aReader);
    parser.setContentHandler(handler);
    try {
        parser.parse(aSource);
    }
    catch (SAXException e) {
        // this should never happen!
        // REVISIT:  what to do with this?; should really not
        // eat it...
    }
    catch (IOException i) {
        // ditto with above
    }
    // Release the reference to the user's ContentHandler.
    parser.setContentHandler(null);
}
 

private synchronized void writeToSAX(ContentHandler handler) {
    // nothing must go wrong with this parse...
    SAXParser parser = fGrammar.getSAXParser();
    StringReader aReader = new StringReader(fData);
    InputSource aSource = new InputSource(aReader);
    parser.setContentHandler(handler);
    try {
        parser.parse(aSource);
    }
    catch (SAXException e) {
        // this should never happen!
        // REVISIT:  what to do with this?; should really not
        // eat it...
    }
    catch (IOException i) {
        // ditto with above
    }
    // Release the reference to the user's ContentHandler.
    parser.setContentHandler(null);
}
 

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

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

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

private synchronized void writeToSAX(ContentHandler handler) {
    // nothing must go wrong with this parse...
    SAXParser parser = fGrammar.getSAXParser();
    StringReader aReader = new StringReader(fData);
    InputSource aSource = new InputSource(aReader);
    parser.setContentHandler(handler);
    try {
        parser.parse(aSource);
    }
    catch (SAXException e) {
        // this should never happen!
        // REVISIT:  what to do with this?; should really not
        // eat it...
    }
    catch (IOException i) {
        // ditto with above
    }
    // Release the reference to the user's ContentHandler.
    parser.setContentHandler(null);
}
 

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

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

private synchronized void writeToSAX(ContentHandler handler) {
    // nothing must go wrong with this parse...
    SAXParser parser = fGrammar.getSAXParser();
    StringReader aReader = new StringReader(fData);
    InputSource aSource = new InputSource(aReader);
    parser.setContentHandler(handler);
    try {
        parser.parse(aSource);
    }
    catch (SAXException e) {
        // this should never happen!
        // REVISIT:  what to do with this?; should really not
        // eat it...
    }
    catch (IOException i) {
        // ditto with above
    }
    // Release the reference to the user's ContentHandler.
    parser.setContentHandler(null);
}
 

private synchronized void writeToSAX(ContentHandler handler) {
    // nothing must go wrong with this parse...
    SAXParser parser = fGrammar.getSAXParser();
    StringReader aReader = new StringReader(fData);
    InputSource aSource = new InputSource(aReader);
    parser.setContentHandler(handler);
    try {
        parser.parse(aSource);
    }
    catch (SAXException e) {
        // this should never happen!
        // REVISIT:  what to do with this?; should really not
        // eat it...
    }
    catch (IOException i) {
        // ditto with above
    }
    // Release the reference to the user's ContentHandler.
    parser.setContentHandler(null);
}
 

private synchronized void writeToSAX(ContentHandler handler) {
    // nothing must go wrong with this parse...
    SAXParser parser = fGrammar.getSAXParser();
    StringReader aReader = new StringReader(fData);
    InputSource aSource = new InputSource(aReader);
    parser.setContentHandler(handler);
    try {
        parser.parse(aSource);
    }
    catch (SAXException e) {
        // this should never happen!
        // REVISIT:  what to do with this?; should really not
        // eat it...
    }
    catch (IOException i) {
        // ditto with above
    }
    // Release the reference to the user's ContentHandler.
    parser.setContentHandler(null);
}
 

private synchronized void writeToSAX(ContentHandler handler) {
    // nothing must go wrong with this parse...
    SAXParser parser = fGrammar.getSAXParser();
    StringReader aReader = new StringReader(fData);
    InputSource aSource = new InputSource(aReader);
    parser.setContentHandler(handler);
    try {
        parser.parse(aSource);
    }
    catch (SAXException e) {
        // this should never happen!
        // REVISIT:  what to do with this?; should really not
        // eat it...
    }
    catch (IOException i) {
        // ditto with above
    }
    // Release the reference to the user's ContentHandler.
    parser.setContentHandler(null);
}
 

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

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

private synchronized void writeToSAX(ContentHandler handler) {
    // nothing must go wrong with this parse...
    SAXParser parser = fGrammar.getSAXParser();
    StringReader aReader = new StringReader(fData);
    InputSource aSource = new InputSource(aReader);
    parser.setContentHandler(handler);
    try {
        parser.parse(aSource);
    }
    catch (SAXException e) {
        // this should never happen!
        // REVISIT:  what to do with this?; should really not
        // eat it...
    }
    catch (IOException i) {
        // ditto with above
    }
    // Release the reference to the user's ContentHandler.
    parser.setContentHandler(null);
}
 

private synchronized void writeToSAX(ContentHandler handler) {
    // nothing must go wrong with this parse...
    SAXParser parser = fGrammar.getSAXParser();
    StringReader aReader = new StringReader(fData);
    InputSource aSource = new InputSource(aReader);
    parser.setContentHandler(handler);
    try {
        parser.parse(aSource);
    }
    catch (SAXException e) {
        // this should never happen!
        // REVISIT:  what to do with this?; should really not
        // eat it...
    }
    catch (IOException i) {
        // ditto with above
    }
    // Release the reference to the user's ContentHandler.
    parser.setContentHandler(null);
}
 

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

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

private synchronized void writeToSAX(ContentHandler handler) {
    // nothing must go wrong with this parse...
    SAXParser parser = fGrammar.getSAXParser();
    StringReader aReader = new StringReader(fData);
    InputSource aSource = new InputSource(aReader);
    parser.setContentHandler(handler);
    try {
        parser.parse(aSource);
    }
    catch (SAXException e) {
        // this should never happen!
        // REVISIT:  what to do with this?; should really not
        // eat it...
    }
    catch (IOException i) {
        // ditto with above
    }
    // Release the reference to the user's ContentHandler.
    parser.setContentHandler(null);
}
 

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

private synchronized void writeToSAX(ContentHandler handler) {
    // nothing must go wrong with this parse...
    SAXParser parser = fGrammar.getSAXParser();
    StringReader aReader = new StringReader(fData);
    InputSource aSource = new InputSource(aReader);
    parser.setContentHandler(handler);
    try {
        parser.parse(aSource);
    }
    catch (SAXException e) {
        // this should never happen!
        // REVISIT:  what to do with this?; should really not
        // eat it...
    }
    catch (IOException i) {
        // ditto with above
    }
    // Release the reference to the user's ContentHandler.
    parser.setContentHandler(null);
}
 

static public IncrementalSAXSource createIncrementalSAXSource()
      {
              try
              {
                      return new IncrementalSAXSource_Xerces();
              }
              catch(NoSuchMethodException e)
              {
                      // Xerces version mismatch; neither Xerces1 nor Xerces2 succeeded.
                      // Fall back on filtering solution.
                      IncrementalSAXSource_Filter iss=new IncrementalSAXSource_Filter();
                      iss.setXMLReader(new SAXParser());
                      return iss;
              }
}
 

static public IncrementalSAXSource
createIncrementalSAXSource(SAXParser parser) {
              try
              {
                      return new IncrementalSAXSource_Xerces(parser);
              }
              catch(NoSuchMethodException e)
              {
                      // Xerces version mismatch; neither Xerces1 nor Xerces2 succeeded.
                      // Fall back on filtering solution.
                      IncrementalSAXSource_Filter iss=new IncrementalSAXSource_Filter();
                      iss.setXMLReader(parser);
                      return iss;
              }
}
 

static public IncrementalSAXSource createIncrementalSAXSource()
      {
              try
              {
                      return new IncrementalSAXSource_Xerces();
              }
              catch(NoSuchMethodException e)
              {
                      // Xerces version mismatch; neither Xerces1 nor Xerces2 succeeded.
                      // Fall back on filtering solution.
                      IncrementalSAXSource_Filter iss=new IncrementalSAXSource_Filter();
                      iss.setXMLReader(new SAXParser());
                      return iss;
              }
}
 

static public IncrementalSAXSource
createIncrementalSAXSource(SAXParser parser) {
              try
              {
                      return new IncrementalSAXSource_Xerces(parser);
              }
              catch(NoSuchMethodException e)
              {
                      // Xerces version mismatch; neither Xerces1 nor Xerces2 succeeded.
                      // Fall back on filtering solution.
                      IncrementalSAXSource_Filter iss=new IncrementalSAXSource_Filter();
                      iss.setXMLReader(parser);
                      return iss;
              }
}
 

private Config() throws Exception {
	// create XML parser
	SAXParser p = new SAXParser();
	// set object itsself as content handler
	p.setContentHandler(this);
	// create hashmap
	settings = new HashMap<String,String>();
	// start parsing
	p.parse(configFile);
}
 

private HelpTexts() {
	// create XML parser
	SAXParser p = new SAXParser();
	// set object itsself as content handler
	p.setContentHandler(this);
	// create hashmap
	texts = new HashMap<String,String>();
	// start parsing
	try {
		p.parse(new InputSource(this.getClass().getResourceAsStream(ClientGlobals.FILE_HELP)));
	} catch (Exception e) {
		JOptionPane.showMessageDialog(null, "Could not load help file '"+ClientGlobals.FILE_HELP+"'.\n\nError:\n" + e.getMessage(),"Error", JOptionPane.WARNING_MESSAGE);
	}
	
}
 

static public IncrementalSAXSource
createIncrementalSAXSource(SAXParser parser) {
              try
              {
                      return new IncrementalSAXSource_Xerces(parser);
              }
              catch(NoSuchMethodException e)
              {
                      // Xerces version mismatch; neither Xerces1 nor Xerces2 succeeded.
                      // Fall back on filtering solution.
                      IncrementalSAXSource_Filter iss=new IncrementalSAXSource_Filter();
                      iss.setXMLReader(parser);
                      return iss;
              }
}
 

private SubstMatrixList() throws SAXException, IOException {
		// create XML parser
		SAXParser p = new SAXParser();
		// set object itsself as content handler
		p.setContentHandler(this);
		// create vector		
		vec = new Vector<SubstMatrixFile>();
		// start parsing
//		System.out.println(ClientGlobals.PATH_MATRICES + ClientGlobals.FILE_MATRICES);
		p.parse(new InputSource(this.getClass().getResourceAsStream(ClientGlobals.PATH_MATRICES + ClientGlobals.FILE_MATRICES)));
	}