calabash-android 0.4.7.pre6 → 0.4.7.pre7

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

@@ -0,0 +1,102 @@
+package sh.calaba.org.codehaus.jackson.map.deser.impl;
+
+import sh.calaba.org.codehaus.jackson.JsonParser;
+import sh.calaba.org.codehaus.jackson.map.DeserializationContext;
+import sh.calaba.org.codehaus.jackson.map.deser.SettableAnyProperty;
+import sh.calaba.org.codehaus.jackson.map.deser.SettableBeanProperty;
+
+/**
+ * Simple container used for temporarily buffering a set of
+ * <code>PropertyValue</code>s.
+ * Using during construction of beans (and Maps) that use Creators, 
+ * and hence need buffering before instance (that will have properties
+ * to assign values to) is constructed.
+ */
+public final class PropertyValueBuffer
+{
+    final JsonParser _parser;
+    final DeserializationContext _context;
+    
+    /**
+     * Buffer used for storing creator parameters for constructing
+     * instance
+     */
+    final Object[] _creatorParameters;
+    
+    /**
+     * Number of creator parameters we are still missing.
+     *<p>
+     * NOTE: assumes there are no duplicates, for now.
+     */
+    private int _paramsNeeded;
+    
+    /**
+     * If we get non-creator parameters before or between
+     * creator parameters, those need to be buffered. Buffer
+     * is just a simple linked list
+     */
+    private PropertyValue _buffered;
+    
+    public PropertyValueBuffer(JsonParser jp, DeserializationContext ctxt, int paramCount)
+    {
+        _parser = jp;
+        _context = ctxt;
+        _paramsNeeded = paramCount;
+        _creatorParameters = new Object[paramCount];
+    }
+
+    public void inject(SettableBeanProperty[] injectableProperties)
+    {
+        for (int i = 0, len = injectableProperties.length; i < len; ++i) {
+            SettableBeanProperty prop = injectableProperties[i];
+            if (prop != null) {
+                // null since there is no POJO yet
+                _creatorParameters[i] = _context.findInjectableValue(prop.getInjectableValueId(),
+                        prop, null);
+            }
+        }
+    }
+    
+    /**
+     * @param defaults If any of parameters requires nulls to be replaced with a non-null
+     *    object (usually primitive types), this is a non-null array that has such replacement
+     *    values (and nulls for cases where nulls are ok)
+     */
+    protected final Object[] getParameters(Object[] defaults)
+    {
+        if (defaults != null) {
+            for (int i = 0, len = _creatorParameters.length; i < len; ++i) {
+                if (_creatorParameters[i] == null) {
+                    Object value = defaults[i];
+                    if (value != null) {
+                        _creatorParameters[i] = value;
+                    }
+                }
+            }
+        }
+        return _creatorParameters;
+    }
+
+    protected PropertyValue buffered() { return _buffered; }
+    
+    /**
+     * @return True if we have received all creator parameters
+     */
+    public boolean assignParameter(int index, Object value) {
+        _creatorParameters[index] = value;
+        return --_paramsNeeded <= 0;
+    }
+    
+    public void bufferProperty(SettableBeanProperty prop, Object value) {
+        _buffered = new PropertyValue.Regular(_buffered, value, prop);
+    }
+    
+    public void bufferAnyProperty(SettableAnyProperty prop, String propName, Object value) {
+        _buffered = new PropertyValue.Any(_buffered, value, prop, propName);
+    }
+
+    public void bufferMapProperty(Object key, Object value) {
+        _buffered = new PropertyValue.Map(_buffered, value, key);
+    }
+}
+

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

