calabash-android 0.4.7.pre6 → 0.4.7.pre7

data/test-server/instrumentation-backend/src/sh/calaba/org/codehaus/jackson/map/deser/MapDeserializer.java

@@ -0,0 +1,44 @@
+package sh.calaba.org.codehaus.jackson.map.deser;
+
+import java.lang.reflect.Constructor;
+import java.util.Map;
+
+import sh.calaba.org.codehaus.jackson.map.*;
+import sh.calaba.org.codehaus.jackson.type.JavaType;
+
+/**
+ * @deprecated Since 1.9, use {@link sh.calaba.org.codehaus.jackson.map.deser.std.MapDeserializer} instead.
+ */
+@Deprecated
+public class MapDeserializer
+    extends sh.calaba.org.codehaus.jackson.map.deser.std.MapDeserializer
+{
+    /**
+     * @deprecated Since 1.9, use variant that takes ValueInstantiator
+     */
+    @SuppressWarnings("deprecation")
+    @Deprecated
+    public MapDeserializer(JavaType mapType, Constructor<Map<Object,Object>> defCtor,
+            KeyDeserializer keyDeser, JsonDeserializer<Object> valueDeser,
+            TypeDeserializer valueTypeDeser)
+    {
+        super(mapType, defCtor, keyDeser, valueDeser, valueTypeDeser);
+    }
+
+    public MapDeserializer(JavaType mapType, ValueInstantiator valueInstantiator,
+            KeyDeserializer keyDeser, JsonDeserializer<Object> valueDeser,
+            TypeDeserializer valueTypeDeser)
+    {
+        super(mapType, valueInstantiator, keyDeser, valueDeser, valueTypeDeser);
+    }
+
+    /**
+     * Copy-constructor that can be used by sub-classes to allow
+     * copy-on-write styling copying of settings of an existing instance.
+     * 
+     * @since 1.9
+     */
+    protected MapDeserializer(MapDeserializer src) {
+        super(src);
+    }
+}

data/test-server/instrumentation-backend/src/sh/calaba/org/codehaus/jackson/map/deser/SettableAnyProperty.java

