src/share/jaxws_classes/com/sun/xml/internal/bind/v2/runtime/unmarshaller/UnmarshallerImpl.java - platform/external/jetbrains/jdk8u_jaxws - Git at Google

 /*
  * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
  * published by the Free Software Foundation.  Oracle designates this
  * particular file as subject to the "Classpath" exception as provided
  * by Oracle in the LICENSE file that accompanied this code.
  *
  * This code is distributed in the hope that it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  * version 2 for more details (a copy is included in the LICENSE file that
  * accompanied this code).
  *
  * You should have received a copy of the GNU General Public License version
  * 2 along with this work; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  *
  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  * or visit www.oracle.com if you need additional information or have any
  * questions.
  */

 package com.sun.xml.internal.bind.v2.runtime.unmarshaller;

 import java.io.IOException;
 import java.io.InputStream;

 import javax.xml.bind.JAXBContext;
 import javax.xml.bind.JAXBElement;
 import javax.xml.bind.JAXBException;
 import javax.xml.bind.PropertyException;
 import javax.xml.bind.UnmarshalException;
 import javax.xml.bind.Unmarshaller;
 import javax.xml.bind.UnmarshallerHandler;
 import javax.xml.bind.ValidationEvent;
 import javax.xml.bind.ValidationEventHandler;
 import javax.xml.bind.annotation.adapters.XmlAdapter;
 import javax.xml.bind.attachment.AttachmentUnmarshaller;
 import javax.xml.bind.helpers.AbstractUnmarshallerImpl;
 import javax.xml.stream.XMLEventReader;
 import javax.xml.stream.XMLStreamConstants;
 import javax.xml.stream.XMLStreamException;
 import javax.xml.stream.XMLStreamReader;
 import javax.xml.stream.events.XMLEvent;
 import javax.xml.transform.Source;
 import javax.xml.transform.dom.DOMSource;
 import javax.xml.transform.sax.SAXSource;
 import javax.xml.transform.stream.StreamSource;
 import javax.xml.validation.Schema;

 import com.sun.xml.internal.bind.IDResolver;
 import com.sun.xml.internal.bind.api.ClassResolver;
 import com.sun.xml.internal.bind.unmarshaller.DOMScanner;
 import com.sun.xml.internal.bind.unmarshaller.InfosetScanner;
 import com.sun.xml.internal.bind.unmarshaller.Messages;
 import com.sun.xml.internal.bind.v2.ClassFactory;
 import com.sun.xml.internal.bind.v2.runtime.AssociationMap;
 import com.sun.xml.internal.bind.v2.runtime.JAXBContextImpl;
 import com.sun.xml.internal.bind.v2.runtime.JaxBeanInfo;
 import com.sun.xml.internal.bind.v2.util.XmlFactory;

 import java.io.Closeable;
 import javax.xml.parsers.ParserConfigurationException;
 import javax.xml.parsers.SAXParserFactory;
 import org.w3c.dom.Document;
 import org.w3c.dom.Element;
 import org.w3c.dom.Node;
 import org.xml.sax.InputSource;
 import org.xml.sax.SAXException;
 import org.xml.sax.XMLReader;
 import org.xml.sax.helpers.DefaultHandler;

 /**
  * Default Unmarshaller implementation.
  *
  * <p>
  * This class can be extended by the generated code to provide
  * type-safe unmarshall methods.
  *
  * @author
  *  <a href="mailto:kohsuke.kawaguchi@sun.com">Kohsuke KAWAGUCHI</a>
  */
  public final class UnmarshallerImpl extends AbstractUnmarshallerImpl implements ValidationEventHandler, Closeable
 {
     /** Owning {@link JAXBContext} */
     protected final JAXBContextImpl context;

     /**
      * schema which will be used to validate during calls to unmarshal
      */
     private Schema schema;

     public final UnmarshallingContext coordinator;

     /** Unmarshaller.Listener */
     private Listener externalListener;

     /**
      * The attachment unmarshaller used to support MTOM and swaRef.
      */
     private AttachmentUnmarshaller attachmentUnmarshaller;
     private IDResolver idResolver = new DefaultIDResolver();

     public UnmarshallerImpl( JAXBContextImpl context, AssociationMap assoc ) {
         this.context = context;
         this.coordinator = new UnmarshallingContext( this, assoc );

         try {
             setEventHandler(this);
         } catch (JAXBException e) {
             throw new AssertionError(e);    // impossible
         }
     }

     public UnmarshallerHandler getUnmarshallerHandler() {
         return getUnmarshallerHandler(true,null);
     }

     private XMLReader reader = null;

     /**
      * Obtains a configured XMLReader.
      *
      * This method is used when the client-specified
      * {@link SAXSource} object doesn't have XMLReader.
      *
      * {@link Unmarshaller} is not re-entrant, so we will
      * only use one instance of XMLReader.
      *
      * Overriden in order to fix potential security issue.
      */
      @Override
     protected XMLReader getXMLReader() throws JAXBException {
          if (reader == null) {
              try {
                  SAXParserFactory parserFactory = XmlFactory.createParserFactory(context.disableSecurityProcessing);
                  // there is no point in asking a validation because
                  // there is no guarantee that the document will come with
                  // a proper schemaLocation.
                  parserFactory.setValidating(false);
                  reader = parserFactory.newSAXParser().getXMLReader();
              } catch (ParserConfigurationException e) {
                  throw new JAXBException(e);
              } catch (SAXException e) {
                  throw new JAXBException(e);
              }
          }
          return reader;
      }

     private SAXConnector getUnmarshallerHandler( boolean intern, JaxBeanInfo expectedType ) {
         XmlVisitor h = createUnmarshallerHandler(null, false, expectedType);
         if (intern) {
             h = new InterningXmlVisitor(h);
         }
         return new SAXConnector(h,null);
     }

     /**
      * Creates and configures a new unmarshalling pipe line.
      * Depending on the setting, we put a validator as a filter.
      *
      * @return
      *      A component that implements both {@link UnmarshallerHandler}
      *      and {@link ValidationEventHandler}. All the parsing errors
      *      should be reported to this error handler for the unmarshalling
      *      process to work correctly.
      *
      *      Also, returned handler expects all the XML names to be interned.
      *
      */
     public final XmlVisitor createUnmarshallerHandler(InfosetScanner scanner, boolean inplace, JaxBeanInfo expectedType ) {

         coordinator.reset(scanner,inplace,expectedType,idResolver);
         XmlVisitor unmarshaller = coordinator;

         // delegate to JAXP 1.3 for validation if the client provided a schema
         if (schema != null) {
             unmarshaller = new ValidatingUnmarshaller(schema,unmarshaller);
         }

         if(attachmentUnmarshaller!=null && attachmentUnmarshaller.isXOPPackage()) {
             unmarshaller = new MTOMDecorator(this,unmarshaller,attachmentUnmarshaller);
         }

         return unmarshaller;
     }

     private static final DefaultHandler dummyHandler = new DefaultHandler();

     public static boolean needsInterning( XMLReader reader ) {
         // attempt to set it to true, which could fail
         try {
             reader.setFeature("http://xml.org/sax/features/string-interning",true);
         } catch (SAXException e) {
             // if it fails that's fine. we'll work around on our side
         }

         try {
             if (reader.getFeature("http://xml.org/sax/features/string-interning")) {
                 return false;   // no need for intern
             }
         } catch (SAXException e) {
             // unrecognized/unsupported
         }
         // otherwise we need intern
         return true;
     }

     protected Object unmarshal( XMLReader reader, InputSource source ) throws JAXBException {
         return unmarshal0(reader,source,null);
     }

     protected <T> JAXBElement<T> unmarshal( XMLReader reader, InputSource source, Class<T> expectedType ) throws JAXBException {
         if(expectedType==null) {
             throw new IllegalArgumentException();
         }
         return (JAXBElement)unmarshal0(reader,source,getBeanInfo(expectedType));
     }

     private Object unmarshal0( XMLReader reader, InputSource source, JaxBeanInfo expectedType ) throws JAXBException {

         SAXConnector connector = getUnmarshallerHandler(needsInterning(reader),expectedType);

         reader.setContentHandler(connector);
         // saxErrorHandler will be set by the getUnmarshallerHandler method.
         // configure XMLReader so that the error will be sent to it.
         // This is essential for the UnmarshallerHandler to be able to abort
         // unmarshalling when an error is found.
         //
         // Note that when this XMLReader is provided by the client code,
         // it might be already configured to call a client error handler.
         // This will clobber such handler, if any.
         //
         // Ryan noted that we might want to report errors to such a client
         // error handler as well.
         reader.setErrorHandler(coordinator);

         try {
             reader.parse(source);
         } catch( IOException e ) {
             coordinator.clearStates();
             throw new UnmarshalException(e);
         } catch( SAXException e ) {
             coordinator.clearStates();
             throw createUnmarshalException(e);
         }

         Object result = connector.getResult();

         // avoid keeping unnecessary references too long to let the GC
         // reclaim more memory.
         // setting null upsets some parsers, so use a dummy instance instead.
         reader.setContentHandler(dummyHandler);
         reader.setErrorHandler(dummyHandler);

         return result;
     }

     @Override
     public <T> JAXBElement<T> unmarshal( Source source, Class<T> expectedType ) throws JAXBException {
         if (source instanceof SAXSource) {
             SAXSource ss = (SAXSource) source;

             XMLReader locReader = ss.getXMLReader();
             if (locReader == null) {
                 locReader = getXMLReader();
             }

             return unmarshal(locReader, ss.getInputSource(), expectedType);
         }
         if (source instanceof StreamSource) {
             return unmarshal(getXMLReader(), streamSourceToInputSource((StreamSource) source), expectedType);
         }
         if (source instanceof DOMSource) {
             return unmarshal(((DOMSource) source).getNode(), expectedType);
         }

         // we don't handle other types of Source
         throw new IllegalArgumentException();
     }

     public Object unmarshal0( Source source, JaxBeanInfo expectedType ) throws JAXBException {
         if (source instanceof SAXSource) {
             SAXSource ss = (SAXSource) source;

             XMLReader locReader = ss.getXMLReader();
             if (locReader == null) {
                 locReader = getXMLReader();
             }

             return unmarshal0(locReader, ss.getInputSource(), expectedType);
         }
         if (source instanceof StreamSource) {
             return unmarshal0(getXMLReader(), streamSourceToInputSource((StreamSource) source), expectedType);
         }
         if (source instanceof DOMSource) {
             return unmarshal0(((DOMSource) source).getNode(), expectedType);
         }

         // we don't handle other types of Source
         throw new IllegalArgumentException();
     }


     @Override
     public final ValidationEventHandler getEventHandler() {
         try {
             return super.getEventHandler();
         } catch (JAXBException e) {
             // impossible
             throw new AssertionError();
         }
     }

     /**
      * Returns true if an event handler is installed.
      * <p>
      * The default handler ignores any errors, and for that this method returns false.
      */
     public final boolean hasEventHandler() {
         return getEventHandler()!=this;
     }

     @Override
     public <T> JAXBElement<T> unmarshal(Node node, Class<T> expectedType) throws JAXBException {
         if (expectedType == null) {
             throw new IllegalArgumentException();
         }
         return (JAXBElement)unmarshal0(node,getBeanInfo(expectedType));
     }

     public final Object unmarshal( Node node ) throws JAXBException {
         return unmarshal0(node,null);
     }

     // just to make the the test harness happy by making this method accessible
     @Deprecated
     public final Object unmarshal( SAXSource source ) throws JAXBException {
         return super.unmarshal(source);
     }

     public final Object unmarshal0( Node node, JaxBeanInfo expectedType ) throws JAXBException {
         try {
             final DOMScanner scanner = new DOMScanner();

             InterningXmlVisitor handler = new InterningXmlVisitor(createUnmarshallerHandler(null,false,expectedType));
             scanner.setContentHandler(new SAXConnector(handler,scanner));

             if(node.getNodeType() == Node.ELEMENT_NODE) {
                 scanner.scan((Element)node);
             } else if(node.getNodeType() == Node.DOCUMENT_NODE) {
                 scanner.scan((Document)node);
             } else {
                 throw new IllegalArgumentException("Unexpected node type: "+node);
             }

             Object retVal = handler.getContext().getResult();
             handler.getContext().clearResult();
             return retVal;
         } catch( SAXException e ) {
             throw createUnmarshalException(e);
         }
     }

     @Override
     public Object unmarshal(XMLStreamReader reader) throws JAXBException {
         return unmarshal0(reader,null);
     }

     @Override
     public <T> JAXBElement<T> unmarshal(XMLStreamReader reader, Class<T> expectedType) throws JAXBException {
         if (expectedType==null) {
             throw new IllegalArgumentException();
         }
         return (JAXBElement)unmarshal0(reader,getBeanInfo(expectedType));
     }

     public Object unmarshal0(XMLStreamReader reader, JaxBeanInfo expectedType) throws JAXBException {
         if (reader == null) {
             throw new IllegalArgumentException(
                 Messages.format(Messages.NULL_READER));
         }

         int eventType = reader.getEventType();
         if (eventType != XMLStreamConstants.START_ELEMENT
             && eventType != XMLStreamConstants.START_DOCUMENT) {
             // TODO: convert eventType into event name
             throw new IllegalStateException(
                 Messages.format(Messages.ILLEGAL_READER_STATE,eventType));
         }

         XmlVisitor h = createUnmarshallerHandler(null,false,expectedType);
         StAXConnector connector=StAXStreamConnector.create(reader,h);

         try {
             connector.bridge();
         } catch (XMLStreamException e) {
             throw handleStreamException(e);
         }

         Object retVal = h.getContext().getResult();
         h.getContext().clearResult();
         return retVal;
     }

     @Override
     public <T> JAXBElement<T> unmarshal(XMLEventReader reader, Class<T> expectedType) throws JAXBException {
         if(expectedType==null) {
             throw new IllegalArgumentException();
         }
         return (JAXBElement)unmarshal0(reader,getBeanInfo(expectedType));
     }

     @Override
     public Object unmarshal(XMLEventReader reader) throws JAXBException {
         return unmarshal0(reader,null);
     }

     private Object unmarshal0(XMLEventReader reader,JaxBeanInfo expectedType) throws JAXBException {
         if (reader == null) {
             throw new IllegalArgumentException(
                     Messages.format(Messages.NULL_READER));
         }

         try {
             XMLEvent event = reader.peek();

             if (!event.isStartElement() && !event.isStartDocument()) {
                 // TODO: convert event into event name
                 throw new IllegalStateException(
                     Messages.format(
                         Messages.ILLEGAL_READER_STATE,event.getEventType()));
             }

             // Quick hack until SJSXP fixes 6270116
             boolean isZephyr = reader.getClass().getName().equals("com.sun.xml.internal.stream.XMLReaderImpl");
             XmlVisitor h = createUnmarshallerHandler(null,false,expectedType);
             if(!isZephyr) {
                 h = new InterningXmlVisitor(h);
             }
             new StAXEventConnector(reader,h).bridge();
             return h.getContext().getResult();
         } catch (XMLStreamException e) {
             throw handleStreamException(e);
         }
     }

     public Object unmarshal0( InputStream input, JaxBeanInfo expectedType ) throws JAXBException {
         return unmarshal0(getXMLReader(),new InputSource(input),expectedType);
     }

     private static JAXBException handleStreamException(XMLStreamException e) {
         // StAXStreamConnector wraps SAXException to XMLStreamException.
         // XMLStreamException doesn't print its nested stack trace when it prints
         // its stack trace, so if we wrap XMLStreamException in JAXBException,
         // it becomes harder to find out the real problem.
         // So we unwrap them here. But we don't want to unwrap too eagerly, because
         // that could throw away some meaningful exception information.
         Throwable ne = e.getNestedException();
         if(ne instanceof JAXBException) {
             return (JAXBException)ne;
         }
         if(ne instanceof SAXException) {
             return new UnmarshalException(ne);
         }
         return new UnmarshalException(e);
     }

     @Override
     public Object getProperty(String name) throws PropertyException {
         if(name.equals(IDResolver.class.getName())) {
             return idResolver;
         }
         return super.getProperty(name);
     }

     @Override
     public void setProperty(String name, Object value) throws PropertyException {
         if(name.equals(FACTORY)) {
             coordinator.setFactories(value);
             return;
         }
         if(name.equals(IDResolver.class.getName())) {
             idResolver = (IDResolver)value;
             return;
         }
         if(name.equals(ClassResolver.class.getName())) {
             coordinator.classResolver = (ClassResolver)value;
             return;
         }
         if(name.equals(ClassLoader.class.getName())) {
             coordinator.classLoader = (ClassLoader)value;
             return;
         }
         super.setProperty(name, value);
     }

     public static final String FACTORY = "com.sun.xml.internal.bind.ObjectFactory";

     @Override
     public void setSchema(Schema schema) {
         this.schema = schema;
     }

     @Override
     public Schema getSchema() {
         return schema;
     }

     @Override
     public AttachmentUnmarshaller getAttachmentUnmarshaller() {
         return attachmentUnmarshaller;
     }

     @Override
     public void setAttachmentUnmarshaller(AttachmentUnmarshaller au) {
         this.attachmentUnmarshaller = au;
     }

     /**
      * @deprecated since 2.0
      */
     @Override
     public boolean isValidating() {
         throw new UnsupportedOperationException();
     }

     /**
      * @deprecated since 2.0
      */
     @Override
     public void setValidating(boolean validating) {
         throw new UnsupportedOperationException();
     }

     @Override
     public <A extends XmlAdapter> void setAdapter(Class<A> type, A adapter) {
         if (type==null) {
             throw new IllegalArgumentException();
         }
         coordinator.putAdapter(type,adapter);
     }

     @Override
     public <A extends XmlAdapter> A getAdapter(Class<A> type) {
         if(type==null) {
             throw new IllegalArgumentException();
         }
         if(coordinator.containsAdapter(type)) {
             return coordinator.getAdapter(type);
         } else {
             return null;
         }
     }

     // opening up for public use
     @Override
     public UnmarshalException createUnmarshalException( SAXException e ) {
         return super.createUnmarshalException(e);
     }


     /**
      * Default error handling behavior for {@link Unmarshaller}.
      */
     public boolean handleEvent(ValidationEvent event) {
         return event.getSeverity()!=ValidationEvent.FATAL_ERROR;
     }

     private static InputSource streamSourceToInputSource( StreamSource ss ) {
         InputSource is = new InputSource();
         is.setSystemId( ss.getSystemId() );
         is.setByteStream( ss.getInputStream() );
         is.setCharacterStream( ss.getReader() );

         return is;
     }

     public <T> JaxBeanInfo<T> getBeanInfo(Class<T> clazz) throws JAXBException {
         return context.getBeanInfo(clazz,true);
     }

     @Override
     public Listener getListener() {
         return externalListener;
     }

     @Override
     public void setListener(Listener listener) {
         externalListener = listener;
     }

     public UnmarshallingContext getContext() {
         return coordinator;
     }

     @Override
     @SuppressWarnings("FinalizeDeclaration")
     protected void finalize() throws Throwable {
         try {
             ClassFactory.cleanCache();
         } finally {
             super.finalize();
         }
     }

     /**
      *  Must be called from same thread which created the UnmarshallerImpl instance.
      * @throws IOException
      */
     public void close() throws IOException {
         ClassFactory.cleanCache();
     }

 }
	/*
	* Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation. Oracle designates this
	* particular file as subject to the "Classpath" exception as provided
	* by Oracle in the LICENSE file that accompanied this code.
	*
	* This code is distributed in the hope that it will be useful, but WITHOUT
	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*/

	package com.sun.xml.internal.bind.v2.runtime.unmarshaller;

	import java.io.IOException;
	import java.io.InputStream;

	import javax.xml.bind.JAXBContext;
	import javax.xml.bind.JAXBElement;
	import javax.xml.bind.JAXBException;
	import javax.xml.bind.PropertyException;
	import javax.xml.bind.UnmarshalException;
	import javax.xml.bind.Unmarshaller;
	import javax.xml.bind.UnmarshallerHandler;
	import javax.xml.bind.ValidationEvent;
	import javax.xml.bind.ValidationEventHandler;
	import javax.xml.bind.annotation.adapters.XmlAdapter;
	import javax.xml.bind.attachment.AttachmentUnmarshaller;
	import javax.xml.bind.helpers.AbstractUnmarshallerImpl;
	import javax.xml.stream.XMLEventReader;
	import javax.xml.stream.XMLStreamConstants;
	import javax.xml.stream.XMLStreamException;
	import javax.xml.stream.XMLStreamReader;
	import javax.xml.stream.events.XMLEvent;
	import javax.xml.transform.Source;
	import javax.xml.transform.dom.DOMSource;
	import javax.xml.transform.sax.SAXSource;
	import javax.xml.transform.stream.StreamSource;
	import javax.xml.validation.Schema;

	import com.sun.xml.internal.bind.IDResolver;
	import com.sun.xml.internal.bind.api.ClassResolver;
	import com.sun.xml.internal.bind.unmarshaller.DOMScanner;
	import com.sun.xml.internal.bind.unmarshaller.InfosetScanner;
	import com.sun.xml.internal.bind.unmarshaller.Messages;
	import com.sun.xml.internal.bind.v2.ClassFactory;
	import com.sun.xml.internal.bind.v2.runtime.AssociationMap;
	import com.sun.xml.internal.bind.v2.runtime.JAXBContextImpl;
	import com.sun.xml.internal.bind.v2.runtime.JaxBeanInfo;
	import com.sun.xml.internal.bind.v2.util.XmlFactory;

	import java.io.Closeable;
	import javax.xml.parsers.ParserConfigurationException;
	import javax.xml.parsers.SAXParserFactory;
	import org.w3c.dom.Document;
	import org.w3c.dom.Element;
	import org.w3c.dom.Node;
	import org.xml.sax.InputSource;
	import org.xml.sax.SAXException;
	import org.xml.sax.XMLReader;
	import org.xml.sax.helpers.DefaultHandler;

	/**
	* Default Unmarshaller implementation.
	*
	* <p>
	* This class can be extended by the generated code to provide
	* type-safe unmarshall methods.
	*
	* @author
	* <a href="mailto:kohsuke.kawaguchi@sun.com">Kohsuke KAWAGUCHI</a>
	*/
	public final class UnmarshallerImpl extends AbstractUnmarshallerImpl implements ValidationEventHandler, Closeable
	{
	/** Owning {@link JAXBContext} */
	protected final JAXBContextImpl context;

	/**
	* schema which will be used to validate during calls to unmarshal
	*/
	private Schema schema;

	public final UnmarshallingContext coordinator;

	/** Unmarshaller.Listener */
	private Listener externalListener;

	/**
	* The attachment unmarshaller used to support MTOM and swaRef.
	*/
	private AttachmentUnmarshaller attachmentUnmarshaller;
	private IDResolver idResolver = new DefaultIDResolver();

	public UnmarshallerImpl( JAXBContextImpl context, AssociationMap assoc ) {
	this.context = context;
	this.coordinator = new UnmarshallingContext( this, assoc );

	try {
	setEventHandler(this);
	} catch (JAXBException e) {
	throw new AssertionError(e); // impossible
	}
	}

	public UnmarshallerHandler getUnmarshallerHandler() {
	return getUnmarshallerHandler(true,null);
	}

	private XMLReader reader = null;

	/**
	* Obtains a configured XMLReader.
	*
	* This method is used when the client-specified
	* {@link SAXSource} object doesn't have XMLReader.
	*
	* {@link Unmarshaller} is not re-entrant, so we will
	* only use one instance of XMLReader.
	*
	* Overriden in order to fix potential security issue.
	*/
	@Override
	protected XMLReader getXMLReader() throws JAXBException {
	if (reader == null) {
	try {
	SAXParserFactory parserFactory = XmlFactory.createParserFactory(context.disableSecurityProcessing);
	// there is no point in asking a validation because
	// there is no guarantee that the document will come with
	// a proper schemaLocation.
	parserFactory.setValidating(false);
	reader = parserFactory.newSAXParser().getXMLReader();
	} catch (ParserConfigurationException e) {
	throw new JAXBException(e);
	} catch (SAXException e) {
	throw new JAXBException(e);
	}
	}
	return reader;
	}

	private SAXConnector getUnmarshallerHandler( boolean intern, JaxBeanInfo expectedType ) {
	XmlVisitor h = createUnmarshallerHandler(null, false, expectedType);
	if (intern) {
	h = new InterningXmlVisitor(h);
	}
	return new SAXConnector(h,null);
	}

	/**
	* Creates and configures a new unmarshalling pipe line.
	* Depending on the setting, we put a validator as a filter.
	*
	* @return
	* A component that implements both {@link UnmarshallerHandler}
	* and {@link ValidationEventHandler}. All the parsing errors
	* should be reported to this error handler for the unmarshalling
	* process to work correctly.
	*
	* Also, returned handler expects all the XML names to be interned.
	*
	*/
	public final XmlVisitor createUnmarshallerHandler(InfosetScanner scanner, boolean inplace, JaxBeanInfo expectedType ) {

	coordinator.reset(scanner,inplace,expectedType,idResolver);
	XmlVisitor unmarshaller = coordinator;

	// delegate to JAXP 1.3 for validation if the client provided a schema
	if (schema != null) {
	unmarshaller = new ValidatingUnmarshaller(schema,unmarshaller);
	}

	if(attachmentUnmarshaller!=null && attachmentUnmarshaller.isXOPPackage()) {
	unmarshaller = new MTOMDecorator(this,unmarshaller,attachmentUnmarshaller);
	}

	return unmarshaller;
	}

	private static final DefaultHandler dummyHandler = new DefaultHandler();

	public static boolean needsInterning( XMLReader reader ) {
	// attempt to set it to true, which could fail
	try {
	reader.setFeature("http://xml.org/sax/features/string-interning",true);
	} catch (SAXException e) {
	// if it fails that's fine. we'll work around on our side
	}

	try {
	if (reader.getFeature("http://xml.org/sax/features/string-interning")) {
	return false; // no need for intern
	}
	} catch (SAXException e) {
	// unrecognized/unsupported
	}
	// otherwise we need intern
	return true;
	}

	protected Object unmarshal( XMLReader reader, InputSource source ) throws JAXBException {
	return unmarshal0(reader,source,null);
	}

	protected <T> JAXBElement<T> unmarshal( XMLReader reader, InputSource source, Class<T> expectedType ) throws JAXBException {
	if(expectedType==null) {
	throw new IllegalArgumentException();
	}
	return (JAXBElement)unmarshal0(reader,source,getBeanInfo(expectedType));
	}

	private Object unmarshal0( XMLReader reader, InputSource source, JaxBeanInfo expectedType ) throws JAXBException {

	SAXConnector connector = getUnmarshallerHandler(needsInterning(reader),expectedType);

	reader.setContentHandler(connector);
	// saxErrorHandler will be set by the getUnmarshallerHandler method.
	// configure XMLReader so that the error will be sent to it.
	// This is essential for the UnmarshallerHandler to be able to abort
	// unmarshalling when an error is found.
	//
	// Note that when this XMLReader is provided by the client code,
	// it might be already configured to call a client error handler.
	// This will clobber such handler, if any.
	//
	// Ryan noted that we might want to report errors to such a client
	// error handler as well.
	reader.setErrorHandler(coordinator);

	try {
	reader.parse(source);
	} catch( IOException e ) {
	coordinator.clearStates();
	throw new UnmarshalException(e);
	} catch( SAXException e ) {
	coordinator.clearStates();
	throw createUnmarshalException(e);
	}

	Object result = connector.getResult();

	// avoid keeping unnecessary references too long to let the GC
	// reclaim more memory.
	// setting null upsets some parsers, so use a dummy instance instead.
	reader.setContentHandler(dummyHandler);
	reader.setErrorHandler(dummyHandler);

	return result;
	}

	@Override
	public <T> JAXBElement<T> unmarshal( Source source, Class<T> expectedType ) throws JAXBException {
	if (source instanceof SAXSource) {
	SAXSource ss = (SAXSource) source;

	XMLReader locReader = ss.getXMLReader();
	if (locReader == null) {
	locReader = getXMLReader();
	}

	return unmarshal(locReader, ss.getInputSource(), expectedType);
	}
	if (source instanceof StreamSource) {
	return unmarshal(getXMLReader(), streamSourceToInputSource((StreamSource) source), expectedType);
	}
	if (source instanceof DOMSource) {
	return unmarshal(((DOMSource) source).getNode(), expectedType);
	}

	// we don't handle other types of Source
	throw new IllegalArgumentException();
	}

	public Object unmarshal0( Source source, JaxBeanInfo expectedType ) throws JAXBException {
	if (source instanceof SAXSource) {
	SAXSource ss = (SAXSource) source;

	XMLReader locReader = ss.getXMLReader();
	if (locReader == null) {
	locReader = getXMLReader();
	}

	return unmarshal0(locReader, ss.getInputSource(), expectedType);
	}
	if (source instanceof StreamSource) {
	return unmarshal0(getXMLReader(), streamSourceToInputSource((StreamSource) source), expectedType);
	}
	if (source instanceof DOMSource) {
	return unmarshal0(((DOMSource) source).getNode(), expectedType);
	}

	// we don't handle other types of Source
	throw new IllegalArgumentException();
	}


	@Override
	public final ValidationEventHandler getEventHandler() {
	try {
	return super.getEventHandler();
	} catch (JAXBException e) {
	// impossible
	throw new AssertionError();
	}
	}

	/**
	* Returns true if an event handler is installed.
	* <p>
	* The default handler ignores any errors, and for that this method returns false.
	*/
	public final boolean hasEventHandler() {
	return getEventHandler()!=this;
	}

	@Override
	public <T> JAXBElement<T> unmarshal(Node node, Class<T> expectedType) throws JAXBException {
	if (expectedType == null) {
	throw new IllegalArgumentException();
	}
	return (JAXBElement)unmarshal0(node,getBeanInfo(expectedType));
	}

	public final Object unmarshal( Node node ) throws JAXBException {
	return unmarshal0(node,null);
	}

	// just to make the the test harness happy by making this method accessible
	@Deprecated
	public final Object unmarshal( SAXSource source ) throws JAXBException {
	return super.unmarshal(source);
	}

	public final Object unmarshal0( Node node, JaxBeanInfo expectedType ) throws JAXBException {
	try {
	final DOMScanner scanner = new DOMScanner();

	InterningXmlVisitor handler = new InterningXmlVisitor(createUnmarshallerHandler(null,false,expectedType));
	scanner.setContentHandler(new SAXConnector(handler,scanner));

	if(node.getNodeType() == Node.ELEMENT_NODE) {
	scanner.scan((Element)node);
	} else if(node.getNodeType() == Node.DOCUMENT_NODE) {
	scanner.scan((Document)node);
	} else {
	throw new IllegalArgumentException("Unexpected node type: "+node);
	}

	Object retVal = handler.getContext().getResult();
	handler.getContext().clearResult();
	return retVal;
	} catch( SAXException e ) {
	throw createUnmarshalException(e);
	}
	}

	@Override
	public Object unmarshal(XMLStreamReader reader) throws JAXBException {
	return unmarshal0(reader,null);
	}

	@Override
	public <T> JAXBElement<T> unmarshal(XMLStreamReader reader, Class<T> expectedType) throws JAXBException {
	if (expectedType==null) {
	throw new IllegalArgumentException();
	}
	return (JAXBElement)unmarshal0(reader,getBeanInfo(expectedType));
	}

	public Object unmarshal0(XMLStreamReader reader, JaxBeanInfo expectedType) throws JAXBException {
	if (reader == null) {
	throw new IllegalArgumentException(
	Messages.format(Messages.NULL_READER));
	}

	int eventType = reader.getEventType();
	if (eventType != XMLStreamConstants.START_ELEMENT
	&& eventType != XMLStreamConstants.START_DOCUMENT) {
	// TODO: convert eventType into event name
	throw new IllegalStateException(
	Messages.format(Messages.ILLEGAL_READER_STATE,eventType));
	}

	XmlVisitor h = createUnmarshallerHandler(null,false,expectedType);
	StAXConnector connector=StAXStreamConnector.create(reader,h);

	try {
	connector.bridge();
	} catch (XMLStreamException e) {
	throw handleStreamException(e);
	}

	Object retVal = h.getContext().getResult();
	h.getContext().clearResult();
	return retVal;
	}

	@Override
	public <T> JAXBElement<T> unmarshal(XMLEventReader reader, Class<T> expectedType) throws JAXBException {
	if(expectedType==null) {
	throw new IllegalArgumentException();
	}
	return (JAXBElement)unmarshal0(reader,getBeanInfo(expectedType));
	}

	@Override
	public Object unmarshal(XMLEventReader reader) throws JAXBException {
	return unmarshal0(reader,null);
	}

	private Object unmarshal0(XMLEventReader reader,JaxBeanInfo expectedType) throws JAXBException {
	if (reader == null) {
	throw new IllegalArgumentException(
	Messages.format(Messages.NULL_READER));
	}

	try {
	XMLEvent event = reader.peek();

	if (!event.isStartElement() && !event.isStartDocument()) {
	// TODO: convert event into event name
	throw new IllegalStateException(
	Messages.format(
	Messages.ILLEGAL_READER_STATE,event.getEventType()));
	}

	// Quick hack until SJSXP fixes 6270116
	boolean isZephyr = reader.getClass().getName().equals("com.sun.xml.internal.stream.XMLReaderImpl");
	XmlVisitor h = createUnmarshallerHandler(null,false,expectedType);
	if(!isZephyr) {
	h = new InterningXmlVisitor(h);
	}
	new StAXEventConnector(reader,h).bridge();
	return h.getContext().getResult();
	} catch (XMLStreamException e) {
	throw handleStreamException(e);
	}
	}

	public Object unmarshal0( InputStream input, JaxBeanInfo expectedType ) throws JAXBException {
	return unmarshal0(getXMLReader(),new InputSource(input),expectedType);
	}

	private static JAXBException handleStreamException(XMLStreamException e) {
	// StAXStreamConnector wraps SAXException to XMLStreamException.
	// XMLStreamException doesn't print its nested stack trace when it prints
	// its stack trace, so if we wrap XMLStreamException in JAXBException,
	// it becomes harder to find out the real problem.
	// So we unwrap them here. But we don't want to unwrap too eagerly, because
	// that could throw away some meaningful exception information.
	Throwable ne = e.getNestedException();
	if(ne instanceof JAXBException) {
	return (JAXBException)ne;
	}
	if(ne instanceof SAXException) {
	return new UnmarshalException(ne);
	}
	return new UnmarshalException(e);
	}

	@Override
	public Object getProperty(String name) throws PropertyException {
	if(name.equals(IDResolver.class.getName())) {
	return idResolver;
	}
	return super.getProperty(name);
	}

	@Override
	public void setProperty(String name, Object value) throws PropertyException {
	if(name.equals(FACTORY)) {
	coordinator.setFactories(value);
	return;
	}
	if(name.equals(IDResolver.class.getName())) {
	idResolver = (IDResolver)value;
	return;
	}
	if(name.equals(ClassResolver.class.getName())) {
	coordinator.classResolver = (ClassResolver)value;
	return;
	}
	if(name.equals(ClassLoader.class.getName())) {
	coordinator.classLoader = (ClassLoader)value;
	return;
	}
	super.setProperty(name, value);
	}

	public static final String FACTORY = "com.sun.xml.internal.bind.ObjectFactory";

	@Override
	public void setSchema(Schema schema) {
	this.schema = schema;
	}

	@Override
	public Schema getSchema() {
	return schema;
	}

	@Override
	public AttachmentUnmarshaller getAttachmentUnmarshaller() {
	return attachmentUnmarshaller;
	}

	@Override
	public void setAttachmentUnmarshaller(AttachmentUnmarshaller au) {
	this.attachmentUnmarshaller = au;
	}

	/**
	* @deprecated since 2.0
	*/
	@Override
	public boolean isValidating() {
	throw new UnsupportedOperationException();
	}

	/**
	* @deprecated since 2.0
	*/
	@Override
	public void setValidating(boolean validating) {
	throw new UnsupportedOperationException();
	}

	@Override
	public <A extends XmlAdapter> void setAdapter(Class<A> type, A adapter) {
	if (type==null) {
	throw new IllegalArgumentException();
	}
	coordinator.putAdapter(type,adapter);
	}

	@Override
	public <A extends XmlAdapter> A getAdapter(Class<A> type) {
	if(type==null) {
	throw new IllegalArgumentException();
	}
	if(coordinator.containsAdapter(type)) {
	return coordinator.getAdapter(type);
	} else {
	return null;
	}
	}

	// opening up for public use
	@Override
	public UnmarshalException createUnmarshalException( SAXException e ) {
	return super.createUnmarshalException(e);
	}


	/**
	* Default error handling behavior for {@link Unmarshaller}.
	*/
	public boolean handleEvent(ValidationEvent event) {
	return event.getSeverity()!=ValidationEvent.FATAL_ERROR;
	}

	private static InputSource streamSourceToInputSource( StreamSource ss ) {
	InputSource is = new InputSource();
	is.setSystemId( ss.getSystemId() );
	is.setByteStream( ss.getInputStream() );
	is.setCharacterStream( ss.getReader() );

	return is;
	}

	public <T> JaxBeanInfo<T> getBeanInfo(Class<T> clazz) throws JAXBException {
	return context.getBeanInfo(clazz,true);
	}

	@Override
	public Listener getListener() {
	return externalListener;
	}

	@Override
	public void setListener(Listener listener) {
	externalListener = listener;
	}

	public UnmarshallingContext getContext() {
	return coordinator;
	}

	@Override
	@SuppressWarnings("FinalizeDeclaration")
	protected void finalize() throws Throwable {
	try {
	ClassFactory.cleanCache();
	} finally {
	super.finalize();
	}
	}

	/**
	* Must be called from same thread which created the UnmarshallerImpl instance.
	* @throws IOException
	*/
	public void close() throws IOException {
	ClassFactory.cleanCache();
	}

	}