@@ -0,0 +1,41 @@
+package sh.calaba.org.codehaus.jackson.map.deser.impl;
+
+import java.io.IOException;
+import java.util.*;
+
+import sh.calaba.org.codehaus.jackson.JsonParser;
+import sh.calaba.org.codehaus.jackson.JsonProcessingException;
+import sh.calaba.org.codehaus.jackson.map.DeserializationContext;
+import sh.calaba.org.codehaus.jackson.map.deser.SettableBeanProperty;
+import sh.calaba.org.codehaus.jackson.util.TokenBuffer;
+
+/**
+ * Object that is responsible for handling acrobatics related to
+ * deserializing "unwrapped" values; sets of properties that are
+ * embedded (inlined) as properties of parent JSON object.
+ *
+ * @since 1.9
+ */
+public class UnwrappedPropertyHandler
+{
+    protected final ArrayList<SettableBeanProperty> _properties = new ArrayList<SettableBeanProperty>();
+    
+    public UnwrappedPropertyHandler()  { }
+
+    public void addProperty(SettableBeanProperty property) {
+        _properties.add(property);
+    }
+
+    public Object processUnwrapped(JsonParser originalParser, DeserializationContext ctxt, Object bean,
+            TokenBuffer buffered)
+        throws IOException, JsonProcessingException
+    {
+        for (int i = 0, len = _properties.size(); i < len; ++i) {
+            SettableBeanProperty prop = _properties.get(i);
+            JsonParser jp = buffered.asParser();
+            jp.nextToken();
+            prop.deserializeAndSet(jp, ctxt, bean);
+        }
+        return bean;
+    }
+}

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

@@ -0,0 +1,45 @@
+package sh.calaba.org.codehaus.jackson.map.deser.impl;
+
+import java.io.IOException;
+
+import sh.calaba.org.codehaus.jackson.map.BeanProperty;
+import sh.calaba.org.codehaus.jackson.map.DeserializationContext;
+import sh.calaba.org.codehaus.jackson.map.introspect.AnnotatedMember;
+import sh.calaba.org.codehaus.jackson.map.util.Annotations;
+import sh.calaba.org.codehaus.jackson.type.JavaType;
+
+/**
+ * Class that encapsulates details of value injection that occurs before
+ * deserialization of a POJO. Details include information needed to find
+ * injectable value (logical id) as well as method used for assigning
+ * value (setter or field)
+ * 
+ * @since 1.9
+ */
+public class ValueInjector
+    extends BeanProperty.Std
+{
+    /**
+     * Identifier used for looking up value to inject
+     */
+    protected final Object _valueId;
+
+    public ValueInjector(String propertyName, JavaType type,
+            Annotations contextAnnotations, AnnotatedMember mutator,
+            Object valueId)
+    {
+        super(propertyName, type, contextAnnotations, mutator);
+        _valueId = valueId;
+    }
+
+    public Object findValue(DeserializationContext context, Object beanInstance)
+    {
+        return context.findInjectableValue(_valueId, this, beanInstance);
+    }
+    
+    public void inject(DeserializationContext context, Object beanInstance)
+        throws IOException
+    {
+        _member.setValue(beanInstance, findValue(context, beanInstance));
+    }
+}

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

@@ -0,0 +1,9 @@
+/**
+ * Contains those implementation classes of deserialization part of 
+ * data binding that are not considered part of public or semi-public
+ * interfaces. Use of these classes by non-core classes is discouraged,
+ * although occasionally this may be necessary.
+ * Note that backwards-compatibility of these classes is not guaranteed
+ * between minor releases (but is between patch releases).
+ */
+package sh.calaba.org.codehaus.jackson.map.deser.impl;

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

@@ -0,0 +1,5 @@
+/**
+ * Contains implementation classes of deserialization part of 
+ * data binding.
+ */
+package sh.calaba.org.codehaus.jackson.map.deser;

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

@@ -0,0 +1,22 @@
+package sh.calaba.org.codehaus.jackson.map.deser.std;
+
+import java.io.IOException;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import sh.calaba.org.codehaus.jackson.JsonParser;
+import sh.calaba.org.codehaus.jackson.JsonProcessingException;
+import sh.calaba.org.codehaus.jackson.map.DeserializationContext;
+
+public class AtomicBooleanDeserializer
+    extends StdScalarDeserializer<AtomicBoolean>
+{
+    public AtomicBooleanDeserializer() { super(AtomicBoolean.class); }
+    
+    @Override
+    public AtomicBoolean deserialize(JsonParser jp, DeserializationContext ctxt)
+        throws IOException, JsonProcessingException
+    {
+        // 16-Dec-2010, tatu: Should we actually convert null to null AtomicBoolean?
+        return new AtomicBoolean(_parseBooleanPrimitive(jp, ctxt));
+    }
+}

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