@@ -0,0 +1,177 @@
+package sh.calaba.org.codehaus.jackson.map.deser;
+
+import java.io.IOException;
+import java.lang.reflect.*;
+
+import sh.calaba.org.codehaus.jackson.*;
+import sh.calaba.org.codehaus.jackson.map.BeanProperty;
+import sh.calaba.org.codehaus.jackson.map.DeserializationContext;
+import sh.calaba.org.codehaus.jackson.map.JsonDeserializer;
+import sh.calaba.org.codehaus.jackson.map.JsonMappingException;
+import sh.calaba.org.codehaus.jackson.map.introspect.AnnotatedMethod;
+import sh.calaba.org.codehaus.jackson.type.JavaType;
+
+/**
+ * Class that represents a "wildcard" set method which can be used
+ * to generically set values of otherwise unmapped (aka "unknown")
+ * properties read from Json content.
+ *<p>
+ * !!! Note: might make sense to refactor to share some code
+ * with {@link SettableBeanProperty}?
+ */
+public final class SettableAnyProperty
+{
+    /**
+     * Method used for setting "any" properties, along with annotation
+     * information. Retained to allow contextualization of any properties.
+     * 
+     * @since 1.7
+     */
+    final protected BeanProperty _property;
+    
+    /**
+     * Physical JDK object used for assigning properties.
+     */
+    final protected Method _setter;
+
+    final protected JavaType _type;
+
+    protected JsonDeserializer<Object> _valueDeserializer;
+
+    /*
+    /**********************************************************
+    /* Life-cycle
+    /**********************************************************
+     */
+    
+    /**
+     * @deprecated Since 1.9 - use variant that takes deserializer
+     */
+    @Deprecated
+    public SettableAnyProperty(BeanProperty property, AnnotatedMethod setter, JavaType type) {
+        this(property, setter, type, null);
+    }
+
+    public SettableAnyProperty(BeanProperty property, AnnotatedMethod setter, JavaType type,
+            JsonDeserializer<Object> valueDeser) {
+        this(property, setter.getAnnotated(), type, valueDeser);
+    }
+
+    public SettableAnyProperty(BeanProperty property, Method rawSetter, JavaType type,
+            JsonDeserializer<Object> valueDeser) {
+        _property = property;
+        _type = type;
+        _setter = rawSetter;
+        _valueDeserializer = valueDeser;
+    }
+
+    public SettableAnyProperty withValueDeserializer(JsonDeserializer<Object> deser) {
+        return new SettableAnyProperty(_property, _setter, _type, deser);
+    }
+    
+    /**
+     * @deprecated Since 1.9 - construct with deserializer
+     */
+    @Deprecated
+    public void setValueDeserializer(JsonDeserializer<Object> deser)
+    {
+        if (_valueDeserializer != null) { // sanity check
+            throw new IllegalStateException("Already had assigned deserializer for SettableAnyProperty");
+        }
+        _valueDeserializer = deser;
+    }
+    
+    /*
+    /**********************************************************
+    /* Public API, accessors
+    /**********************************************************
+     */
+
+    public BeanProperty getProperty() { return _property; }
+    
+    public boolean hasValueDeserializer() { return (_valueDeserializer != null); }
+
+    public JavaType getType() { return _type; }
+
+    /*
+    /**********************************************************
+    /* Public API, deserialization
+    /**********************************************************
+     */
+    
+    /**
+     * Method called to deserialize appropriate value, given parser (and
+     * context), and set it using appropriate method (a setter method).
+     */
+    public final void deserializeAndSet(JsonParser jp, DeserializationContext ctxt,
+                                        Object instance, String propName)
+        throws IOException, JsonProcessingException
+    {
+        set(instance, propName, deserialize(jp, ctxt));
+    }
+
+    public final Object deserialize(JsonParser jp, DeserializationContext ctxt)
+        throws IOException, JsonProcessingException
+    {
+        JsonToken t = jp.getCurrentToken();
+        if (t == JsonToken.VALUE_NULL) {
+            return null;
+        }
+        return _valueDeserializer.deserialize(jp, ctxt);
+    }
+
+    public final void set(Object instance, String propName, Object value)
+        throws IOException
+    {
+        try {
+            _setter.invoke(instance, propName, value);
+        } catch (Exception e) {
+            _throwAsIOE(e, propName, value);
+        }
+    }
+
+    /*
+    /**********************************************************
+    /* Helper methods
+    /**********************************************************
+     */
+
+    /**
+     * @param e Exception to re-throw or wrap
+     * @param propName Name of property (from Json input) to set
+     * @param value Value of the property
+     */
+    protected void _throwAsIOE(Exception e, String propName, Object value)
+        throws IOException
+    {
+        if (e instanceof IllegalArgumentException) {
+            String actType = (value == null) ? "[NULL]" : value.getClass().getName();
+            StringBuilder msg = new StringBuilder("Problem deserializing \"any\" property '").append(propName);
+            msg.append("' of class "+getClassName()+" (expected type: ").append(_type);
+            msg.append("; actual type: ").append(actType).append(")");
+            String origMsg = e.getMessage();
+            if (origMsg != null) {
+                msg.append(", problem: ").append(origMsg);
+            } else {
+                msg.append(" (no error message provided)");
+            }
+            throw new JsonMappingException(msg.toString(), null, e);
+        }
+        if (e instanceof IOException) {
+            throw (IOException) e;
+        }
+        if (e instanceof RuntimeException) {
+            throw (RuntimeException) e;
+        }
+        // let's wrap the innermost problem
+        Throwable t = e;
+        while (t.getCause() != null) {
+            t = t.getCause();
+        }
+        throw new JsonMappingException(t.getMessage(), null, t);
+    }
+
+    private String getClassName() { return _setter.getDeclaringClass().getName(); }
+
+    @Override public String toString() { return "[any property on class "+getClassName()+"]"; }
+}

data/test-server/instrumentation-backend/src/sh/calaba/org/codehaus/jackson/map/deser/SettableBeanProperty.java

