* This class is intended to be used in conjunction with * {@link AbstractSchemaImpl} to promote consistent * behaviors among {@link Schema} implementations. * *
* This class wraps a {@link javax.xml.validation.ValidatorHandler} * object and implements the {@link Validator} semantics. * * @author Kohsuke Kawaguchi * @version $Revision: 1.5 $, $Date: 2004/07/12 20:38:39 $ * @since 1.5 */ class ValidatorImpl extends Validator { /** * The actual validation will be done by this object. */ private final ValidatorHandlerImpl handler; /** * Lazily created identity transformer. */ private Transformer identityTransformer1 = null; private TransformerHandler identityTransformer2 = null; ValidatorImpl( ValidatorHandlerImpl _handler ) { this.handler = _handler; } public LSResourceResolver getResourceResolver() { return handler.getResourceResolver(); } public ErrorHandler getErrorHandler() { return handler.getErrorHandler(); } public void setResourceResolver(LSResourceResolver resolver) { handler.setResourceResolver(resolver); } public void setErrorHandler(ErrorHandler errorHandler) { handler.setErrorHandler(errorHandler); } public void validate(Source source, Result result) throws SAXException, IOException { if( source instanceof DOMSource ) { if( result!=null && !(result instanceof DOMResult) ) throw new IllegalArgumentException(result.getClass().getName()); process( (DOMSource)source, (DOMResult)result ); return; } if( source instanceof SAXSource ) { if( result!=null && !(result instanceof SAXResult) ) throw new IllegalArgumentException(result.getClass().getName()); process( (SAXSource)source, (SAXResult)result ); return; } if( source instanceof StreamSource ) { if( result!=null ) throw new IllegalArgumentException(result.getClass().getName()); StreamSource ss = (StreamSource)source; InputSource is = new InputSource(); is.setByteStream(ss.getInputStream()); is.setCharacterStream(ss.getReader()); is.setPublicId(ss.getPublicId()); is.setSystemId(ss.getSystemId()); process( new SAXSource(is), null ); return; } throw new IllegalArgumentException(source.getClass().getName()); } /** * Parses a {@link SAXSource} potentially to a {@link SAXResult}. */ private void process(SAXSource source, SAXResult result) throws IOException, SAXException { if( result!=null ) { handler.setContentHandler(result.getHandler()); } try { XMLReader reader = source.getXMLReader(); if( reader==null ) { // create one now SAXParserFactory spf = SAXParserFactory.newInstance(); spf.setNamespaceAware(true); try { reader = spf.newSAXParser().getXMLReader(); } catch( Exception e ) { // this is impossible, but better safe than sorry throw new FactoryConfigurationError(e); } } reader.setErrorHandler(errorForwarder); reader.setEntityResolver(resolutionForwarder); reader.setContentHandler(handler); InputSource is = source.getInputSource(); reader.parse(is); } finally { // release the reference to user's handler ASAP handler.setContentHandler(null); } } /** * Parses a {@link DOMSource} potentially to a {@link DOMResult}. */ private void process( DOMSource source, DOMResult result ) throws SAXException { if( identityTransformer1==null ) { try { SAXTransformerFactory tf = (SAXTransformerFactory)SAXTransformerFactory.newInstance(); identityTransformer1 = tf.newTransformer(); identityTransformer2 = tf.newTransformerHandler(); } catch (TransformerConfigurationException e) { // this is impossible, but again better safe than sorry throw new TransformerFactoryConfigurationError(e); } } if( result!=null ) { handler.setContentHandler(identityTransformer2); identityTransformer2.setResult(result); } try { identityTransformer1.transform( source, new SAXResult(handler) ); } catch (TransformerException e) { if( e.getException() instanceof SAXException ) throw (SAXException)e.getException(); throw new SAXException(e); } finally { handler.setContentHandler(null); } } /** * Forwards the error to the {@link ValidatorHandler}. * If the {@link ValidatorHandler} doesn't have its own * {@link ErrorHandler}, behave draconian. */ private final ErrorHandler errorForwarder = new ErrorHandler() { public void warning(SAXParseException exception) throws SAXException { ErrorHandler realHandler = handler.getErrorHandler(); if( realHandler!=null ) realHandler.warning(exception); } public void error(SAXParseException exception) throws SAXException { ErrorHandler realHandler = handler.getErrorHandler(); if( realHandler!=null ) realHandler.error(exception); else throw exception; } public void fatalError(SAXParseException exception) throws SAXException { ErrorHandler realHandler = handler.getErrorHandler(); if( realHandler!=null ) realHandler.fatalError(exception); else throw exception; } }; /** * Forwards the entity resolution to the {@link ValidatorHandler}. * If the {@link ValidatorHandler} doesn't have its own * {@link DOMResourceResolver}, let the parser do the resolution. */ private final EntityResolver resolutionForwarder = new EntityResolver() { public InputSource resolveEntity(String publicId, String systemId) throws SAXException, IOException { LSResourceResolver resolver = handler.getResourceResolver(); if( resolver==null ) return null; LSInput di = resolver.resolveResource(null,null,publicId,systemId,null); if(di==null) return null; InputSource r = new InputSource(); r.setByteStream(di.getByteStream()); r.setCharacterStream(di.getCharacterStream()); r.setEncoding(di.getEncoding()); r.setPublicId(di.getPublicId()); r.setSystemId(di.getSystemId()); return r; } }; public void reset() { handler.reset(); // I don't think this is necessary, but I don't think it hurts either. // so reset just for the kick. if(identityTransformer1!=null) { identityTransformer1.reset(); } } }