spinjar.com.sun.xml.bind.v2.runtime.reflect.TransducedAccessor Maven / Gradle / Ivy
/*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
*
* Copyright (c) 1997-2011 Oracle and/or its affiliates. All rights reserved.
*
* The contents of this file are subject to the terms of either the GNU
* General Public License Version 2 only ("GPL") or the Common Development
* and Distribution License("CDDL") (collectively, the "License"). You
* may not use this file except in compliance with the License. You can
* obtain a copy of the License at
* https://glassfish.dev.java.net/public/CDDL+GPL_1_1.html
* or packager/legal/LICENSE.txt. See the License for the specific
* language governing permissions and limitations under the License.
*
* When distributing the software, include this License Header Notice in each
* file and include the License file at packager/legal/LICENSE.txt.
*
* GPL Classpath Exception:
* Oracle designates this particular file as subject to the "Classpath"
* exception as provided by Oracle in the GPL Version 2 section of the License
* file that accompanied this code.
*
* Modifications:
* If applicable, add the following below the License Header, with the fields
* enclosed by brackets [] replaced by your own identifying information:
* "Portions Copyright [year] [name of copyright owner]"
*
* Contributor(s):
* If you wish your version of this file to be governed by only the CDDL or
* only the GPL Version 2, indicate your decision by adding "[Contributor]
* elects to include this software in this distribution under the [CDDL or GPL
* Version 2] license." If you don't indicate a single choice of license, a
* recipient has the option to distribute your version of this file under
* either the CDDL, the GPL Version 2 or to extend the choice of license to
* its licensees as provided above. However, if you add GPL Version 2 code
* and therefore, elected the GPL Version 2 license, then the option applies
* only if the new code is made subject to such option by the copyright
* holder.
*/
package com.sun.xml.bind.v2.runtime.reflect;
import java.io.IOException;
import java.util.concurrent.Callable;
import javax.xml.bind.JAXBException;
import javax.xml.bind.annotation.XmlValue;
import javax.xml.stream.XMLStreamException;
import com.sun.istack.NotNull;
import com.sun.istack.Nullable;
import com.sun.istack.SAXException2;
import com.sun.xml.bind.WhiteSpaceProcessor;
import com.sun.xml.bind.api.AccessorException;
import com.sun.xml.bind.v2.model.core.ID;
import com.sun.xml.bind.v2.model.impl.RuntimeModelBuilder;
import com.sun.xml.bind.v2.model.nav.Navigator;
import com.sun.xml.bind.v2.model.runtime.RuntimeNonElementRef;
import com.sun.xml.bind.v2.model.runtime.RuntimePropertyInfo;
import com.sun.xml.bind.v2.runtime.Name;
import com.sun.xml.bind.v2.runtime.Transducer;
import com.sun.xml.bind.v2.runtime.XMLSerializer;
import com.sun.xml.bind.v2.runtime.JAXBContextImpl;
import com.sun.xml.bind.v2.runtime.reflect.opt.OptimizedTransducedAccessorFactory;
import com.sun.xml.bind.v2.runtime.unmarshaller.Patcher;
import com.sun.xml.bind.v2.runtime.unmarshaller.UnmarshallingContext;
import com.sun.xml.bind.v2.runtime.unmarshaller.LocatorEx;
import org.xml.sax.SAXException;
/**
* {@link Accessor} and {@link Transducer} combined into one object.
*
*
* This allows efficient conversions between primitive values and
* String without using boxing.
*
*
* This abstraction only works for a single-value property.
*
*
* An instance of {@link TransducedAccessor} implicitly holds a
* field of the {@code BeanT} that the accessors access.
*
* @author Kohsuke Kawaguchi ([email protected])
*/
public abstract class TransducedAccessor {
/**
* @see Transducer#useNamespace()
*/
public boolean useNamespace() {
return false;
}
/**
* Obtain the value of the field and declares the namespace URIs used in
* the value.
*
* @see Transducer#declareNamespace(Object, XMLSerializer)
*/
public void declareNamespace( BeanT o, XMLSerializer w ) throws AccessorException, SAXException {
}
/**
* Prints the responsible field of the given bean to the writer.
*
*
* Use {@link XMLSerializer#getInstance()} to access to the namespace bindings
*
* @return
* if the accessor didn't yield a value, return null.
*/
public abstract @Nullable CharSequence print(@NotNull BeanT o) throws AccessorException, SAXException;
/**
* Parses the text value into the responsible field of the given bean.
*
*
* Use {@link UnmarshallingContext#getInstance()} to access to the namespace bindings
*
* @throws AccessorException
* if the transducer is used to parse an user bean that uses {@link XmlValue},
* then this exception may occur when it tries to set the leaf value to the bean.
* @throws RuntimeException
* if the lexical form is incorrect. The method may throw a RuntimeException,
* but it shouldn't cause the entire unmarshalling to fail.
* @throws SAXException
* if the parse method found an error, the error is reported, and then
* the processing is aborted.
*/
public abstract void parse(BeanT o, CharSequence lexical) throws AccessorException, SAXException;
/**
* Checks if the field has a value.
*/
public abstract boolean hasValue(BeanT o) throws AccessorException;
/**
* Gets the {@link TransducedAccessor} appropriately configured for
* the given property.
*
*
* This allows the implementation to use an optimized code.
*/
public static TransducedAccessor get(JAXBContextImpl context, RuntimeNonElementRef ref) {
Transducer xducer = RuntimeModelBuilder.createTransducer(ref);
RuntimePropertyInfo prop = ref.getSource();
if(prop.isCollection()) {
return new ListTransducedAccessorImpl(xducer,prop.getAccessor(),
Lister.create(Navigator.REFLECTION.erasure(prop.getRawType()),prop.id(),
prop.getAdapter()));
}
if(prop.id()==ID.IDREF)
return new IDREFTransducedAccessorImpl(prop.getAccessor());
if(xducer.isDefault() && context != null && !context.fastBoot) {
TransducedAccessor xa = OptimizedTransducedAccessorFactory.get(prop);
if(xa!=null) return xa;
}
if(xducer.useNamespace())
return new CompositeContextDependentTransducedAccessorImpl( context, xducer, prop.getAccessor() );
else
return new CompositeTransducedAccessorImpl( context, xducer, prop.getAccessor() );
}
/**
* Convenience method to write the value as a text inside an element
* without any attributes.
* Can be overridden for improved performance.
*
*
* The callee assumes that there's an associated value in the field.
* No @xsi:type handling is expected.
*/
public abstract void writeLeafElement(XMLSerializer w, Name tagName, BeanT o, String fieldName) throws SAXException, AccessorException, IOException, XMLStreamException;
/**
* Invokes one of the {@link XMLSerializer#text(String, String)} method
* with the representation of data bested suited for this transduced accessor.
*/
public abstract void writeText(XMLSerializer w, BeanT o, String fieldName) throws AccessorException, SAXException, IOException, XMLStreamException;
static class CompositeContextDependentTransducedAccessorImpl extends CompositeTransducedAccessorImpl {
public CompositeContextDependentTransducedAccessorImpl(JAXBContextImpl context,Transducer xducer, Accessor acc) {
super(context,xducer,acc);
assert xducer.useNamespace();
}
@Override
public boolean useNamespace() {
return true;
}
@Override
public void declareNamespace(BeanT bean, XMLSerializer w) throws AccessorException {
ValueT o = acc.get(bean);
if(o!=null)
xducer.declareNamespace(o,w);
}
@Override
public void writeLeafElement(XMLSerializer w, Name tagName, BeanT o, String fieldName) throws SAXException, AccessorException, IOException, XMLStreamException {
w.startElement(tagName,null);
declareNamespace(o,w);
w.endNamespaceDecls(null);
w.endAttributes();
xducer.writeText(w,acc.get(o),fieldName);
w.endElement();
}
}
/**
* Implementation of {@link TransducedAccessor} that
* simply combines a {@link Transducer} and {@link Accessor}.
*/
public static class CompositeTransducedAccessorImpl extends TransducedAccessor {
protected final Transducer xducer;
protected final Accessor acc;
public CompositeTransducedAccessorImpl(JAXBContextImpl context, Transducer xducer, Accessor acc) {
this.xducer = xducer;
this.acc = acc.optimize(context);
}
public CharSequence print(BeanT bean) throws AccessorException {
ValueT o = acc.get(bean);
if(o==null) return null;
return xducer.print(o);
}
public void parse(BeanT bean, CharSequence lexical) throws AccessorException, SAXException {
acc.set(bean,xducer.parse(lexical));
}
public boolean hasValue(BeanT bean) throws AccessorException {
return acc.getUnadapted(bean)!=null;
}
@Override
public void writeLeafElement(XMLSerializer w, Name tagName, BeanT o, String fieldName) throws SAXException, AccessorException, IOException, XMLStreamException {
xducer.writeLeafElement(w,tagName,acc.get(o),fieldName);
}
@Override
public void writeText(XMLSerializer w, BeanT o, String fieldName) throws AccessorException, SAXException, IOException, XMLStreamException {
xducer.writeText(w,acc.get(o),fieldName);
}
}
/**
* {@link TransducedAccessor} for IDREF.
*
* BeanT: the type of the bean that contains this the IDREF field.
* TargetT: the type of the bean pointed by IDREF.
*/
private static final class IDREFTransducedAccessorImpl extends DefaultTransducedAccessor {
private final Accessor acc;
/**
* The object that an IDREF resolves to should be
* assignable to this type.
*/
private final Class targetType;
public IDREFTransducedAccessorImpl(Accessor acc) {
this.acc = acc;
this.targetType = acc.getValueType();
}
public String print(BeanT bean) throws AccessorException, SAXException {
TargetT target = acc.get(bean);
if(target==null) return null;
XMLSerializer w = XMLSerializer.getInstance();
try {
String id = w.grammar.getBeanInfo(target,true).getId(target,w);
if(id==null)
w.errorMissingId(target);
return id;
} catch (JAXBException e) {
w.reportError(null,e);
return null;
}
}
private void assign( BeanT bean, TargetT t, UnmarshallingContext context ) throws AccessorException {
if(!targetType.isInstance(t))
context.handleError(Messages.UNASSIGNABLE_TYPE.format(targetType,t.getClass()));
else
acc.set(bean,t);
}
public void parse(final BeanT bean, CharSequence lexical) throws AccessorException, SAXException {
final String idref = WhiteSpaceProcessor.trim(lexical).toString();
final UnmarshallingContext context = UnmarshallingContext.getInstance();
final Callable callable = context.getObjectFromId(idref,acc.valueType);
if(callable==null) {
// the IDResolver decided to abort it now
context.errorUnresolvedIDREF(bean,idref,context.getLocator());
return;
}
TargetT t;
try {
t = (TargetT)callable.call();
} catch (SAXException e) {// from callable.call
throw e;
} catch (RuntimeException e) {// from callable.call
throw e;
} catch (Exception e) {// from callable.call
throw new SAXException2(e);
}
if(t!=null) {
assign(bean,t,context);
} else {
// try again later
final LocatorEx loc = new LocatorEx.Snapshot(context.getLocator());
context.addPatcher(new Patcher() {
public void run() throws SAXException {
try {
TargetT t = (TargetT)callable.call();
if(t==null) {
context.errorUnresolvedIDREF(bean,idref,loc);
} else {
assign(bean,t,context);
}
} catch (AccessorException e) {
context.handleError(e);
} catch (SAXException e) {// from callable.call
throw e;
} catch (RuntimeException e) {// from callable.call
throw e;
} catch (Exception e) {// from callable.call
throw new SAXException2(e);
}
}
});
}
}
public boolean hasValue(BeanT bean) throws AccessorException {
return acc.get(bean)!=null;
}
}
}