@@ -0,0 +1,47 @@
+package sh.calaba.org.codehaus.jackson.map.deser.std;
+
+import java.io.IOException;
+import java.util.concurrent.atomic.AtomicReference;
+
+import sh.calaba.org.codehaus.jackson.JsonParser;
+import sh.calaba.org.codehaus.jackson.JsonProcessingException;
+import sh.calaba.org.codehaus.jackson.map.*;
+import sh.calaba.org.codehaus.jackson.type.JavaType;
+
+public class AtomicReferenceDeserializer
+    extends StdScalarDeserializer<AtomicReference<?>>
+    implements ResolvableDeserializer
+{
+    /**
+     * Type of value that we reference
+     */
+    protected final JavaType _referencedType;
+    
+    protected final BeanProperty _property;
+    
+    protected JsonDeserializer<?> _valueDeserializer;
+    
+    /**
+     * @param referencedType Parameterization of this reference
+     */
+    public AtomicReferenceDeserializer(JavaType referencedType, BeanProperty property)
+    {
+        super(AtomicReference.class);
+        _referencedType = referencedType;
+        _property = property;
+    }
+    
+    @Override
+    public AtomicReference<?> deserialize(JsonParser jp, DeserializationContext ctxt)
+        throws IOException, JsonProcessingException
+    {
+        return new AtomicReference<Object>(_valueDeserializer.deserialize(jp, ctxt));
+    }
+    
+    @Override
+    public void resolve(DeserializationConfig config, DeserializerProvider provider)
+        throws JsonMappingException
+    {
+        _valueDeserializer = provider.findValueDeserializer(config, _referencedType, _property);
+    }
+}

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

@@ -0,0 +1,47 @@
+package sh.calaba.org.codehaus.jackson.map.deser.std;
+
+import java.io.IOException;
+import java.util.Calendar;
+import java.util.Date;
+
+import sh.calaba.org.codehaus.jackson.JsonParser;
+import sh.calaba.org.codehaus.jackson.JsonProcessingException;
+import sh.calaba.org.codehaus.jackson.map.DeserializationContext;
+import sh.calaba.org.codehaus.jackson.map.annotate.JacksonStdImpl;
+
+@JacksonStdImpl
+public class CalendarDeserializer
+    extends StdScalarDeserializer<Calendar>
+{
+    /**
+     * We may know actual expected type; if so, it will be
+     * used for instantiation.
+     */
+    protected final Class<? extends Calendar> _calendarClass;
+    
+    public CalendarDeserializer() { this(null); }
+    public CalendarDeserializer(Class<? extends Calendar> cc) {
+        super(Calendar.class);
+        _calendarClass = cc;
+    }
+
+    @Override
+    public Calendar deserialize(JsonParser jp, DeserializationContext ctxt)
+        throws IOException, JsonProcessingException
+    {
+        Date d = _parseDate(jp, ctxt);
+        if (d == null) {
+            return null;
+        }
+        if (_calendarClass == null) {
+            return ctxt.constructCalendar(d);
+        }
+        try {
+            Calendar c = _calendarClass.newInstance();            
+            c.setTimeInMillis(d.getTime());
+            return c;
+        } catch (Exception e) {
+            throw ctxt.instantiationException(_calendarClass, e);
+        }
+    }
+}

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

