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;

 import java.io.IOException;

 import java.lang.ref.WeakReference;

 import java.lang.reflect.Field;

 import java.lang.reflect.Method;

 import java.lang.reflect.Type;

 import java.util.Arrays;

 import java.util.Collection;

 import java.util.Collections;

 import java.util.Comparator;

 import java.util.HashMap;

 import java.util.HashSet;

 import java.util.LinkedHashMap;

 import java.util.List;

 import java.util.Map;

 import java.util.Map.Entry;

 import java.util.Set;

 import java.util.TreeSet;

 import javax.xml.bind.Binder;

 import javax.xml.bind.JAXBContext;

 import javax.xml.bind.JAXBElement;

 import javax.xml.bind.JAXBException;

 import javax.xml.bind.JAXBIntrospector;

 import javax.xml.bind.Marshaller;

 import javax.xml.bind.SchemaOutputResolver;

 import javax.xml.bind.Unmarshaller;

 import javax.xml.bind.Validator;

 import javax.xml.bind.annotation.XmlAttachmentRef;

 import javax.xml.bind.annotation.XmlList;

 import javax.xml.bind.annotation.XmlNs;

 import javax.xml.bind.annotation.XmlSchema;

 import javax.xml.bind.annotation.adapters.XmlJavaTypeAdapter;

 import javax.xml.namespace.QName;

 import javax.xml.parsers.DocumentBuilder;

 import javax.xml.parsers.DocumentBuilderFactory;

 import javax.xml.parsers.FactoryConfigurationError;

 import javax.xml.parsers.ParserConfigurationException;

 import javax.xml.transform.Result;

 import javax.xml.transform.Transformer;

 import javax.xml.transform.TransformerConfigurationException;

 import javax.xml.transform.TransformerFactory;

 import javax.xml.transform.sax.SAXTransformerFactory;

 import javax.xml.transform.sax.TransformerHandler;

 import com.sun.istack.internal.NotNull;

 import com.sun.istack.internal.Pool;

 import com.sun.xml.internal.bind.v2.WellKnownNamespace;

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

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

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

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

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

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

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

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

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

 import com.sun.xml.internal.bind.util.Which;

 import com.sun.xml.internal.bind.v2.model.annotation.RuntimeAnnotationReader;

 import com.sun.xml.internal.bind.v2.model.annotation.RuntimeInlineAnnotationReader;

 import com.sun.xml.internal.bind.v2.model.core.Adapter;

 import com.sun.xml.internal.bind.v2.model.core.NonElement;

 import com.sun.xml.internal.bind.v2.model.core.Ref;

 import com.sun.xml.internal.bind.v2.model.impl.RuntimeBuiltinLeafInfoImpl;

 import com.sun.xml.internal.bind.v2.model.impl.RuntimeModelBuilder;

 import com.sun.xml.internal.bind.v2.model.nav.Navigator;

 import com.sun.xml.internal.bind.v2.model.runtime.RuntimeArrayInfo;

 import com.sun.xml.internal.bind.v2.model.runtime.RuntimeBuiltinLeafInfo;

 import com.sun.xml.internal.bind.v2.model.runtime.RuntimeClassInfo;

 import com.sun.xml.internal.bind.v2.model.runtime.RuntimeElementInfo;

 import com.sun.xml.internal.bind.v2.model.runtime.RuntimeEnumLeafInfo;

 import com.sun.xml.internal.bind.v2.model.runtime.RuntimeLeafInfo;

 import com.sun.xml.internal.bind.v2.model.runtime.RuntimeTypeInfo;

 import com.sun.xml.internal.bind.v2.model.runtime.RuntimeTypeInfoSet;

 import com.sun.xml.internal.bind.v2.runtime.output.Encoded;

 import com.sun.xml.internal.bind.v2.runtime.property.AttributeProperty;

 import com.sun.xml.internal.bind.v2.runtime.property.Property;

 import com.sun.xml.internal.bind.v2.runtime.reflect.Accessor;

 import com.sun.xml.internal.bind.v2.runtime.unmarshaller.Loader;

 import com.sun.xml.internal.bind.v2.runtime.unmarshaller.TagName;

 import com.sun.xml.internal.bind.v2.runtime.unmarshaller.UnmarshallerImpl;

 import com.sun.xml.internal.bind.v2.runtime.unmarshaller.UnmarshallingContext;

 import com.sun.xml.internal.bind.v2.schemagen.XmlSchemaGenerator;

 import com.sun.xml.internal.bind.v2.util.EditDistance;

 import com.sun.xml.internal.bind.v2.util.QNameMap;

 import com.sun.xml.internal.bind.v2.util.XmlFactory;

 import com.sun.xml.internal.txw2.output.ResultFactory;

 import org.w3c.dom.Document;

 import org.w3c.dom.Element;

 import org.w3c.dom.Node;

 import org.xml.sax.SAXException;

 import org.xml.sax.SAXParseException;

 /**

  * This class provides the implementation of JAXBContext.

  *

  */

 public final class JAXBContextImpl extends JAXBRIContext {

     /**

      * All the bridge classes.

      */

     private final Map<TypeReference,Bridge> bridges = new LinkedHashMap<TypeReference,Bridge>();

     /**

      * Shared instance of {@link DocumentBuilder}.

      * Lock before use. Lazily created.

      */

     private static DocumentBuilder db;

     private final QNameMap<JaxBeanInfo> rootMap = new QNameMap<JaxBeanInfo>();

     private final HashMap<QName,JaxBeanInfo> typeMap = new HashMap<QName,JaxBeanInfo>();

     /**

      * Map from JAXB-bound {@link Class} to its {@link JaxBeanInfo}.

      */

     private final Map<Class,JaxBeanInfo> beanInfoMap = new LinkedHashMap<Class,JaxBeanInfo>();

     /**

      * All created {@link JaxBeanInfo}s.

      * Updated from each {@link JaxBeanInfo}s constructors to avoid infinite recursion

      * for a cyclic reference.

      *

      * <p>

      * This map is only used while the {@link JAXBContextImpl} is built and set to null

      * to avoid keeping references too long.

      */

     protected Map<RuntimeTypeInfo,JaxBeanInfo> beanInfos = new LinkedHashMap<RuntimeTypeInfo, JaxBeanInfo>();

     private final Map<Class/*scope*/,Map<QName,ElementBeanInfoImpl>> elements = new LinkedHashMap<Class, Map<QName, ElementBeanInfoImpl>>();

     /**

      * Pool of {@link Marshaller}s.

      */

     public final Pool<Marshaller> marshallerPool = new Pool.Impl<Marshaller>() {

         protected @NotNull Marshaller create() {

             return createMarshaller();

         }

     };

     public final Pool<Unmarshaller> unmarshallerPool = new Pool.Impl<Unmarshaller>() {

         protected @NotNull Unmarshaller create() {

             return createUnmarshaller();

         }

     };

     /**

      * Used to assign indices to known names in this grammar.

      * Reset to null once the build phase is completed.

      */

     public NameBuilder nameBuilder = new NameBuilder();

     /**

      * Keeps the list of known names.

      * This field is set once the build pahse is completed.

      */

     public final NameList nameList;

     /**

      * Input to the JAXBContext.newInstance, so that we can recreate

      * {@link RuntimeTypeInfoSet} whenever we need.

      */

     private final String defaultNsUri;

     private final Class[] classes;

     /**

      * true to reorder attributes lexicographically in preparation of the c14n support.

      */

     protected final boolean c14nSupport;

     /**

      * Flag that user has provided a custom AccessorFactory for JAXB to use

      */

     public final boolean xmlAccessorFactorySupport;

     /**

      * @see JAXBRIContext#TREAT_EVERYTHING_NILLABLE

      */

     public final boolean allNillable;

     /**

      * Store properties, so that they can be recovered in the run (is here because of JSON encoding of Jersey).

      */

     public final boolean retainPropertyInfo;

     /**

      * Suppress reflection accessor warnings.

      */

     public final boolean supressAccessorWarnings;

     /**

      * Improved xsi type handling.

      */

     public final boolean improvedXsiTypeHandling;

     /**

      * Disable security processing.

      */

     public final boolean disableSecurityProcessing;

     private WeakReference<RuntimeTypeInfoSet> typeInfoSetCache;

     private @NotNull RuntimeAnnotationReader annotationReader;

     private /*almost final*/ boolean hasSwaRef;

     private final @NotNull Map<Class,Class> subclassReplacements;

     /**

      * If true, we aim for faster {@link JAXBContext} instantiation performance,

      * instead of going after efficient sustained unmarshalling/marshalling performance.

      *

      * @since 2.0.4

      */

     public final boolean fastBoot;

     private Set<XmlNs> xmlNsSet = null;

     /**

      * Returns declared XmlNs annotations (from package-level annotation XmlSchema

      *

      * @return set of all present XmlNs annotations

      */

     public Set<XmlNs> getXmlNsSet() {

         return xmlNsSet;

     }

     private JAXBContextImpl(JAXBContextBuilder builder) throws JAXBException {

         this.defaultNsUri = builder.defaultNsUri;

         this.retainPropertyInfo = builder.retainPropertyInfo;

         this.annotationReader = builder.annotationReader;

         this.subclassReplacements = builder.subclassReplacements;

         this.c14nSupport = builder.c14nSupport;

         this.classes = builder.classes;

         this.xmlAccessorFactorySupport = builder.xmlAccessorFactorySupport;

         this.allNillable = builder.allNillable;

         this.supressAccessorWarnings = builder.supressAccessorWarnings;

         this.improvedXsiTypeHandling = builder.improvedXsiTypeHandling;

         this.disableSecurityProcessing = builder.disableSecurityProcessing;

         Collection<TypeReference> typeRefs = builder.typeRefs;

         boolean fastB;

         try {

             fastB = Boolean.getBoolean(JAXBContextImpl.class.getName()+".fastBoot");

         } catch (SecurityException e) {

             fastB = false;

         }

         this.fastBoot = fastB;

         RuntimeTypeInfoSet typeSet = getTypeInfoSet();

         // at least prepare the empty table so that we don't have to check for null later

         elements.put(null,new LinkedHashMap<QName, ElementBeanInfoImpl>());

         // recognize leaf bean infos

         for( RuntimeBuiltinLeafInfo leaf : RuntimeBuiltinLeafInfoImpl.builtinBeanInfos ) {

             LeafBeanInfoImpl<?> bi = new LeafBeanInfoImpl(this,leaf);

             beanInfoMap.put(leaf.getClazz(),bi);

             for( QName t : bi.getTypeNames() )

                 typeMap.put(t,bi);

         }

         for (RuntimeEnumLeafInfo e : typeSet.enums().values()) {

             JaxBeanInfo<?> bi = getOrCreate(e);

             for (QName qn : bi.getTypeNames())

                 typeMap.put( qn, bi );

             if(e.isElement())

                 rootMap.put( e.getElementName(), bi );

         }

         for (RuntimeArrayInfo a : typeSet.arrays().values()) {

             JaxBeanInfo<?> ai = getOrCreate(a);

             for (QName qn : ai.getTypeNames())

                 typeMap.put( qn, ai );

         }

         for( Entry<Class, ? extends RuntimeClassInfo> e : typeSet.beans().entrySet() ) {

             ClassBeanInfoImpl<?> bi = getOrCreate(e.getValue());

             XmlSchema xs = this.annotationReader.getPackageAnnotation(XmlSchema.class, e.getKey(), null);

             if(xs != null) {

                 if(xs.xmlns() != null && xs.xmlns().length > 0) {

                     if(xmlNsSet == null)

                         xmlNsSet = new HashSet<XmlNs>();

                     xmlNsSet.addAll(Arrays.asList(xs.xmlns()));

                 }

             }

             if(bi.isElement())

                 rootMap.put( e.getValue().getElementName(), bi );

             for (QName qn : bi.getTypeNames())

                 typeMap.put( qn, bi );

         }

         // fill in element mappings

         for( RuntimeElementInfo n : typeSet.getAllElements() ) {

             ElementBeanInfoImpl bi = getOrCreate(n);

             if(n.getScope()==null)

                 rootMap.put(n.getElementName(),bi);

             RuntimeClassInfo scope = n.getScope();

             Class scopeClazz = scope==null?null:scope.getClazz();

             Map<QName,ElementBeanInfoImpl> m = elements.get(scopeClazz);

             if(m==null) {

                 m = new LinkedHashMap<QName, ElementBeanInfoImpl>();

                 elements.put(scopeClazz,m);

             }

             m.put(n.getElementName(),bi);

         }

         // this one is so that we can handle plain JAXBElements.

         beanInfoMap.put(JAXBElement.class,new ElementBeanInfoImpl(this));

         // another special BeanInfoImpl just for marshalling

         beanInfoMap.put(CompositeStructure.class,new CompositeStructureBeanInfo(this));

         getOrCreate(typeSet.getAnyTypeInfo());

         // then link them all!

         for (JaxBeanInfo bi : beanInfos.values())

             bi.link(this);

         // register primitives for boxed types just to make GrammarInfo fool-proof

         for( Map.Entry<Class,Class> e : RuntimeUtil.primitiveToBox.entrySet() )

             beanInfoMap.put( e.getKey(), beanInfoMap.get(e.getValue()) );

         // build bridges

         Navigator<Type, Class, Field, Method> nav = typeSet.getNavigator();

         for (TypeReference tr : typeRefs) {

             XmlJavaTypeAdapter xjta = tr.get(XmlJavaTypeAdapter.class);

             Adapter<Type,Class> a=null;

             XmlList xl = tr.get(XmlList.class);

             // eventually compute the in-memory type

             Class erasedType = (Class) nav.erasure(tr.type);

             if(xjta!=null) {

                 a = new Adapter<Type,Class>(xjta.value(),nav);

             }

             if(tr.get(XmlAttachmentRef.class)!=null) {

                 a = new Adapter<Type,Class>(SwaRefAdapter.class,nav);

                 hasSwaRef = true;

             }

             if(a!=null) {

                 erasedType = (Class) nav.erasure(a.defaultType);

             }

             Name name = nameBuilder.createElementName(tr.tagName);

             InternalBridge bridge;

             if(xl==null)

                 bridge = new BridgeImpl(this, name,getBeanInfo(erasedType,true),tr);

             else

                 bridge = new BridgeImpl(this, name,new ValueListBeanInfoImpl(this,erasedType),tr);

             if(a!=null)

                 bridge = new BridgeAdapter(bridge,a.adapterType);

             bridges.put(tr,bridge);

         }

         this.nameList = nameBuilder.conclude();

         for (JaxBeanInfo bi : beanInfos.values())

             bi.wrapUp();

         // no use for them now

         nameBuilder = null;

         beanInfos = null;

     }

     /**

      * True if this JAXBContext has {@link XmlAttachmentRef}.

      */

     public boolean hasSwaRef() {

         return hasSwaRef;

     }

     public RuntimeTypeInfoSet getRuntimeTypeInfoSet() {

         try {

             return getTypeInfoSet();

         } catch (IllegalAnnotationsException e) {

             // impossible, once the model is constructred

             throw new AssertionError(e);

         }

     }

     /**

      * Creates a {@link RuntimeTypeInfoSet}.

      */

     public RuntimeTypeInfoSet getTypeInfoSet() throws IllegalAnnotationsException {

         // check cache

         if(typeInfoSetCache!=null) {

             RuntimeTypeInfoSet r = typeInfoSetCache.get();

             if(r!=null)

                 return r;

         }

         final RuntimeModelBuilder builder = new RuntimeModelBuilder(this,annotationReader,subclassReplacements,defaultNsUri);

         IllegalAnnotationsException.Builder errorHandler = new IllegalAnnotationsException.Builder();

         builder.setErrorHandler(errorHandler);

         for( Class c : classes ) {

             if(c==CompositeStructure.class)

                 // CompositeStructure doesn't have TypeInfo, so skip it.

                 // We'll add JaxBeanInfo for this later automatically

                 continue;

             builder.getTypeInfo(new Ref<Type,Class>(c));

         }

         this.hasSwaRef |= builder.hasSwaRef;

         RuntimeTypeInfoSet r = builder.link();

         errorHandler.check();

         assert r!=null : "if no error was reported, the link must be a success";

         typeInfoSetCache = new WeakReference<RuntimeTypeInfoSet>(r);

         return r;

     }

     public ElementBeanInfoImpl getElement(Class scope, QName name) {

         Map<QName,ElementBeanInfoImpl> m = elements.get(scope);

         if(m!=null) {

             ElementBeanInfoImpl bi = m.get(name);

             if(bi!=null)

                 return bi;

         }

         m = elements.get(null);

         return m.get(name);

     }

     private ElementBeanInfoImpl getOrCreate( RuntimeElementInfo rei ) {

         JaxBeanInfo bi = beanInfos.get(rei);

         if(bi!=null)    return (ElementBeanInfoImpl)bi;

         // all elements share the same type, so we can't register them to beanInfoMap

         return new ElementBeanInfoImpl(this, rei);

     }

     protected JaxBeanInfo getOrCreate( RuntimeEnumLeafInfo eli ) {

         JaxBeanInfo bi = beanInfos.get(eli);

         if(bi!=null)    return bi;

         bi = new LeafBeanInfoImpl(this,eli);

         beanInfoMap.put(bi.jaxbType,bi);

         return bi;

     }

     protected ClassBeanInfoImpl getOrCreate( RuntimeClassInfo ci ) {

         ClassBeanInfoImpl bi = (ClassBeanInfoImpl)beanInfos.get(ci);

         if(bi!=null)    return bi;

         bi = new ClassBeanInfoImpl(this,ci);

         beanInfoMap.put(bi.jaxbType,bi);

         return bi;

     }

     protected JaxBeanInfo getOrCreate( RuntimeArrayInfo ai ) {

         JaxBeanInfo abi = beanInfos.get(ai);

         if(abi!=null)   return abi;

         abi = new ArrayBeanInfoImpl(this,ai);

         beanInfoMap.put(ai.getType(),abi);

         return abi;

     }

     public JaxBeanInfo getOrCreate(RuntimeTypeInfo e) {

         if(e instanceof RuntimeElementInfo)

             return getOrCreate((RuntimeElementInfo)e);

         if(e instanceof RuntimeClassInfo)

             return getOrCreate((RuntimeClassInfo)e);

         if(e instanceof RuntimeLeafInfo) {

             JaxBeanInfo bi = beanInfos.get(e); // must have been created

             assert bi!=null;

             return bi;

         }

         if(e instanceof RuntimeArrayInfo)

             return getOrCreate((RuntimeArrayInfo)e);

         if(e.getType()==Object.class) {

             // anyType

             JaxBeanInfo bi = beanInfoMap.get(Object.class);

             if(bi==null) {

                 bi = new AnyTypeBeanInfo(this,e);

                 beanInfoMap.put(Object.class,bi);

             }

             return bi;

         }

         throw new IllegalArgumentException();

     }

     /**

      * Gets the {@link JaxBeanInfo} object that can handle

      * the given JAXB-bound object.

      *

      * <p>

      * This method traverses the base classes of the given object.

      *

      * @return null

      *      if <tt>c</tt> isn't a JAXB-bound class and <tt>fatal==false</tt>.

      */

     public final JaxBeanInfo getBeanInfo(Object o) {

         // don't allow xs:anyType beanInfo to handle all the unbound objects

         for( Class c=o.getClass(); c!=Object.class; c=c.getSuperclass()) {

             JaxBeanInfo bi = beanInfoMap.get(c);

             if(bi!=null)    return bi;

         }

         if(o instanceof Element)

             return beanInfoMap.get(Object.class);   // return the BeanInfo for xs:anyType

         for( Class c : o.getClass().getInterfaces()) {

             JaxBeanInfo bi = beanInfoMap.get(c);

             if(bi!=null)    return bi;

         }

         return null;

     }

     /**

      * Gets the {@link JaxBeanInfo} object that can handle

      * the given JAXB-bound object.

      *

      * @param fatal

      *      if true, the failure to look up will throw an exception.

      *      Otherwise it will just return null.

      */

     public final JaxBeanInfo getBeanInfo(Object o,boolean fatal) throws JAXBException {

         JaxBeanInfo bi = getBeanInfo(o);

         if(bi!=null)    return bi;

         if(fatal) {

             if(o instanceof Document)

                 throw new JAXBException(Messages.ELEMENT_NEEDED_BUT_FOUND_DOCUMENT.format(o.getClass()));

             throw new JAXBException(Messages.UNKNOWN_CLASS.format(o.getClass()));

         }

         return null;

     }

     /**

      * Gets the {@link JaxBeanInfo} object that can handle

      * the given JAXB-bound class.

      *

      * <p>

      * This method doesn't look for base classes.

      *

      * @return null

      *      if <tt>c</tt> isn't a JAXB-bound class and <tt>fatal==false</tt>.

      */

     public final <T> JaxBeanInfo<T> getBeanInfo(Class<T> clazz) {

         return (JaxBeanInfo<T>)beanInfoMap.get(clazz);

     }

     /**

      * Gets the {@link JaxBeanInfo} object that can handle

      * the given JAXB-bound class.

      *

      * @param fatal

      *      if true, the failure to look up will throw an exception.

      *      Otherwise it will just return null.

      */

     public final <T> JaxBeanInfo<T> getBeanInfo(Class<T> clazz,boolean fatal) throws JAXBException {

         JaxBeanInfo<T> bi = getBeanInfo(clazz);

         if(bi!=null)    return bi;

         if(fatal)

             throw new JAXBException(clazz.getName()+" is not known to this context");

         return null;

     }

     /**

      * Based on the tag name, determine what object to unmarshal,

      * and then set a new object and its loader to the current unmarshaller state.

      *

      * @return

      *      null if the given name pair is not recognized.

      */

     public final Loader selectRootLoader( UnmarshallingContext.State state, TagName tag ) {

         JaxBeanInfo beanInfo = rootMap.get(tag.uri,tag.local);

         if(beanInfo==null)

             return null;

         return beanInfo.getLoader(this,true);

     }

     /**

      * Gets the {@link JaxBeanInfo} for the given named XML Schema type.

      *

      * @return

      *      null if the type name is not recognized. For schema

      *      languages other than XML Schema, this method always

      *      returns null.

      */

     public JaxBeanInfo getGlobalType(QName name) {

         return typeMap.get(name);

     }

     /**

      * Finds a type name that this context recognizes which is

      * "closest" to the given type name.

      *

      * <p>

      * This method is used for error recovery.

      */

     public String getNearestTypeName(QName name) {

         String[] all = new String[typeMap.size()];

         int i=0;

         for (QName qn : typeMap.keySet()) {

             if(qn.getLocalPart().equals(name.getLocalPart()))

                 return qn.toString();  // probably a match, as people often gets confused about namespace.

             all[i++] = qn.toString();

         }

         String nearest = EditDistance.findNearest(name.toString(), all);

         if(EditDistance.editDistance(nearest,name.toString())>10)

             return null;    // too far apart.

         return nearest;

     }

     /**

      * Returns the set of valid root tag names.

      * For diagnostic use.

      */

     public Set<QName> getValidRootNames() {

         Set<QName> r = new TreeSet<QName>(QNAME_COMPARATOR);

         for (QNameMap.Entry e : rootMap.entrySet()) {

             r.add(e.createQName());

         }

         return r;

     }

     /**

      * Cache of UTF-8 encoded local names to improve the performance for the marshalling.

      */

     private Encoded[] utf8nameTable;

     public synchronized Encoded[] getUTF8NameTable() {

         if(utf8nameTable==null) {

             Encoded[] x = new Encoded[nameList.localNames.length];

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

                 Encoded e = new Encoded(nameList.localNames[i]);

                 e.compact();

                 x[i] = e;

             }

             utf8nameTable = x;

         }

         return utf8nameTable;

     }

     public int getNumberOfLocalNames() {

         return nameList.localNames.length;

     }

     public int getNumberOfElementNames() {

         return nameList.numberOfElementNames;

     }

     public int getNumberOfAttributeNames() {

         return nameList.numberOfAttributeNames;

     }

     /**

      * Creates a new identity transformer.

      */

     static Transformer createTransformer(boolean disableSecureProcessing) {

         try {

             SAXTransformerFactory tf = (SAXTransformerFactory)XmlFactory.createTransformerFactory(disableSecureProcessing);

             return tf.newTransformer();

         } catch (TransformerConfigurationException e) {

             throw new Error(e); // impossible

         }

     }

     /**

      * Creates a new identity transformer.

      */

     public static TransformerHandler createTransformerHandler(boolean disableSecureProcessing) {

         try {

             SAXTransformerFactory tf = (SAXTransformerFactory)XmlFactory.createTransformerFactory(disableSecureProcessing);

             return tf.newTransformerHandler();

         } catch (TransformerConfigurationException e) {

             throw new Error(e); // impossible

         }

     }

     /**

      * Creates a new DOM document.

      */

     static Document createDom(boolean disableSecurityProcessing) {

         synchronized(JAXBContextImpl.class) {

             if(db==null) {

                 try {

                     DocumentBuilderFactory dbf = XmlFactory.createDocumentBuilderFactory(disableSecurityProcessing);

                     db = dbf.newDocumentBuilder();

                 } catch (ParserConfigurationException e) {

                     // impossible

                     throw new FactoryConfigurationError(e);

                 }

             }

             return db.newDocument();

         }

     }

     public MarshallerImpl createMarshaller() {

         return new MarshallerImpl(this,null);

     }

     public UnmarshallerImpl createUnmarshaller() {

         return new UnmarshallerImpl(this,null);

     }

     public Validator createValidator() {

         throw new UnsupportedOperationException(Messages.NOT_IMPLEMENTED_IN_2_0.format());

     }

     @Override

     public JAXBIntrospector createJAXBIntrospector() {

         return new JAXBIntrospector() {

             public boolean isElement(Object object) {

                 return getElementName(object)!=null;

             }

             public QName getElementName(Object jaxbElement) {

                 try {

                     return JAXBContextImpl.this.getElementName(jaxbElement);

                 } catch (JAXBException e) {

                     return null;

                 }

             }

         };

     }

     private NonElement<Type,Class> getXmlType(RuntimeTypeInfoSet tis, TypeReference tr) {

         if(tr==null)

             throw new IllegalArgumentException();

         XmlJavaTypeAdapter xjta = tr.get(XmlJavaTypeAdapter.class);

         XmlList xl = tr.get(XmlList.class);

         Ref<Type,Class> ref = new Ref<Type,Class>(annotationReader, tis.getNavigator(), tr.type, xjta, xl );

         return tis.getTypeInfo(ref);

     }

     @Override

     public void generateEpisode(Result output) {

         if(output==null)

             throw new IllegalArgumentException();

         createSchemaGenerator().writeEpisodeFile(ResultFactory.createSerializer(output));

     }

     @Override

     @SuppressWarnings("ThrowableInitCause")

     public void generateSchema(SchemaOutputResolver outputResolver) throws IOException {

         if(outputResolver==null)

             throw new IOException(Messages.NULL_OUTPUT_RESOLVER.format());

         final SAXParseException[] e = new SAXParseException[1];

         final SAXParseException[] w = new SAXParseException[1];

         createSchemaGenerator().write(outputResolver, new ErrorListener() {

             public void error(SAXParseException exception) {

                 e[0] = exception;

             }

             public void fatalError(SAXParseException exception) {

                 e[0] = exception;

             }

             public void warning(SAXParseException exception) {

                 w[0] = exception;

             }

             public void info(SAXParseException exception) {}

         });

         if (e[0]!=null) {

             IOException x = new IOException(Messages.FAILED_TO_GENERATE_SCHEMA.format());

             x.initCause(e[0]);

             throw x;

         }

         if (w[0]!=null) {

             IOException x = new IOException(Messages.ERROR_PROCESSING_SCHEMA.format());

             x.initCause(w[0]);

             throw x;

         }

     }

     private XmlSchemaGenerator<Type,Class,Field,Method> createSchemaGenerator() {

         RuntimeTypeInfoSet tis;

         try {

             tis = getTypeInfoSet();

         } catch (IllegalAnnotationsException e) {

             // this shouldn't happen because we've already

             throw new AssertionError(e);

         }

         XmlSchemaGenerator<Type,Class,Field,Method> xsdgen =

                 new XmlSchemaGenerator<Type,Class,Field,Method>(tis.getNavigator(),tis);

         // JAX-RPC uses Bridge objects that collide with

         // @XmlRootElement.

         // we will avoid collision here

         Set<QName> rootTagNames = new HashSet<QName>();

         for (RuntimeElementInfo ei : tis.getAllElements()) {

             rootTagNames.add(ei.getElementName());

         }

         for (RuntimeClassInfo ci : tis.beans().values()) {

             if(ci.isElement())

                 rootTagNames.add(ci.asElement().getElementName());

         }

         for (TypeReference tr : bridges.keySet()) {

             if(rootTagNames.contains(tr.tagName))

                 continue;

             if(tr.type==void.class || tr.type==Void.class) {

                 xsdgen.add(tr.tagName,false,null);

             } else

             if(tr.type==CompositeStructure.class) {

                 // this is a special class we introduced for JAX-WS that we *don't* want in the schema

             } else {

                 NonElement<Type,Class> typeInfo = getXmlType(tis,tr);

                 xsdgen.add(tr.tagName, !tis.getNavigator().isPrimitive(tr.type),typeInfo);

             }

         }

         return xsdgen;

     }

     public QName getTypeName(TypeReference tr) {

         try {

             NonElement<Type,Class> xt = getXmlType(getTypeInfoSet(),tr);

             if(xt==null)    throw new IllegalArgumentException();

             return xt.getTypeName();

         } catch (IllegalAnnotationsException e) {

             // impossible given that JAXBRIContext has been successfully built in the first place

             throw new AssertionError(e);

         }

     }

     @Override

     public <T> Binder<T> createBinder(Class<T> domType) {

         if(domType==Node.class)

             return (Binder<T>)createBinder();

         else

             return super.createBinder(domType);

     }

     @Override

     public Binder<Node> createBinder() {

         return new BinderImpl<Node>(this,new DOMScanner());

     }

     public QName getElementName(Object o) throws JAXBException {

         JaxBeanInfo bi = getBeanInfo(o,true);

         if(!bi.isElement())

             return null;

         return new QName(bi.getElementNamespaceURI(o),bi.getElementLocalName(o));

     }

     public QName getElementName(Class o) throws JAXBException {

         JaxBeanInfo bi = getBeanInfo(o,true);

         if(!bi.isElement())

             return null;

         return new QName(bi.getElementNamespaceURI(o),bi.getElementLocalName(o));

     }

     public Bridge createBridge(TypeReference ref) {

         return bridges.get(ref);

     }

     public @NotNull BridgeContext createBridgeContext() {

         return new BridgeContextImpl(this);

     }

     public RawAccessor getElementPropertyAccessor(Class wrapperBean, String nsUri, String localName) throws JAXBException {

         JaxBeanInfo bi = getBeanInfo(wrapperBean,true);

         if(!(bi instanceof ClassBeanInfoImpl))

             throw new JAXBException(wrapperBean+" is not a bean");

         for( ClassBeanInfoImpl cb = (ClassBeanInfoImpl) bi; cb!=null; cb=cb.superClazz) {

             for (Property p : cb.properties) {

                 final Accessor acc = p.getElementPropertyAccessor(nsUri,localName);

                 if(acc!=null)

                     return new RawAccessor() {

                         // Accessor.set/get are designed for unmarshaller/marshaller, and hence

                         // they go through an adapter behind the scene.

                         // this isn't desirable for JAX-WS, which essentially uses this method

                         // just as a reflection library. So use the "unadapted" version to

                         // achieve the desired semantics

                         public Object get(Object bean) throws AccessorException {

                             return acc.getUnadapted(bean);

                         }

                         public void set(Object bean, Object value) throws AccessorException {

                             acc.setUnadapted(bean,value);

                         }

                     };

             }

         }

         throw new JAXBException(new QName(nsUri,localName)+" is not a valid property on "+wrapperBean);

     }

     public List<String> getKnownNamespaceURIs() {

         return Arrays.asList(nameList.namespaceURIs);

     }

     public String getBuildId() {

         Package pkg = getClass().getPackage();

         if(pkg==null)   return null;

         return pkg.getImplementationVersion();

     }

     @Override

     public String toString() {

         StringBuilder buf = new StringBuilder(Which.which(getClass()) + " Build-Id: " + getBuildId());

         buf.append("\nClasses known to this context:\n");

         Set<String> names = new TreeSet<String>();  // sort them so that it's easy to read

         for (Class key : beanInfoMap.keySet())

             names.add(key.getName());

         for(String name: names)

             buf.append("  ").append(name).append('\n');

         return buf.toString();

     }

     /**

      * Gets the value of the xmime:contentType attribute on the given object, or null

      * if for some reason it couldn't be found, including any error.

      */

     public String getXMIMEContentType( Object o ) {

         JaxBeanInfo bi = getBeanInfo(o);

         if(!(bi instanceof ClassBeanInfoImpl))

             return null;

         ClassBeanInfoImpl cb = (ClassBeanInfoImpl) bi;

         for (Property p : cb.properties) {

             if (p instanceof AttributeProperty) {

                 AttributeProperty ap = (AttributeProperty) p;

                 if(ap.attName.equals(WellKnownNamespace.XML_MIME_URI,"contentType"))

                     try {

                         return (String)ap.xacc.print(o);

                     } catch (AccessorException e) {

                         return null;

                     } catch (SAXException e) {

                         return null;

                     } catch (ClassCastException e) {

                         return null;

                     }

             }

         }

         return null;

     }

     /**

      * Creates a {@link JAXBContextImpl} that includes the specified additional classes.

      */

     public JAXBContextImpl createAugmented(Class<?> clazz) throws JAXBException {

         Class[] newList = new Class[classes.length+1];

         System.arraycopy(classes,0,newList,0,classes.length);

         newList[classes.length] = clazz;

         JAXBContextBuilder builder = new JAXBContextBuilder(this);

         builder.setClasses(newList);

         return builder.build();

     }

     private static final Comparator<QName> QNAME_COMPARATOR = new Comparator<QName>() {

         public int compare(QName lhs, QName rhs) {

             int r = lhs.getLocalPart().compareTo(rhs.getLocalPart());

             if(r!=0)    return r;

             return lhs.getNamespaceURI().compareTo(rhs.getNamespaceURI());

         }

     };

     public static class JAXBContextBuilder {

         private boolean retainPropertyInfo = false;

         private boolean supressAccessorWarnings = false;

         private String defaultNsUri = "";

         private @NotNull RuntimeAnnotationReader annotationReader = new RuntimeInlineAnnotationReader();

         private @NotNull Map<Class,Class> subclassReplacements = Collections.emptyMap();

         private boolean c14nSupport = false;

         private Class[] classes;

         private Collection<TypeReference> typeRefs;

         private boolean xmlAccessorFactorySupport = false;

         private boolean allNillable;

         private boolean improvedXsiTypeHandling = true;

         private boolean disableSecurityProcessing = true;

         public JAXBContextBuilder() {};

         public JAXBContextBuilder(JAXBContextImpl baseImpl) {

             this.supressAccessorWarnings = baseImpl.supressAccessorWarnings;

             this.retainPropertyInfo = baseImpl.retainPropertyInfo;

             this.defaultNsUri = baseImpl.defaultNsUri;

             this.annotationReader = baseImpl.annotationReader;

             this.subclassReplacements = baseImpl.subclassReplacements;

             this.c14nSupport = baseImpl.c14nSupport;

             this.classes = baseImpl.classes;

             this.typeRefs = baseImpl.bridges.keySet();

             this.xmlAccessorFactorySupport = baseImpl.xmlAccessorFactorySupport;

             this.allNillable = baseImpl.allNillable;

             this.disableSecurityProcessing = baseImpl.disableSecurityProcessing;

         }

         public JAXBContextBuilder setRetainPropertyInfo(boolean val) {

             this.retainPropertyInfo = val;

             return this;

         }

         public JAXBContextBuilder setSupressAccessorWarnings(boolean val) {

             this.supressAccessorWarnings = val;

             return this;

         }

         public JAXBContextBuilder setC14NSupport(boolean val) {

             this.c14nSupport = val;

             return this;

         }

         public JAXBContextBuilder setXmlAccessorFactorySupport(boolean val) {

             this.xmlAccessorFactorySupport = val;

             return this;

         }

         public JAXBContextBuilder setDefaultNsUri(String val) {

             this.defaultNsUri = val;

             return this;

         }

         public JAXBContextBuilder setAllNillable(boolean val) {

             this.allNillable = val;

             return this;

         }

         public JAXBContextBuilder setClasses(Class[] val) {

             this.classes = val;

             return this;

         }

         public JAXBContextBuilder setAnnotationReader(RuntimeAnnotationReader val) {

             this.annotationReader = val;

             return this;

         }

         public JAXBContextBuilder setSubclassReplacements(Map<Class,Class> val) {

             this.subclassReplacements = val;

             return this;

         }

         public JAXBContextBuilder setTypeRefs(Collection<TypeReference> val) {

             this.typeRefs = val;

             return this;

         }

         public JAXBContextBuilder setImprovedXsiTypeHandling(boolean val) {

             this.improvedXsiTypeHandling = val;

             return this;

         }

         public JAXBContextBuilder setDisableSecurityProcessing(boolean val) {

             this.disableSecurityProcessing = val;

             return this;

         }

         public JAXBContextImpl build() throws JAXBException {

             // fool-proof

             if (this.defaultNsUri == null) {

                 this.defaultNsUri = "";

             }

             if (this.subclassReplacements == null) {

                 this.subclassReplacements = Collections.emptyMap();

             }

             if (this.annotationReader == null) {

                 this.annotationReader = new RuntimeInlineAnnotationReader();

             }

             if (this.typeRefs == null) {

                 this.typeRefs = Collections.<TypeReference>emptyList();

             }

             return new JAXBContextImpl(this);

         }

     }

 }