Mercurial > jdk8-mips64-public > jaxws / file revision

 /*

  * Copyright (c) 1997, 2013, 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.lang.reflect.InvocationTargetException;

 import java.lang.reflect.Method;

 import java.util.ArrayList;

 import java.util.Collection;

 import java.util.Collections;

 import java.util.HashMap;

 import java.util.Iterator;

 import java.util.List;

 import java.util.Map;

 import java.util.concurrent.Callable;

 import java.util.logging.Level;

 import java.util.logging.Logger;

 import javax.xml.XMLConstants;

 import javax.xml.bind.JAXBElement;

 import javax.xml.bind.UnmarshalException;

 import javax.xml.bind.Unmarshaller;

 import javax.xml.bind.ValidationEvent;

 import javax.xml.bind.ValidationEventHandler;

 import javax.xml.bind.ValidationEventLocator;

 import javax.xml.bind.helpers.ValidationEventImpl;

 import javax.xml.namespace.NamespaceContext;

 import javax.xml.namespace.QName;

 import com.sun.istack.internal.NotNull;

 import com.sun.istack.internal.Nullable;

 import com.sun.istack.internal.SAXParseException2;

 import com.sun.xml.internal.bind.IDResolver;

 import com.sun.xml.internal.bind.Util;

 import com.sun.xml.internal.bind.api.AccessorException;

 import com.sun.xml.internal.bind.api.ClassResolver;

 import com.sun.xml.internal.bind.unmarshaller.InfosetScanner;

 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.Coordinator;

 import com.sun.xml.internal.bind.v2.runtime.JAXBContextImpl;

 import com.sun.xml.internal.bind.v2.runtime.JaxBeanInfo;

 import java.util.logging.Level;

 import java.util.logging.Logger;

 import org.xml.sax.ErrorHandler;

 import org.xml.sax.SAXException;

 import org.xml.sax.helpers.LocatorImpl;

 /**

  * Center of the unmarshalling.

  *

  * <p>

  * This object is responsible for coordinating {@link Loader}s to

  * perform the whole unmarshalling.

  *

  * @author Kohsuke Kawaguchi

  */

 public final class UnmarshallingContext extends Coordinator

     implements NamespaceContext, ValidationEventHandler, ErrorHandler, XmlVisitor, XmlVisitor.TextPredictor {

     private static final Logger logger = Logger.getLogger(UnmarshallingContext.class.getName());

     /**

      * Root state.

      */

     private final State root;

     /**

      * The currently active state.

      */

     private State current;

     private static final LocatorEx DUMMY_INSTANCE;

     static {

         LocatorImpl loc = new LocatorImpl();

         loc.setPublicId(null);

         loc.setSystemId(null);

         loc.setLineNumber(-1);

         loc.setColumnNumber(-1);

         DUMMY_INSTANCE = new LocatorExWrapper(loc);

     }

     private @NotNull LocatorEx locator = DUMMY_INSTANCE;

     /** Root object that is being unmarshalled. */

     private Object result;

     /**

      * If non-null, this unmarshaller will unmarshal {@code JAXBElement<EXPECTEDTYPE>}

      * regardless of the tag name, as opposed to deciding the root object by using

      * the tag name.

      *

      * The property has a package-level access, because we cannot copy this value

      * to {@link UnmarshallingContext} when it is created. The property

      * on {@link Unmarshaller} could be changed after the handler is created.

      */

     private JaxBeanInfo expectedType;

     /**

      * Handles ID/IDREF.

      */

     private IDResolver idResolver;

     /**

      * This flag is set to true at the startDocument event

      * and false at the endDocument event.

      *

      * Until the first document is unmarshalled, we don't

      * want to return an object. So this variable is initialized

      * to true.

      */

     private boolean isUnmarshalInProgress = true;

     private boolean aborted = false;

     public final UnmarshallerImpl parent;

     /**

      * If the unmarshaller is doing associative unmarshalling,

      * this field is initialized to non-null.

      */

     private final AssociationMap assoc;

     /**

      * Indicates whether we are doing in-place unmarshalling

      * or not.

      *

      * <p>

      * This flag is unused when {@link #assoc}==null.

      * If it's non-null, then <tt>true</tt> indicates

      * that we are doing in-place associative unmarshalling.

      * If <tt>false</tt>, then we are doing associative unmarshalling

      * without object reuse.

      */

     private boolean isInplaceMode;

     /**

      * This object is consulted to get the element object for

      * the current element event.

      *

      * This is used when we are building an association map.

      */

     private InfosetScanner scanner;

     private Object currentElement;

     /**

      * @see XmlVisitor#startDocument(LocatorEx, NamespaceContext)

      */

     private NamespaceContext environmentNamespaceContext;

     /**

      * Used to discover additional classes when we hit unknown elements/types.

      */

     public @Nullable ClassResolver classResolver;

     /**

      * User-supplied {@link ClassLoader} for converting name to {@link Class}.

      * For backward compatibility, when null, use thread context classloader.

      */

     public @Nullable ClassLoader classLoader;

     /**

      * The variable introduced to avoid reporting n^10 similar errors.

      * After error is reported counter is decremented. When it became 0 - errors should not be reported any more.

      *

      * volatile is required to ensure that concurrent threads will see changed value

      */

     private static volatile int errorsCounter = 10;

     /**

      * State information for each element.

      */

     public final class State {

         /**

          * Loader that owns this element.

          */

         public Loader loader;

         /**

          * Once {@link #loader} is completed, this receiver

          * receives the result.

          */

         public Receiver receiver;

         public Intercepter intercepter;

         /**

          * Object being unmarshalled by this {@link #loader}.

          */

         public Object target;

         /**

          * Hack for making JAXBElement unmarshalling work.

          *

          * <p>

          * While the unmarshalling is in progress, the {@link #target} field stores the object being unmarshalled.

          * This makes it convenient to keep track of the unmarshalling activity in context of XML infoset, but

          * since there's only one {@link State} per element, this mechanism only works when there's one object

          * per element, which breaks down when we have {@link JAXBElement}, since the presence of JAXBElement

          * requires that we have two objects unmarshalled (a JAXBElement X and a value object Y bound to an XML type.)

          *

          * <p>

          * So to make room for storing both, this {@link #backup} field is used. When we create X instance

          * in the above example, we set that to {@code state.prev.target} and displace its old value to

          * {@code state.prev.backup} (where Y goes to {@code state.target}.) Upon the completion of the unmarshalling

          * of Y, we revert this.

          *

          * <p>

          * While this attributes X incorrectly to its parent element, this preserves the parent/child

          * relationship between unmarshalled objects and {@link State} parent/child relationship, and

          * it thereby makes {@link Receiver} mechanism simpler.

          *

          * <p>

          * Yes, I know this is a hack, and no, I'm not proud of it.

          *

          * @see ElementBeanInfoImpl.IntercepterLoader#startElement(State, TagName)

          * @see ElementBeanInfoImpl.IntercepterLoader#intercept(State, Object)

          */

         public Object backup;

         /**

          * Number of {@link UnmarshallingContext#nsBind}s declared thus far.

          * (The value of {@link UnmarshallingContext#nsLen} when this state is pushed.

          */

         private int numNsDecl;

         /**

          * If this element has an element default value.

          *

          * This should be set by either a parent {@link Loader} when

          * {@link Loader#childElement(State, TagName)} is called

          * or by a child {@link Loader} when

          * {@link Loader#startElement(State, TagName)} is called.

          */

         public String elementDefaultValue;

         /**

          * {@link State} for the parent element

          *

          * {@link State} objects form a doubly linked list.

          */

         public State prev;

         private State next;

         public boolean nil = false;

         /**

          * Gets the context.

          */

         public UnmarshallingContext getContext() {

             return UnmarshallingContext.this;

         }

         @SuppressWarnings("LeakingThisInConstructor")

         private State(State prev) {

             this.prev = prev;

             if (prev!=null) {

                 prev.next = this;

             }

         }

         private void push() {

             if (logger.isLoggable(Level.FINEST)) {

                 logger.log(Level.FINEST, "State.push");

             }

             if (next==null) {

                 assert current == this;

                 allocateMoreStates();

             }

             nil = false;

             State n = next;

             n.numNsDecl = nsLen;

             current = n;

         }

         private void pop() {

             if (logger.isLoggable(Level.FINEST)) {

                 logger.log(Level.FINEST, "State.pop");

             }

             assert prev!=null;

             loader = null;

             nil = false;

             receiver = null;

             intercepter = null;

             elementDefaultValue = null;

             target = null;

             current = prev;

         }

     }

     /**

      * Stub to the user-specified factory method.

      */

     private static class Factory {

         private final Object factorInstance;

         private final Method method;

         public Factory(Object factorInstance, Method method) {

             this.factorInstance = factorInstance;

             this.method = method;

         }

         public Object createInstance() throws SAXException {

             try {

                 return method.invoke(factorInstance);

             } catch (IllegalAccessException e) {

                 getInstance().handleError(e,false);

             } catch (InvocationTargetException e) {

                 getInstance().handleError(e,false);

             }

             return null; // can never be executed

         }

     }

     /**

      * Creates a new unmarshaller.

      *

      * @param assoc

      *      Must be both non-null when the unmarshaller does the

      *      in-place unmarshalling. Otherwise must be both null.

      */

     public UnmarshallingContext( UnmarshallerImpl _parent, AssociationMap assoc) {

         this.parent = _parent;

         this.assoc = assoc;

         this.root = this.current = new State(null);

         allocateMoreStates();

     }

     public void reset(InfosetScanner scanner,boolean isInplaceMode, JaxBeanInfo expectedType, IDResolver idResolver) {

         this.scanner = scanner;

         this.isInplaceMode = isInplaceMode;

         this.expectedType = expectedType;

         this.idResolver = idResolver;

     }

     public JAXBContextImpl getJAXBContext() {

         return parent.context;

     }

     public State getCurrentState() {

         return current;

     }

     /**

      * On top of {@link JAXBContextImpl#selectRootLoader(State, TagName)},

      * this method also consults {@link ClassResolver}.

      *

      * @throws SAXException

      *      if {@link ValidationEventHandler} reported a failure.

      */

     public Loader selectRootLoader(State state, TagName tag) throws SAXException {

         try {

             Loader l = getJAXBContext().selectRootLoader(state, tag);

             if(l!=null)     return l;

             if(classResolver!=null) {

                 Class<?> clazz = classResolver.resolveElementName(tag.uri, tag.local);

                 if(clazz!=null) {

                     JAXBContextImpl enhanced = getJAXBContext().createAugmented(clazz);

                     JaxBeanInfo<?> bi = enhanced.getBeanInfo(clazz);

                     return bi.getLoader(enhanced,true);

                 }

             }

         } catch (RuntimeException e) {

             throw e;

         } catch (Exception e) {

             handleError(e);

         }

         return null;

     }

     /**

      * Allocates a few more {@link State}s.

      *

      * Allocating multiple {@link State}s at once allows those objects

      * to be allocated near each other, which reduces the working set

      * of CPU. It improves the chance the relevant data is in the cache.

      */

     private void allocateMoreStates() {

         // this method should be used only when we run out of a state.

         assert current.next==null;

         State s = current;

         for (int i=0; i<8; i++) {

             s = new State(s);

         }

     }

     public void clearStates() {

         State last = current;

         while (last.next != null) last = last.next;

         while (last.prev != null) {

             last.loader = null;

             last.nil = false;

             last.receiver = null;

             last.intercepter = null;

             last.elementDefaultValue = null;

             last.target = null;

             last = last.prev;

             last.next.prev = null;

             last.next = null;

         }

         current = last;

     }

     /**

      * User-specified factory methods.

      */

     private final Map<Class,Factory> factories = new HashMap<Class, Factory>();

     public void setFactories(Object factoryInstances) {

         factories.clear();

         if(factoryInstances==null) {

             return;

         }

         if(factoryInstances instanceof Object[]) {

             for( Object factory : (Object[])factoryInstances ) {

                 // look for all the public methods inlcuding derived ones

                 addFactory(factory);

             }

         } else {

             addFactory(factoryInstances);

         }

     }

     private void addFactory(Object factory) {

         for( Method m : factory.getClass().getMethods() ) {

             // look for methods whose signature is T createXXX()

             if(!m.getName().startsWith("create"))

                 continue;

             if(m.getParameterTypes().length>0)

                 continue;

             Class type = m.getReturnType();

             factories.put(type,new Factory(factory,m));

         }

     }

     @Override

     public void startDocument(LocatorEx locator, NamespaceContext nsContext) throws SAXException {

         if(locator!=null)

             this.locator = locator;

         this.environmentNamespaceContext = nsContext;

         // reset the object

         result = null;

         current = root;

         patchersLen=0;

         aborted = false;

         isUnmarshalInProgress = true;

         nsLen=0;

         if(expectedType!=null)

             root.loader = EXPECTED_TYPE_ROOT_LOADER;

         else

             root.loader = DEFAULT_ROOT_LOADER;

         idResolver.startDocument(this);

     }

     @Override

     public void startElement(TagName tagName) throws SAXException {

         pushCoordinator();

         try {

             _startElement(tagName);

         } finally {

             popCoordinator();

         }

     }

     private void _startElement(TagName tagName) throws SAXException {

         // remember the current element if we are interested in it.

         // because the inner peer might not be found while we consume

         // the enter element token, we need to keep this information

         // longer than this callback. That's why we assign it to a field.

         if( assoc!=null )

             currentElement = scanner.getCurrentElement();

         Loader h = current.loader;

         current.push();

         // tell the parent about the new child

         h.childElement(current,tagName);

         assert current.loader!=null;   // the childElement should register this

         // and tell the new child that you are activated

         current.loader.startElement(current,tagName);

     }

     @Override

     public void text(CharSequence pcdata) throws SAXException {

         State cur = current;

         pushCoordinator();

         try {

             if(cur.elementDefaultValue!=null) {

                 if(pcdata.length()==0) {

                     // send the default value into the unmarshaller instead

                     pcdata = cur.elementDefaultValue;

                 }

             }

             cur.loader.text(cur,pcdata);

         } finally {

             popCoordinator();

         }

     }

     @Override

     public final void endElement(TagName tagName) throws SAXException {

         pushCoordinator();

         try {

             State child = current;

             // tell the child that your time is up

             child.loader.leaveElement(child,tagName);

             // child.pop will erase them so store them now

             Object target = child.target;

             Receiver recv = child.receiver;

             Intercepter intercepter = child.intercepter;

             child.pop();

             // then let the parent know

             if(intercepter!=null)

                 target = intercepter.intercept(current,target);

             if(recv!=null)

                 recv.receive(current,target);

         } finally {

             popCoordinator();

         }

     }

     @Override

     public void endDocument() throws SAXException {

         runPatchers();

         idResolver.endDocument();

         isUnmarshalInProgress = false;

         currentElement = null;

         locator = DUMMY_INSTANCE;

         environmentNamespaceContext = null;

         // at the successful completion, scope must be all closed

         assert root==current;

     }

     /**

      * You should be always calling this through {@link TextPredictor}.

      */

     @Deprecated

     @Override

     public boolean expectText() {

         return current.loader.expectText;

     }

     /**

      * You should be always getting {@link TextPredictor} from {@link XmlVisitor}.

      */

     @Deprecated

     @Override

     public TextPredictor getPredictor() {

         return this;

     }

     @Override

     public UnmarshallingContext getContext() {

         return this;

     }

     /**

      * Gets the result of the unmarshalling

      */

     public Object getResult() throws UnmarshalException {

         if(isUnmarshalInProgress)

             throw new IllegalStateException();

         if(!aborted)       return result;

         // there was an error.

         throw new UnmarshalException((String)null);

     }

     void clearResult() {

         if (isUnmarshalInProgress) {

             throw new IllegalStateException();

         }

         result = null;

     }

     /**

      * Creates a new instance of the specified class.

      * In the unmarshaller, we need to check the user-specified factory class.

      */

     public Object createInstance( Class<?> clazz ) throws SAXException {

         if(!factories.isEmpty()) {

             Factory factory = factories.get(clazz);

             if(factory!=null)

                 return factory.createInstance();

         }

         return ClassFactory.create(clazz);

     }

     /**

      * Creates a new instance of the specified class.

      * In the unmarshaller, we need to check the user-specified factory class.

      */

     public Object createInstance( JaxBeanInfo beanInfo ) throws SAXException {

         if(!factories.isEmpty()) {

             Factory factory = factories.get(beanInfo.jaxbType);

             if(factory!=null)

                 return factory.createInstance();

         }

         try {

             return beanInfo.createInstance(this);

         } catch (IllegalAccessException e) {

             Loader.reportError("Unable to create an instance of "+beanInfo.jaxbType.getName(),e,false);

         } catch (InvocationTargetException e) {

             Loader.reportError("Unable to create an instance of "+beanInfo.jaxbType.getName(),e,false);

         } catch (InstantiationException e) {

             Loader.reportError("Unable to create an instance of "+beanInfo.jaxbType.getName(),e,false);

         }

         return null;    // can never be here

     }

 //

 //

 // error handling

 //

 //

     /**

      * Reports an error to the user, and asks if s/he wants

      * to recover. If the canRecover flag is false, regardless

      * of the client instruction, an exception will be thrown.

      *

      * Only if the flag is true and the user wants to recover from an error,

      * the method returns normally.

      *

      * The thrown exception will be catched by the unmarshaller.

      */

     public void handleEvent(ValidationEvent event, boolean canRecover ) throws SAXException {

         ValidationEventHandler eventHandler = parent.getEventHandler();

         boolean recover = eventHandler.handleEvent(event);

         // if the handler says "abort", we will not return the object

         // from the unmarshaller.getResult()

         if(!recover)    aborted = true;

         if( !canRecover || !recover )

             throw new SAXParseException2( event.getMessage(), locator,

                 new UnmarshalException(

                     event.getMessage(),

                     event.getLinkedException() ) );

     }

     @Override

     public boolean handleEvent(ValidationEvent event) {

         try {

             // if the handler says "abort", we will not return the object.

             boolean recover = parent.getEventHandler().handleEvent(event);

             if(!recover)    aborted = true;

             return recover;

         } catch( RuntimeException re ) {

             // if client event handler causes a runtime exception, then we

             // have to return false.

             return false;

         }

     }

     /**

      * Reports an exception found during the unmarshalling to the user.

      * This method is a convenience method that calls into

      * {@link #handleEvent(ValidationEvent, boolean)}

      */

     public void handleError(Exception e) throws SAXException {

         handleError(e,true);

     }

     public void handleError(Exception e,boolean canRecover) throws SAXException {

         handleEvent(new ValidationEventImpl(ValidationEvent.ERROR,e.getMessage(),locator.getLocation(),e),canRecover);

     }

     public void handleError(String msg) {

         handleEvent(new ValidationEventImpl(ValidationEvent.ERROR,msg,locator.getLocation()));

     }

     @Override

     protected ValidationEventLocator getLocation() {

         return locator.getLocation();

     }

     /**

      * Gets the current source location information in SAX {@link Locator}.

      * <p>

      * Sometimes the unmarshaller works against a different kind of XML source,

      * making this information meaningless.

      */

     public LocatorEx getLocator() { return locator; }

     /**

      * Called when there's no corresponding ID value.

      */

     public void errorUnresolvedIDREF(Object bean, String idref, LocatorEx loc) throws SAXException {

         handleEvent( new ValidationEventImpl(

             ValidationEvent.ERROR,

             Messages.UNRESOLVED_IDREF.format(idref),

             loc.getLocation()), true );

     }

 //

 //

 // ID/IDREF related code

 //

 //

     /**

      * Submitted patchers in the order they've submitted.

      * Many XML vocabulary doesn't use ID/IDREF at all, so we

      * initialize it with null.

      */

     private Patcher[] patchers = null;

     private int patchersLen = 0;

     /**

      * Adds a job that will be executed at the last of the unmarshalling.

      * This method is used to support ID/IDREF feature, but it can be used

      * for other purposes as well.

      *

      * @param   job

      *      The run method of this object is called.

      */

     public void addPatcher( Patcher job ) {

         // re-allocate buffer if necessary

         if( patchers==null )

             patchers = new Patcher[32];

         if( patchers.length == patchersLen ) {

             Patcher[] buf = new Patcher[patchersLen*2];

             System.arraycopy(patchers,0,buf,0,patchersLen);

             patchers = buf;

         }

         patchers[patchersLen++] = job;

     }

     /** Executes all the patchers. */

     private void runPatchers() throws SAXException {

         if( patchers!=null ) {

             for( int i=0; i<patchersLen; i++ ) {

                 patchers[i].run();

                 patchers[i] = null; // free memory

             }

         }

     }

     /**

      * Adds the object which is currently being unmarshalled

      * to the ID table.

      *

      * @return

      *      Returns the value passed as the parameter.

      *      This is a hack, but this makes it easier for ID

      *      transducer to do its job.

      */

     // TODO: what shall we do if the ID is already declared?

     //

     // throwing an exception is one way. Overwriting the previous one

     // is another way. The latter allows us to process invalid documents,

     // while the former makes it impossible to handle them.

     //

     // I prefer to be flexible in terms of invalid document handling,

     // so chose not to throw an exception.

     //

     // I believe this is an implementation choice, not the spec issue.

     // -kk

     public String addToIdTable( String id ) throws SAXException {

         // Hmm...

         // in cases such as when ID is used as an attribute, or as @XmlValue

         // the target wilil be current.target.

         // but in some other cases, such as when ID is used as a child element

         // or a value of JAXBElement, it's current.prev.target.

         // I don't know if this detection logic is complete

         Object o = current.target;

         if(o==null)

             o = current.prev.target;

         idResolver.bind(id,o);

         return id;

     }

     /**

      * Looks up the ID table and gets associated object.

      *

      * <p>

      * The exception thrown from {@link Callable#call()} means the unmarshaller should abort

      * right away.

      *

      * @see IDResolver#resolve(String, Class)

      */

     public Callable getObjectFromId( String id, Class targetType ) throws SAXException {

         return idResolver.resolve(id,targetType);

     }

 //

 //

 // namespace binding maintainance

 //

 //

     private String[] nsBind = new String[16];

     private int nsLen=0;

     @Override

     public void startPrefixMapping( String prefix, String uri ) {

         if(nsBind.length==nsLen) {

             // expand the buffer

             String[] n = new String[nsLen*2];

             System.arraycopy(nsBind,0,n,0,nsLen);

             nsBind=n;

         }

         nsBind[nsLen++] = prefix;

         nsBind[nsLen++] = uri;

     }

     @Override

     public void endPrefixMapping( String prefix ) {

         nsLen-=2;

     }

     private String resolveNamespacePrefix( String prefix ) {

         if(prefix.equals("xml"))

             return XMLConstants.XML_NS_URI;

         for( int i=nsLen-2; i>=0; i-=2 ) {

             if(prefix.equals(nsBind[i]))

                 return nsBind[i+1];

         }

         if(environmentNamespaceContext!=null)

             // temporary workaround until Zephyr fixes 6337180

             return environmentNamespaceContext.getNamespaceURI(prefix.intern());

         // by default, the default ns is bound to "".

         // but allow environmentNamespaceContext to take precedence

         if(prefix.equals(""))

             return "";

         // unresolved. error.

         return null;

     }

     /**

      * Returns a list of prefixes newly declared on the current element.

      *

      * @return

      *      A possible zero-length array of prefixes. The default prefix

      *      is represented by the empty string.

      */

     public String[] getNewlyDeclaredPrefixes() {

         return getPrefixList( current.prev.numNsDecl );

     }

     /**

      * Returns a list of all in-scope prefixes.

      *

      * @return

      *      A possible zero-length array of prefixes. The default prefix

      *      is represented by the empty string.

      */

     public String[] getAllDeclaredPrefixes() {

         return getPrefixList(0);

     }

     private String[] getPrefixList( int startIndex ) {

         int size = (current.numNsDecl - startIndex)/2;

         String[] r = new String[size];

         for( int i=0; i<r.length; i++ )

             r[i] = nsBind[startIndex+i*2];

         return r;

     }

     //  NamespaceContext2 implementation

     //

     @Override

     public Iterator<String> getPrefixes(String uri) {

         // TODO: could be implemented much faster

         // wrap it into unmodifiable list so that the remove method

         // will throw UnsupportedOperationException.

         return Collections.unmodifiableList(

             getAllPrefixesInList(uri)).iterator();

     }

     private List<String> getAllPrefixesInList(String uri) {

         List<String> a = new ArrayList<String>();

         if( uri==null )

             throw new IllegalArgumentException();

         if( uri.equals(XMLConstants.XML_NS_URI) ) {

             a.add(XMLConstants.XML_NS_PREFIX);

             return a;

         }

         if( uri.equals(XMLConstants.XMLNS_ATTRIBUTE_NS_URI) ) {

             a.add(XMLConstants.XMLNS_ATTRIBUTE);

             return a;

         }

         for( int i=nsLen-2; i>=0; i-=2 )

             if(uri.equals(nsBind[i+1]))

                 if( getNamespaceURI(nsBind[i]).equals(nsBind[i+1]) )

                     // make sure that this prefix is still effective.

                     a.add(nsBind[i]);

         return a;

     }

     @Override

     public String getPrefix(String uri) {

         if( uri==null )

             throw new IllegalArgumentException();

         if( uri.equals(XMLConstants.XML_NS_URI) )

             return XMLConstants.XML_NS_PREFIX;

         if( uri.equals(XMLConstants.XMLNS_ATTRIBUTE_NS_URI) )

             return XMLConstants.XMLNS_ATTRIBUTE;

         for( int i=nsLen-2; i>=0; i-=2 )

             if(uri.equals(nsBind[i+1]))

                 if( getNamespaceURI(nsBind[i]).equals(nsBind[i+1]) )

                     // make sure that this prefix is still effective.

                     return nsBind[i];

         if(environmentNamespaceContext!=null)

             return environmentNamespaceContext.getPrefix(uri);

         return null;

     }

     @Override

     public String getNamespaceURI(String prefix) {

         if (prefix == null)

             throw new IllegalArgumentException();

         if (prefix.equals(XMLConstants.XMLNS_ATTRIBUTE))

             return XMLConstants.XMLNS_ATTRIBUTE_NS_URI;

         return resolveNamespacePrefix(prefix);

     }

 //

 //

 //

 // scope management

 //

 //

 //

     private Scope[] scopes = new Scope[16];

     /**

      * Points to the top of the scope stack (=size-1).

      */

     private int scopeTop=0;

     {

         for( int i=0; i<scopes.length; i++ )

             scopes[i] = new Scope(this);

     }

     /**

      * Starts a new packing scope.

      *

      * <p>

      * This method allocates a specified number of fresh {@link Scope} objects.

      * They can be accessed by the {@link #getScope} method until the corresponding

      * {@link #endScope} method is invoked.

      *

      * <p>

      * A new scope will mask the currently active scope. Only one frame of {@link Scope}s

      * can be accessed at any given time.

      *

      * @param frameSize

      *      The # of slots to be allocated.

      */

     public void startScope(int frameSize) {

         scopeTop += frameSize;

         // reallocation

         if(scopeTop>=scopes.length) {

             Scope[] s = new Scope[Math.max(scopeTop+1,scopes.length*2)];

             System.arraycopy(scopes,0,s,0,scopes.length);

             for( int i=scopes.length; i<s.length; i++ )

                 s[i] = new Scope(this);

             scopes = s;

         }

     }

     /**

      * Ends the current packing scope.

      *

      * <p>

      * If any packing in progress will be finalized by this method.

      *

      * @param frameSize

      *      The same size that gets passed to the {@link #startScope(int)}

      *      method.

      */

     public void endScope(int frameSize) throws SAXException {

         try {

             for( ; frameSize>0; frameSize--, scopeTop-- )

                 scopes[scopeTop].finish();

         } catch (AccessorException e) {

             handleError(e);

             // the error might have left scopes in inconsistent state,

             // so replace them by fresh ones

             for( ; frameSize>0; frameSize-- )

                 scopes[scopeTop--] = new Scope(this);

         }

     }

     /**

      * Gets the currently active {@link Scope}.

      *

      * @param offset

      *      a number between [0,frameSize)

      *

      * @return

      *      always a valid {@link Scope} object.

      */

     public Scope getScope(int offset) {

         return scopes[scopeTop-offset];

     }

 //

 //

 //

 //

 //

 //

 //

     private static final Loader DEFAULT_ROOT_LOADER = new DefaultRootLoader();

     private static final Loader EXPECTED_TYPE_ROOT_LOADER = new ExpectedTypeRootLoader();

     /**

      * Root loader that uses the tag name and possibly its @xsi:type

      * to decide how to start unmarshalling.

      */

     private static final class DefaultRootLoader extends Loader implements Receiver {

         /**

          * Receives the root element and determines how to start

          * unmarshalling.

          */

         @Override

         public void childElement(UnmarshallingContext.State state, TagName ea) throws SAXException {

             Loader loader = state.getContext().selectRootLoader(state,ea);

             if(loader!=null) {

                 state.loader = loader;

                 state.receiver = this;

                 return;

             }

             // the registry doesn't know about this element.

             // try its xsi:type

             JaxBeanInfo beanInfo = XsiTypeLoader.parseXsiType(state, ea, null);

             if(beanInfo==null) {

                 // we don't even know its xsi:type

                 reportUnexpectedChildElement(ea,false);

                 return;

             }

             state.loader = beanInfo.getLoader(null,false);

             state.prev.backup = new JAXBElement<Object>(ea.createQName(),Object.class,null);

             state.receiver = this;

         }

         @Override

         public Collection<QName> getExpectedChildElements() {

             return getInstance().getJAXBContext().getValidRootNames();

         }

         @Override

         public void receive(State state, Object o) {

              if(state.backup!=null) {

                 ((JAXBElement<Object>)state.backup).setValue(o);

                 o = state.backup;

             }

             if (state.nil) {

                 ((JAXBElement<Object>)o).setNil(true);

             }

             state.getContext().result = o;

         }

     }

     /**

      * Root loader that uses {@link UnmarshallingContext#expectedType}

      * to decide how to start unmarshalling.

      */

     private static final class ExpectedTypeRootLoader extends Loader implements Receiver {

         /**

          * Receives the root element and determines how to start

          * unmarshalling.

          */

         @Override

         public void childElement(UnmarshallingContext.State state, TagName ea) {

             UnmarshallingContext context = state.getContext();

             // unmarshals the specified type

             QName qn = new QName(ea.uri,ea.local);

             state.prev.target = new JAXBElement(qn,context.expectedType.jaxbType,null,null);

             state.receiver = this;

             // this is bit wasteful, as in theory we should have each expectedType keep

             // nillable version --- but that increases the combination from two to four,

             // which adds the resident memory footprint. Since XsiNilLoader is small,

             // I intentionally allocate a new instance freshly.

             state.loader = new XsiNilLoader(context.expectedType.getLoader(null,true));

         }

         @Override

         public void receive(State state, Object o) {

             JAXBElement e = (JAXBElement)state.target;

             e.setValue(o);

             state.getContext().recordOuterPeer(e);

             state.getContext().result = e;

         }

     }

 //

 // in-place unmarshalling related capabilities

 //

     /**

      * Notifies the context about the inner peer of the current element.

      *

      * <p>

      * If the unmarshalling is building the association, the context

      * will use this information. Otherwise it will be just ignored.

      */

     public void recordInnerPeer(Object innerPeer) {

         if(assoc!=null)

             assoc.addInner(currentElement,innerPeer);

     }

     /**

      * Gets the inner peer JAXB object associated with the current element.

      *

      * @return

      *      null if the current element doesn't have an inner peer,

      *      or if we are not doing the in-place unmarshalling.

      */

     public Object getInnerPeer() {

         if(assoc!=null && isInplaceMode)

             return assoc.getInnerPeer(currentElement);

         else

             return null;

     }

     /**

      * Notifies the context about the outer peer of the current element.

      *

      * <p>

      * If the unmarshalling is building the association, the context

      * will use this information. Otherwise it will be just ignored.

      */

     public void recordOuterPeer(Object outerPeer) {

         if(assoc!=null)

             assoc.addOuter(currentElement,outerPeer);

     }

     /**

      * Gets the outer peer JAXB object associated with the current element.

      *

      * @return

      *      null if the current element doesn't have an inner peer,

      *      or if we are not doing the in-place unmarshalling.

      */

     public Object getOuterPeer() {

         if(assoc!=null && isInplaceMode)

             return assoc.getOuterPeer(currentElement);

         else

             return null;

     }

     /**

      * Gets the xmime:contentType value for the current object.

      *

      * @see JAXBContextImpl#getXMIMEContentType(Object)

      */

     public String getXMIMEContentType() {

         /*

             this won't work when the class is like

             class Foo {

                 @XmlValue Image img;

             }

             because the target will return Foo, not the class enclosing Foo

             which will have xmime:contentType

         */

         Object t = current.target;

         if(t==null)     return null;

         return getJAXBContext().getXMIMEContentType(t);

     }

     /**

      * When called from within the realm of the unmarshaller, this method

      * returns the current {@link UnmarshallingContext} in charge.

      */

     public static UnmarshallingContext getInstance() {

         return (UnmarshallingContext) Coordinator._getInstance();

     }

     /**

      * Allows to access elements which are expected in current state.

      * Useful for getting elements for current parent.

      *

      * @return

      */

     public Collection<QName> getCurrentExpectedElements() {

         pushCoordinator();

         try {

             State s = getCurrentState();

             Loader l = s.loader;

             return (l != null) ? l.getExpectedChildElements() : null;

         } finally {

             popCoordinator();

         }

     }

     /**

      * Allows to access attributes which are expected in current state.

      * Useful for getting attributes for current parent.

      *

      * @return

      */

     public Collection<QName> getCurrentExpectedAttributes() {

         pushCoordinator();

         try {

             State s = getCurrentState();

             Loader l = s.loader;

             return (l != null) ? l.getExpectedAttributes() : null;

         } finally {

             popCoordinator();

         }

     }

     /**

      * Gets StructureLoader if used as loader.

      * Useful when determining if element is mixed or not.

      *

      */

     public StructureLoader getStructureLoader() {

         if(current.loader instanceof StructureLoader)

             return (StructureLoader)current.loader;

         return null;

     }

     /**

      * Based on current {@link Logger} {@link Level} and errorCounter value determines if error should be reported.

      *

      * If the method called and return true it is expected that error will be reported. And that's why

      * errorCounter is automatically decremented during the check.

      *

      * NOT THREAD SAFE!!! In case of heave concurrency access several additional errors could be reported. It's not expected to be the

      * problem. Otherwise add synchronization here.

      *

      * @return true in case if {@link Level#FINEST} is set OR we haven't exceed errors reporting limit.

      */

     public boolean shouldErrorBeReported() throws SAXException {

         if (logger.isLoggable(Level.FINEST))

             return true;

         if (errorsCounter >= 0) {

             --errorsCounter;

             if (errorsCounter == 0) // it's possible to miss this because of concurrency. If required add synchronization here

                 handleEvent(new ValidationEventImpl(ValidationEvent.WARNING, Messages.ERRORS_LIMIT_EXCEEDED.format(),

                         getLocator().getLocation(), null), true);

         }

         return errorsCounter >= 0;

     }

 }