@@ -0,0 +1,49 @@
+package sh.calaba.org.codehaus.jackson.map.deser.std;
+
+import java.io.IOException;
+
+import sh.calaba.org.codehaus.jackson.JsonParser;
+import sh.calaba.org.codehaus.jackson.JsonProcessingException;
+import sh.calaba.org.codehaus.jackson.JsonToken;
+import sh.calaba.org.codehaus.jackson.map.DeserializationContext;
+import sh.calaba.org.codehaus.jackson.map.annotate.JacksonStdImpl;
+
+/**
+ * 
+ * @since 1.9 (renamed from 'sh.calaba.org.codehaus.jackson.map.deser.StdDeserializer#ClassDeserializer')
+ */
+@JacksonStdImpl
+public class ClassDeserializer
+    extends StdScalarDeserializer<Class<?>>
+{
+    public ClassDeserializer() { super(Class.class); }
+
+    @Override
+    public Class<?> deserialize(JsonParser jp, DeserializationContext ctxt)
+        throws IOException, JsonProcessingException
+    {
+        JsonToken curr = jp.getCurrentToken();
+        // Currently will only accept if given simple class name
+        if (curr == JsonToken.VALUE_STRING) {
+            String className = jp.getText();
+            // [JACKSON-597]: support primitive types (and void)
+            if (className.indexOf('.') < 0) {
+                if ("int".equals(className)) return Integer.TYPE;
+                if ("long".equals(className)) return Long.TYPE;
+                if ("float".equals(className)) return Float.TYPE;
+                if ("double".equals(className)) return Double.TYPE;
+                if ("boolean".equals(className)) return Boolean.TYPE;
+                if ("byte".equals(className)) return Byte.TYPE;
+                if ("char".equals(className)) return Character.TYPE;
+                if ("short".equals(className)) return Short.TYPE;
+                if ("void".equals(className)) return Void.TYPE;
+            }
+            try {
+                return Class.forName(jp.getText());
+            } catch (ClassNotFoundException e) {
+                throw ctxt.instantiationException(_valueClass, e);
+            }
+        }
+        throw ctxt.mappingException(_valueClass, curr);
+    }
+}

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