@@ -0,0 +1,827 @@
+package sh.calaba.org.codehaus.jackson.map.deser;
+
+import java.io.IOException;
+import java.lang.annotation.Annotation;
+import java.lang.reflect.*;
+import java.util.*;
+
+import sh.calaba.org.codehaus.jackson.*;
+import sh.calaba.org.codehaus.jackson.map.*;
+import sh.calaba.org.codehaus.jackson.map.introspect.AnnotatedField;
+import sh.calaba.org.codehaus.jackson.map.introspect.AnnotatedMember;
+import sh.calaba.org.codehaus.jackson.map.introspect.AnnotatedMethod;
+import sh.calaba.org.codehaus.jackson.map.util.Annotations;
+import sh.calaba.org.codehaus.jackson.map.util.ClassUtil;
+import sh.calaba.org.codehaus.jackson.type.JavaType;
+import sh.calaba.org.codehaus.jackson.util.InternCache;
+
+/**
+ * Base class for settable properties of a bean: contains
+ * both type and name definitions, and reflection-based set functionality.
+ * Concrete sub-classes implement details, so that both field- and
+ * setter-backed properties can be handled
+ */
+public abstract class SettableBeanProperty
+    implements BeanProperty // since 1.7
+{
+    /**
+     * Logical name of the property (often but not always derived
+     * from the setter method name)
+     */
+    protected final String _propName;
+
+    /**
+     * Base type for property; may be a supertype of actual value.
+     */
+    protected final JavaType _type;
+    
+    /**
+     * Class that contains this property (either class that declares
+     * the property or one of its subclasses), class that is
+     * deserialized using deserializer that contains this property.
+     */
+    protected final Annotations _contextAnnotations;
+    
+    /**
+     * Deserializer used for handling property value.
+     */
+    protected JsonDeserializer<Object> _valueDeserializer;
+
+    /**
+     * If value will contain type information (to support
+     * polymorphic handling), this is the type deserializer
+     * used to handle type resolution.
+     */
+    protected TypeDeserializer _valueTypeDeserializer;
+    
+    /**
+     * Object used to figure out value to be used when 'null' literal is encountered in JSON.
+     * For most types simply Java null, but for primitive types must
+     * be a non-null value (like Integer.valueOf(0) for int).
+     * 
+     * @since 1.7
+     */
+    protected NullProvider _nullProvider;
+
+    /**
+     * If property represents a managed (forward) reference
+     * (see [JACKSON-235]), we will need name of reference for
+     * later linking.
+     */
+    protected String _managedReferenceName;
+
+    /**
+     * Index of property (within all property of a bean); assigned
+     * when all properties have been collected. Order of entries
+     * is arbitrary, but once indexes are assigned they are not
+     * changed.
+     * 
+     * @since 1.7
+     */
+    protected int _propertyIndex = -1;
+    
+    /*
+    /**********************************************************
+    /* Life-cycle (construct & configure)
+    /**********************************************************
+     */
+
+    protected SettableBeanProperty(String propName, JavaType type, TypeDeserializer typeDeser,
+            Annotations contextAnnotations)
+    {
+        /* 09-Jan-2009, tatu: Intern()ing makes sense since Jackson parsed
+         *   field names are (usually) interned too, hence lookups will be faster.
+         */
+        // 23-Oct-2009, tatu: should this be disabled wrt [JACKSON-180]?
+        if (propName == null || propName.length() == 0) {
+            _propName = "";
+        } else {
+            _propName = InternCache.instance.intern(propName);
+        }
+        _type = type;
+        _contextAnnotations = contextAnnotations;
+        _valueTypeDeserializer = typeDeser;
+    }
+
+    /**
+     * Basic copy-constructor for sub-classes to use.
+     * 
+     * @since 1.9
+     */
+    protected SettableBeanProperty(SettableBeanProperty src)
+    {
+        _propName = src._propName;
+        _type = src._type;
+        _contextAnnotations = src._contextAnnotations;
+        _valueDeserializer = src._valueDeserializer;
+        _valueTypeDeserializer = src._valueTypeDeserializer;
+        _nullProvider = src._nullProvider;
+        _managedReferenceName = src._managedReferenceName;
+        _propertyIndex = src._propertyIndex;
+    }
+
+    /**
+     * Copy-with-deserializer-change constructor for sub-classes to use.
+     * 
+     * @since 1.9
+     */
+    protected SettableBeanProperty(SettableBeanProperty src, JsonDeserializer<Object> deser)
+    {
+        _propName = src._propName;
+        _type = src._type;
+        _contextAnnotations = src._contextAnnotations;
+        _valueTypeDeserializer = src._valueTypeDeserializer;
+        _managedReferenceName = src._managedReferenceName;
+        _propertyIndex = src._propertyIndex;
+
+        _valueDeserializer = deser;
+        if (deser == null) {
+            _nullProvider = null;
+        } else {
+            Object nvl = deser.getNullValue();
+            _nullProvider = (nvl == null) ? null : new NullProvider(_type, nvl);
+        }
+    }
+    
+    @Deprecated
+    public void setValueDeserializer(JsonDeserializer<Object> deser)
+    {
+        if (_valueDeserializer != null) { // sanity check
+            throw new IllegalStateException("Already had assigned deserializer for property '"+getName()+"' (class "+getDeclaringClass().getName()+")");
+        }
+        _valueDeserializer = deser;
+        Object nvl = _valueDeserializer.getNullValue();
+        _nullProvider = (nvl == null) ? null : new NullProvider(_type, nvl);
+    }
+    
+    /**
+     * @since 1.9
+     */
+    public abstract SettableBeanProperty withValueDeserializer(JsonDeserializer<Object> deser);
+    
+    public void setManagedReferenceName(String n) {
+        _managedReferenceName = n;
+    }
+    
+    /**
+     * Method used to assign index for property.
+     * 
+     * @since 1.7
+     */
+    public void assignIndex(int index) {
+        if (_propertyIndex != -1) {
+            throw new IllegalStateException("Property '"+getName()+"' already had index ("+_propertyIndex+"), trying to assign "+index);
+        }
+        _propertyIndex = index;
+    }
+    
+    /*
+    /**********************************************************
+    /* BeanProperty impl
+    /**********************************************************
+     */
+    
+    @Override
+    public final String getName() { return _propName; }
+
+    @Override
+    public JavaType getType() { return _type; }
+
+    @Override
+    public abstract <A extends Annotation> A getAnnotation(Class<A> acls);
+
+    @Override
+    public abstract AnnotatedMember getMember();
+
+    @Override
+    public <A extends Annotation> A getContextAnnotation(Class<A> acls) {
+        return _contextAnnotations.get(acls);
+    }
+
+    /*
+    /**********************************************************
+    /* Accessors
+    /**********************************************************
+     */
+
+    protected final Class<?> getDeclaringClass() {
+        return getMember().getDeclaringClass();
+    }
+    
+    /**
+     * @deprecated Since 1.7, use {@link #getName} instead.
+     */
+    @Deprecated
+    public String getPropertyName() { return _propName; }
+
+    public String getManagedReferenceName() { return _managedReferenceName; }
+
+    public boolean hasValueDeserializer() { return (_valueDeserializer != null); }
+
+    /**
+     * @since 1.9
+     */
+    public boolean hasValueTypeDeserializer() { return (_valueTypeDeserializer != null); }
+    
+    /**
+     * @since 1.9
+     */
+    public JsonDeserializer<Object> getValueDeserializer() { return _valueDeserializer; }
+
+    /**
+     * @since 1.9
+     */
+    public TypeDeserializer getValueTypeDeserializer() { return _valueTypeDeserializer; }
+    
+    /**
+     * Method for accessing unique index of this property; indexes are
+     * assigned once all properties of a {@link BeanDeserializer} have
+     * been collected.
+     * 
+     * @return Index of this property
+     * 
+     * @since 1.7 Although note that it was misspelled as "getProperytIndex"; fixed in 1.9
+     */
+    public int getPropertyIndex() { return _propertyIndex; }
+
+    /**
+     * @deprecated Since 1.9: use {@link #getPropertyIndex} instead
+     */
+    @Deprecated
+    public int getProperytIndex() { return getPropertyIndex(); }
+
+    /**
+     * Accessor for id of injectable value, if this bean property supports
+     * value injection.
+     * 
+     * @since 1.9
+     */
+    public Object getInjectableValueId() { return null; }
+    
+    /*
+    /**********************************************************
+    /* Public API
+    /**********************************************************
+     */
+
+    /**
+     * Method called to deserialize appropriate value, given parser (and
+     * context), and set it using appropriate mechanism.
+     * Pre-condition is that passed parser must point to the first token
+     * that should be consumed to produce the value (the only value for
+     * scalars, multiple for Objects and Arrays).
+     */
+    public abstract void deserializeAndSet(JsonParser jp, DeserializationContext ctxt,
+                                           Object instance)
+        throws IOException, JsonProcessingException;
+
+    public abstract void set(Object instance, Object value)
+        throws IOException;
+
+    /**
+     * This method is needed by some specialized bean deserializers,
+     * and also called by some {@link #deserializeAndSet} implementations.
+     *<p>
+     * Pre-condition is that passed parser must point to the first token
+     * that should be consumed to produce the value (the only value for
+     * scalars, multiple for Objects and Arrays).
+     */
+    public final Object deserialize(JsonParser jp, DeserializationContext ctxt)
+        throws IOException, JsonProcessingException
+    {
+        JsonToken t = jp.getCurrentToken();
+        if (t == JsonToken.VALUE_NULL) {
+            return (_nullProvider == null) ? null : _nullProvider.nullValue(ctxt);
+        }
+        if (_valueTypeDeserializer != null) {
+            return _valueDeserializer.deserializeWithType(jp, ctxt, _valueTypeDeserializer);
+        }
+        return _valueDeserializer.deserialize(jp, ctxt);
+    }
+    
+    /*
+    /**********************************************************
+    /* Helper methods
+    /**********************************************************
+     */
+
+    /**
+     * Method that takes in exception of any type, and casts or wraps it
+     * to an IOException or its subclass.
+     */
+    protected void _throwAsIOE(Exception e, Object value)
+        throws IOException
+    {
+        if (e instanceof IllegalArgumentException) {
+            String actType = (value == null) ? "[NULL]" : value.getClass().getName();
+            StringBuilder msg = new StringBuilder("Problem deserializing property '").append(getPropertyName());
+            msg.append("' (expected type: ").append(getType());
+            msg.append("; actual type: ").append(actType).append(")");
+            String origMsg = e.getMessage();
+            if (origMsg != null) {
+                msg.append(", problem: ").append(origMsg);
+            } else {
+                msg.append(" (no error message provided)");
+            }
+            throw new JsonMappingException(msg.toString(), null, e);
+        }
+        _throwAsIOE(e);
+    }
+
+    protected IOException _throwAsIOE(Exception e)
+        throws IOException
+    {
+        if (e instanceof IOException) {
+            throw (IOException) e;
+        }
+        if (e instanceof RuntimeException) {
+            throw (RuntimeException) e;
+        }
+        // let's wrap the innermost problem
+        Throwable th = e;
+        while (th.getCause() != null) {
+            th = th.getCause();
+        }
+        throw new JsonMappingException(th.getMessage(), null, th);
+    }
+    
+    @Override public String toString() { return "[property '"+getName()+"']"; }
+
+    /*
+    /**********************************************************
+    /* Implementation classes
+    /**********************************************************
+     */
+
+    /**
+     * This concrete sub-class implements property that is set
+     * using regular "setter" method.
+     */
+    public final static class MethodProperty
+        extends SettableBeanProperty
+    {
+        protected final AnnotatedMethod _annotated;
+        
+        /**
+         * Setter method for modifying property value; used for
+         * "regular" method-accessible properties.
+         */
+        protected final Method _setter;
+
+        public MethodProperty(String name, JavaType type, TypeDeserializer typeDeser,
+                Annotations contextAnnotations, AnnotatedMethod method)
+        {
+            super(name, type, typeDeser, contextAnnotations);
+            _annotated = method;
+            _setter = method.getAnnotated();
+        }
+
+        protected MethodProperty(MethodProperty src, JsonDeserializer<Object> deser) {
+            super(src, deser);
+            _annotated = src._annotated;
+            _setter = src._setter;
+        }
+        
+        @Override
+        public MethodProperty withValueDeserializer(JsonDeserializer<Object> deser) {
+            return new MethodProperty(this, deser);
+        }
+        
+        /*
+        /**********************************************************
+        /* BeanProperty impl
+        /**********************************************************
+         */
+        
+        @Override
+        public <A extends Annotation> A getAnnotation(Class<A> acls) {
+            return _annotated.getAnnotation(acls);
+        }
+
+        @Override public AnnotatedMember getMember() {  return _annotated; }
+
+        /*
+        /**********************************************************
+        /* Overridden methods
+        /**********************************************************
+         */
+
+        @Override
+        public void deserializeAndSet(JsonParser jp, DeserializationContext ctxt,
+                Object instance)
+            throws IOException, JsonProcessingException
+        {
+            set(instance, deserialize(jp, ctxt));
+        }
+
+        @Override
+        public final void set(Object instance, Object value)
+            throws IOException
+        {
+            try {
+                _setter.invoke(instance, value);
+            } catch (Exception e) {
+                _throwAsIOE(e, value);
+            }
+        }
+    }
+
+    /**
+     * This concrete sub-class implements Collection or Map property that is
+     * indirectly by getting the property value and directly modifying it.
+     */
+    public final static class SetterlessProperty
+        extends SettableBeanProperty
+    {
+        protected final AnnotatedMethod _annotated;
+
+        /**
+         * Get method for accessing property value used to access property
+         * (of Collection or Map type) to modify.
+         */
+        protected final Method _getter;
+
+        public SetterlessProperty(String name, JavaType type, TypeDeserializer typeDeser,
+                Annotations contextAnnotations, AnnotatedMethod method)
+            {
+            super(name, type, typeDeser, contextAnnotations);
+            _annotated = method;
+            _getter = method.getAnnotated();
+        }
+
+        protected SetterlessProperty(SetterlessProperty src, JsonDeserializer<Object> deser) {
+            super(src, deser);
+            _annotated = src._annotated;
+            _getter = src._getter;
+        }
+        
+        @Override
+        public SetterlessProperty withValueDeserializer(JsonDeserializer<Object> deser) {
+            return new SetterlessProperty(this, deser);
+        }
+        
+        /*
+        /**********************************************************
+        /* BeanProperty impl
+        /**********************************************************
+         */
+        
+        @Override
+        public <A extends Annotation> A getAnnotation(Class<A> acls) {
+            return _annotated.getAnnotation(acls);
+        }
+
+        @Override public AnnotatedMember getMember() {  return _annotated; }
+
+        /*
+        /**********************************************************
+        /* Overridden methods
+        /**********************************************************
+         */
+        
+        @Override
+        public final void deserializeAndSet(JsonParser jp, DeserializationContext ctxt,
+                Object instance)
+            throws IOException, JsonProcessingException
+        {
+            JsonToken t = jp.getCurrentToken();
+            if (t == JsonToken.VALUE_NULL) {
+                /* Hmmh. Is this a problem? We won't be setting anything, so it's
+                 * equivalent of empty Collection/Map in this case
+                 */
+                return;
+            }
+
+            // Ok: then, need to fetch Collection/Map to modify:
+            Object toModify;
+            try {
+                toModify = _getter.invoke(instance);
+            } catch (Exception e) {
+                _throwAsIOE(e);
+                return; // never gets here
+            }
+            /* Note: null won't work, since we can't then inject anything
+             * in. At least that's not good in common case. However,
+             * theoretically the case where we get JSON null might
+             * be compatible. If so, implementation could be changed.
+             */
+            if (toModify == null) {
+                throw new JsonMappingException("Problem deserializing 'setterless' property '"+getName()+"': get method returned null");
+            }
+            _valueDeserializer.deserialize(jp, ctxt, toModify);
+        }
+
+        @Override
+        public final void set(Object instance, Object value)
+            throws IOException
+        {
+            throw new UnsupportedOperationException("Should never call 'set' on setterless property");
+        }
+    }
+
+    /**
+     * This concrete sub-class implements property that is set
+     * directly assigning to a Field.
+     */
+    public final static class FieldProperty
+        extends SettableBeanProperty
+    {
+        protected final AnnotatedField _annotated;
+
+        /**
+         * Actual field to set when deserializing this property.
+         */
+        protected final Field _field;
+
+        public FieldProperty(String name, JavaType type, TypeDeserializer typeDeser,
+                Annotations contextAnnotations, AnnotatedField field)
+        {
+            super(name, type, typeDeser, contextAnnotations);
+            _annotated = field;
+            _field = field.getAnnotated();
+        }
+
+        protected FieldProperty(FieldProperty src, JsonDeserializer<Object> deser) {
+            super(src, deser);
+            _annotated = src._annotated;
+            _field = src._field;
+        }
+        
+        @Override
+        public FieldProperty withValueDeserializer(JsonDeserializer<Object> deser) {
+            return new FieldProperty(this, deser);
+        }
+        
+        /*
+        /**********************************************************
+        /* BeanProperty impl
+        /**********************************************************
+         */
+        
+        @Override
+        public <A extends Annotation> A getAnnotation(Class<A> acls) {
+            return _annotated.getAnnotation(acls);
+        }
+
+        @Override public AnnotatedMember getMember() {  return _annotated; }
+
+        /*
+        /**********************************************************
+        /* Overridden methods
+        /**********************************************************
+         */
+
+        @Override
+        public void deserializeAndSet(JsonParser jp, DeserializationContext ctxt,
+                                      Object instance)
+            throws IOException, JsonProcessingException
+        {
+            set(instance, deserialize(jp, ctxt));
+        }
+
+        @Override
+        public final void set(Object instance, Object value)
+            throws IOException
+        {
+            try {
+                _field.set(instance, value);
+            } catch (Exception e) {
+                _throwAsIOE(e, value);
+            }
+        }
+    }
+
+     /**
+     * Wrapper property that is used to handle managed (forward) properties
+     * (see [JACKSON-235] for more information). Basically just need to
+     * delegate first to actual forward property, and 
+     * 
+     * @author tatu
+     */
+    public final static class ManagedReferenceProperty
+        extends SettableBeanProperty
+    {
+        protected final String _referenceName;
+        
+        /**
+         * Flag that indicates whether property to handle is a container type
+         * (array, Collection, Map) or not.
+         */
+        protected final boolean _isContainer;
+        
+        protected final SettableBeanProperty _managedProperty;
+
+        protected final SettableBeanProperty _backProperty;
+        
+        public ManagedReferenceProperty(String refName,
+                SettableBeanProperty forward, SettableBeanProperty backward,
+                Annotations contextAnnotations,
+                boolean isContainer)
+        {
+            super(forward.getName(), forward.getType(), forward._valueTypeDeserializer,
+                    contextAnnotations);
+            _referenceName = refName;
+            _managedProperty = forward;
+            _backProperty = backward;
+            _isContainer = isContainer;
+        }
+
+        protected ManagedReferenceProperty(ManagedReferenceProperty src, JsonDeserializer<Object> deser)
+        {
+            super(src, deser);
+            _referenceName = src._referenceName;
+            _isContainer = src._isContainer;
+            _managedProperty = src._managedProperty;
+            _backProperty = src._backProperty;
+        }
+        
+        @Override
+        public ManagedReferenceProperty withValueDeserializer(JsonDeserializer<Object> deser) {
+            return new ManagedReferenceProperty(this, deser);
+        }
+        
+        /*
+        /**********************************************************
+        /* BeanProperty impl
+        /**********************************************************
+         */
+        
+        @Override
+        public <A extends Annotation> A getAnnotation(Class<A> acls) {
+            return _managedProperty.getAnnotation(acls);
+        }
+
+        @Override public AnnotatedMember getMember() {  return _managedProperty.getMember(); }
+
+        /*
+        /**********************************************************
+        /* Overridden methods
+        /**********************************************************
+         */
+    
+        @Override
+        public void deserializeAndSet(JsonParser jp, DeserializationContext ctxt,
+                                      Object instance)
+            throws IOException, JsonProcessingException
+        {
+            set(instance, _managedProperty.deserialize(jp, ctxt));
+        }
+    
+        @Override
+        public final void set(Object instance, Object value)
+            throws IOException
+        {
+            _managedProperty.set(instance, value);
+            /* And then back reference, if (and only if!) we actually have a non-null
+             * reference
+             */
+            if (value != null) {
+                if (_isContainer) { // ok, this gets ugly... but has to do for now
+                    if (value instanceof Object[]) {
+                        for (Object ob : (Object[]) value) {
+                            if (ob != null) {
+                                _backProperty.set(ob, instance);                            
+                            }
+                        }
+                    } else if (value instanceof Collection<?>) {
+                        for (Object ob : (Collection<?>) value) {
+                            if (ob != null) {
+                                _backProperty.set(ob, instance);                            
+                            }
+                        }
+                    } else if (value instanceof Map<?,?>) {
+                        for (Object ob : ((Map<?,?>) value).values()) {
+                            if (ob != null) {
+                                _backProperty.set(ob, instance);                            
+                            }
+                        }
+                    } else {
+                        throw new IllegalStateException("Unsupported container type ("+value.getClass().getName()
+                                +") when resolving reference '"+_referenceName+"'");
+                    }
+                } else {
+                    _backProperty.set(value, instance);
+                }
+            }
+        }
+    }
+
+    /**
+     * This sub-class is used to handle special case of value being a
+     * non-static inner class. If so, we will have to use a special
+     * alternative for default constructor; but otherwise can delegate
+     * to regular implementation.
+     * 
+     * @since 1.9
+     */
+    public final static class InnerClassProperty
+        extends SettableBeanProperty
+    {
+        /**
+         * Actual property that we use after value construction.
+         */
+        protected final SettableBeanProperty _delegate;
+
+        /**
+         * Single-arg constructor we use for value instantiation.
+         */
+        protected final Constructor<?> _creator;
+        
+        public InnerClassProperty(SettableBeanProperty delegate,
+                Constructor<?> ctor)
+        {
+            super(delegate);
+            _delegate = delegate;
+            _creator = ctor;
+        }
+
+        protected InnerClassProperty(InnerClassProperty src, JsonDeserializer<Object> deser)
+        {
+            super(src, deser);
+            _delegate = src._delegate.withValueDeserializer(deser);
+            _creator = src._creator;
+        }
+        
+        @Override
+        public InnerClassProperty withValueDeserializer(JsonDeserializer<Object> deser) {
+            return new InnerClassProperty(this, deser);
+        }
+        
+        // // // BeanProperty impl
+        
+        @Override
+        public <A extends Annotation> A getAnnotation(Class<A> acls) {
+            return _delegate.getAnnotation(acls);
+        }
+
+        @Override public AnnotatedMember getMember() {  return _delegate.getMember(); }
+
+        // // //  Overridden methods
+
+        @Override
+        public void deserializeAndSet(JsonParser jp, DeserializationContext ctxt,
+                Object bean)
+            throws IOException, JsonProcessingException
+        {
+            // mostly copied from super class impl:
+            JsonToken t = jp.getCurrentToken();
+            Object value;
+            if (t == JsonToken.VALUE_NULL) {
+                value = (_nullProvider == null) ? null : _nullProvider.nullValue(ctxt);
+            } else if (_valueTypeDeserializer != null) {
+                value = _valueDeserializer.deserializeWithType(jp, ctxt, _valueTypeDeserializer);
+            } else  { // the usual case
+                try {
+                    value = _creator.newInstance(bean);
+                } catch (Exception e) {
+                    ClassUtil.unwrapAndThrowAsIAE(e, "Failed to instantiate class "+_creator.getDeclaringClass().getName()+", problem: "+e.getMessage());
+                    value = null;
+                }
+                _valueDeserializer.deserialize(jp, ctxt, value);
+            }
+            set(bean, value);
+        }
+
+        @Override
+        public final void set(Object instance, Object value) throws IOException
+        {
+            _delegate.set(instance, value);
+        }
+    }
+    
+    /*
+    /**********************************************************
+    /* Other helper classes
+    /**********************************************************
+     */
+    
+    /**
+     * To support [JACKSON-420] we need bit more indirection; this is used to produce
+     * artificial failure for primitives that don't accept JSON null as value.
+     */
+    protected final static class NullProvider
+    {
+        private final Object _nullValue;
+
+        private final boolean _isPrimitive;
+        
+        private final Class<?> _rawType;
+        
+        protected NullProvider(JavaType type, Object nullValue)
+        {
+            _nullValue = nullValue;
+            // [JACKSON-420]
+            _isPrimitive = type.isPrimitive();
+            _rawType = type.getRawClass();
+        }
+
+        public Object nullValue(DeserializationContext ctxt) throws JsonProcessingException
+        {
+            if (_isPrimitive && ctxt.isEnabled(DeserializationConfig.Feature.FAIL_ON_NULL_FOR_PRIMITIVES)) {
+                throw ctxt.mappingException("Can not map JSON null into type "+_rawType.getName()
+                        +" (set DeserializationConfig.Feature.FAIL_ON_NULL_FOR_PRIMITIVES to 'false' to allow)");
+            }
+            return _nullValue;
+        }
+    }
+}