/*
* 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 {@code c} isn't a JAXB-bound class and {@code fatal==false}.
*/
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 {@code c} isn't a JAXB-bound class and {@code fatal==false}.
*/
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);
}
}
}