@@ -0,0 +1,265 @@
+package sh.calaba.org.codehaus.jackson.map.deser.std;
+
+import java.io.IOException;
+import java.lang.reflect.Constructor;
+import java.util.*;
+
+import sh.calaba.org.codehaus.jackson.JsonParser;
+import sh.calaba.org.codehaus.jackson.JsonProcessingException;
+import sh.calaba.org.codehaus.jackson.JsonToken;
+import sh.calaba.org.codehaus.jackson.map.*;
+import sh.calaba.org.codehaus.jackson.map.annotate.JacksonStdImpl;
+import sh.calaba.org.codehaus.jackson.map.deser.ValueInstantiator;
+import sh.calaba.org.codehaus.jackson.map.deser.std.ContainerDeserializerBase;
+import sh.calaba.org.codehaus.jackson.map.deser.std.StdValueInstantiator;
+import sh.calaba.org.codehaus.jackson.map.introspect.AnnotatedConstructor;
+import sh.calaba.org.codehaus.jackson.map.introspect.AnnotatedWithParams;
+import sh.calaba.org.codehaus.jackson.type.JavaType;
+
+/**
+ * Basic serializer that can take JSON "Array" structure and
+ * construct a {@link java.util.Collection} instance, with typed contents.
+ *<p>
+ * Note: for untyped content (one indicated by passing Object.class
+ * as the type), {@link UntypedObjectDeserializer} is used instead.
+ * It can also construct {@link java.util.List}s, but not with specific
+ * POJO types, only other containers and primitives/wrappers.
+ * 
+ * @since 1.9 (renamed from 'sh.calaba.org.codehaus.jackson.map.deser.CollectionDeserializer)
+ */
+@JacksonStdImpl
+public class CollectionDeserializer
+    extends ContainerDeserializerBase<Collection<Object>>
+    implements ResolvableDeserializer
+{
+    // // Configuration
+
+    protected final JavaType _collectionType;
+
+    /**
+     * Value deserializer.
+     */
+    protected final JsonDeserializer<Object> _valueDeserializer;
+
+    /**
+     * If element instances have polymorphic type information, this
+     * is the type deserializer that can handle it
+     */
+    protected final TypeDeserializer _valueTypeDeserializer;
+
+    // // Instance construction settings:
+    
+    /**
+     * @since 1.9
+     */
+    protected final ValueInstantiator _valueInstantiator;
+    
+    /**
+     * Deserializer that is used iff delegate-based creator is
+     * to be used for deserializing from JSON Object.
+     */
+    protected JsonDeserializer<Object> _delegateDeserializer;
+
+    // NOTE: no PropertyBasedCreator, as JSON Arrays have no properties
+
+    /*
+    /**********************************************************
+    /* Life-cycle
+    /**********************************************************
+     */
+    
+    /**
+     * @deprecated Since 1.9, use variant that takes ValueInstantiator
+     */
+    @Deprecated
+    protected CollectionDeserializer(JavaType collectionType, JsonDeserializer<Object> valueDeser,
+            TypeDeserializer valueTypeDeser,
+            Constructor<Collection<Object>> defCtor)
+    {
+        super(collectionType.getRawClass());
+        _collectionType = collectionType;
+        _valueDeserializer = valueDeser;
+        _valueTypeDeserializer = valueTypeDeser;
+        // not super-clean, but has to do...
+        StdValueInstantiator inst = new StdValueInstantiator(null, collectionType);
+        if (defCtor != null) {
+            AnnotatedConstructor aCtor = new AnnotatedConstructor(defCtor,
+                    null, null);
+            inst.configureFromObjectSettings(aCtor, null, null, null, null);
+        }
+        _valueInstantiator = inst;
+    }
+
+    /**
+     * @since 1.9
+     */
+    public CollectionDeserializer(JavaType collectionType, JsonDeserializer<Object> valueDeser,
+            TypeDeserializer valueTypeDeser, ValueInstantiator valueInstantiator)
+    {
+        super(collectionType.getRawClass());
+        _collectionType = collectionType;
+        _valueDeserializer = valueDeser;
+        _valueTypeDeserializer = valueTypeDeser;
+        _valueInstantiator = valueInstantiator;
+    }
+
+    /**
+     * 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 CollectionDeserializer(CollectionDeserializer src)
+    {
+        super(src._valueClass);
+        _collectionType = src._collectionType;
+        _valueDeserializer = src._valueDeserializer;
+        _valueTypeDeserializer = src._valueTypeDeserializer;
+        _valueInstantiator = src._valueInstantiator;
+        _delegateDeserializer = src._delegateDeserializer;
+    }
+
+    /*
+    /**********************************************************
+    /* Validation, post-processing (ResolvableDeserializer)
+    /**********************************************************
+     */
+
+    /**
+     * Method called to finalize setup of this deserializer,
+     * after deserializer itself has been registered. This
+     * is needed to handle recursive and transitive dependencies.
+     */
+    @Override
+    public void resolve(DeserializationConfig config, DeserializerProvider provider)
+        throws JsonMappingException
+    {
+        // May need to resolve types for delegate-based creators:
+        if (_valueInstantiator.canCreateUsingDelegate()) {
+            JavaType delegateType = _valueInstantiator.getDelegateType();
+            if (delegateType == null) {
+                throw new IllegalArgumentException("Invalid delegate-creator definition for "+_collectionType
+                        +": value instantiator ("+_valueInstantiator.getClass().getName()
+                        +") returned true for 'canCreateUsingDelegate()', but null for 'getDelegateType()'");
+            }
+            AnnotatedWithParams delegateCreator = _valueInstantiator.getDelegateCreator();
+            // Need to create a temporary property to allow contextual deserializers:
+            // Note: unlike BeanDeserializer, we don't have an AnnotatedClass around; hence no annotations passed
+            BeanProperty.Std property = new BeanProperty.Std(null,
+                    delegateType, null, delegateCreator);
+            _delegateDeserializer = findDeserializer(config, provider, delegateType, property);
+        }
+    }
+    
+    /*
+    /**********************************************************
+    /* ContainerDeserializerBase API
+    /**********************************************************
+     */
+
+    @Override
+    public JavaType getContentType() {
+        return _collectionType.getContentType();
+    }
+
+    @Override
+    public JsonDeserializer<Object> getContentDeserializer() {
+        return _valueDeserializer;
+    }
+    
+    /*
+    /**********************************************************
+    /* JsonDeserializer API
+    /**********************************************************
+     */
+    
+    @SuppressWarnings("unchecked")
+    @Override
+    public Collection<Object> deserialize(JsonParser jp, DeserializationContext ctxt)
+        throws IOException, JsonProcessingException
+    {
+        if (_delegateDeserializer != null) {
+            return (Collection<Object>) _valueInstantiator.createUsingDelegate(_delegateDeserializer.deserialize(jp, ctxt));
+        }
+        /* [JACKSON-620]: empty String may be ok; bit tricky to check, however, since
+         *  there is also possibility of "auto-wrapping" of single-element arrays.
+         *  Hence we only accept empty String here.
+         */
+        if (jp.getCurrentToken() == JsonToken.VALUE_STRING) {
+            String str = jp.getText();
+            if (str.length() == 0) {
+                return (Collection<Object>) _valueInstantiator.createFromString(str);
+            }
+        }
+        return deserialize(jp, ctxt, (Collection<Object>) _valueInstantiator.createUsingDefault());
+    }
+
+    @Override
+    public Collection<Object> deserialize(JsonParser jp, DeserializationContext ctxt,
+            Collection<Object> result)
+        throws IOException, JsonProcessingException
+    {
+        // Ok: must point to START_ARRAY (or equivalent)
+        if (!jp.isExpectedStartArrayToken()) {
+            return handleNonArray(jp, ctxt, result);
+        }
+
+        JsonDeserializer<Object> valueDes = _valueDeserializer;
+        JsonToken t;
+        final TypeDeserializer typeDeser = _valueTypeDeserializer;
+
+        while ((t = jp.nextToken()) != JsonToken.END_ARRAY) {
+            Object value;
+            
+            if (t == JsonToken.VALUE_NULL) {
+                value = null;
+            } else if (typeDeser == null) {
+                value = valueDes.deserialize(jp, ctxt);
+            } else {
+                value = valueDes.deserializeWithType(jp, ctxt, typeDeser);
+            }
+            result.add(value);
+        }
+        return result;
+    }
+
+    @Override
+    public Object deserializeWithType(JsonParser jp, DeserializationContext ctxt,
+            TypeDeserializer typeDeserializer)
+        throws IOException, JsonProcessingException
+    {
+        // In future could check current token... for now this should be enough:
+        return typeDeserializer.deserializeTypedFromArray(jp, ctxt);
+    }
+
+    /**
+     * Helper method called when current token is no START_ARRAY. Will either
+     * throw an exception, or try to handle value as if member of implicit
+     * array, depending on configuration.
+     */
+    private final Collection<Object> handleNonArray(JsonParser jp, DeserializationContext ctxt,
+            Collection<Object> result)
+        throws IOException, JsonProcessingException
+    {
+        // [JACKSON-526]: implicit arrays from single values?
+        if (!ctxt.isEnabled(DeserializationConfig.Feature.ACCEPT_SINGLE_VALUE_AS_ARRAY)) {
+            throw ctxt.mappingException(_collectionType.getRawClass());
+        }
+        JsonDeserializer<Object> valueDes = _valueDeserializer;
+        final TypeDeserializer typeDeser = _valueTypeDeserializer;
+        JsonToken t = jp.getCurrentToken();
+
+        Object value;
+        
+        if (t == JsonToken.VALUE_NULL) {
+            value = null;
+        } else if (typeDeser == null) {
+            value = valueDes.deserialize(jp, ctxt);
+        } else {
+            value = valueDes.deserializeWithType(jp, ctxt, typeDeser);
+        }
+        result.add(value);
+        return result;
+    }
+
+}