calabash-android 0.0.1

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

@@ -0,0 +1,152 @@
+package sh.calaba.org.codehaus.jackson.map.deser.impl;
+
+import java.io.IOException;
+import java.lang.annotation.Annotation;
+
+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.JsonDeserializer;
+import sh.calaba.org.codehaus.jackson.map.TypeDeserializer;
+import sh.calaba.org.codehaus.jackson.map.deser.SettableBeanProperty;
+import sh.calaba.org.codehaus.jackson.map.introspect.AnnotatedMember;
+import sh.calaba.org.codehaus.jackson.map.introspect.AnnotatedParameter;
+import sh.calaba.org.codehaus.jackson.map.util.Annotations;
+import sh.calaba.org.codehaus.jackson.type.JavaType;
+
+/**
+ * This concrete sub-class implements property that is passed
+ * via Creator (constructor or static factory method).
+ * It is not a full-featured implementation in that its set method
+ * should never be called -- instead, value must separately passed.
+ *<p>
+ * Note on injectable values (1.9): unlike with other mutators, where
+ * deserializer and injecting are separate, here we deal the two as related
+ * things. This is necessary to add proper priority, as well as to simplify
+ * coordination.
+ *<p>
+ * Note that this class was moved in Jackson 1.9
+ * from being a static sub-class of "sh.calaba.org.codehaus.jackson.map.deser.SettableBeanProperty"
+ * into separate class, to make it easier to use it for custom creators.
+ */
+public class CreatorProperty
+    extends SettableBeanProperty
+{
+    /**
+     * Placeholder that represents constructor parameter, when it is created
+     * from actual constructor.
+     * May be null when a synthetic instance is created.
+     */
+    protected final AnnotatedParameter _annotated;
+
+    /**
+     * Id of value to inject, if value injection should be used for this parameter
+     * (in addition to, or instead of, regular deserialization).
+     * 
+     * @since 1.9
+     */
+    protected final Object _injectableValueId;
+    
+    /**
+     * @param name Name of the logical property
+     * @param type Type of the property, used to find deserializer
+     * @param typeDeser Type deserializer to use for handling polymorphic type
+     *    information, if one is needed
+     * @param contextAnnotations Contextual annotations (usually by class that
+     *    declares creator [constructor, factory method] that includes
+     *    this property)
+     * @param param Representation of property, constructor or factory
+     *    method parameter; used for accessing annotations of the property
+     */
+    public CreatorProperty(String name, JavaType type, TypeDeserializer typeDeser,
+            Annotations contextAnnotations, AnnotatedParameter param,
+            int index, Object injectableValueId)
+    {
+        super(name, type, typeDeser, contextAnnotations);
+        _annotated = param;
+        _propertyIndex = index;
+        _injectableValueId = injectableValueId;
+    }
+
+    protected CreatorProperty(CreatorProperty src, JsonDeserializer<Object> deser) {
+        super(src, deser);
+        _annotated = src._annotated;
+        _injectableValueId = src._injectableValueId;
+    }
+    
+    @Override
+    public CreatorProperty withValueDeserializer(JsonDeserializer<Object> deser) {
+        return new CreatorProperty(this, deser);
+    }
+
+    /**
+     * Method that can be called to locate value to be injected for this
+     * property, if it is configured for this.
+     * 
+     * @since 1.9
+     */
+    public Object findInjectableValue(DeserializationContext context, Object beanInstance)
+    {
+        if (_injectableValueId == null) {
+            throw new IllegalStateException("Property '"+getName()
+                    +"' (type "+getClass().getName()+") has no injectable value id configured");
+        }
+        return context.findInjectableValue(_injectableValueId, this, beanInstance);
+    }
+    
+    /**
+     * Method to find value to inject, and inject it to this property.
+     * 
+     * @since 1.9
+     */
+    public void inject(DeserializationContext context, Object beanInstance)
+        throws IOException
+    {
+        set(beanInstance, findInjectableValue(context, beanInstance));
+    }
+    
+    /*
+    /**********************************************************
+    /* BeanProperty impl
+    /**********************************************************
+     */
+    
+    @Override
+    public <A extends Annotation> A getAnnotation(Class<A> acls) {
+        if (_annotated == null) {
+            return null;
+        }
+        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 void set(Object instance, Object value)
+        throws IOException
+    {
+        /* Hmmmh. Should we return quietly (NOP), or error?
+         * For now, let's just bail out without fuss.
+         */
+        //throw new IllegalStateException("Method should never be called on a "+getClass().getName());
+    }
+
+    @Override
+    public Object getInjectableValueId() {
+        return _injectableValueId;
+    }
+}

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

@@ -0,0 +1,173 @@
+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;
+
+/**
+ * Helper class that is used to flatten JSON structure when using
+ * "external type id" (see {@link sh.calaba.org.codehaus.jackson.annotate.JsonTypeInfo.As#EXTERNAL_PROPERTY}).
+ * This is needed to store temporary state and buffer tokens, as the structure is
+ * rearranged a bit so that actual type deserializer can resolve type and 
+ * finalize deserialization.
+ * 
+ * @since 1.9
+ */
+public class ExternalTypeHandler
+{
+    private final ExtTypedProperty[] _properties;
+    private final HashMap<String, Integer> _nameToPropertyIndex;
+
+    private final String[] _typeIds;
+    private final TokenBuffer[] _tokens;
+    
+    protected ExternalTypeHandler(ExtTypedProperty[] properties,
+            HashMap<String, Integer> nameToPropertyIndex,
+            String[] typeIds, TokenBuffer[] tokens)
+    {
+        _properties = properties;        
+        _nameToPropertyIndex = nameToPropertyIndex;
+        _typeIds = typeIds;
+        _tokens = tokens;
+    }
+
+    protected ExternalTypeHandler(ExternalTypeHandler h)
+    {
+        _properties = h._properties;
+        _nameToPropertyIndex = h._nameToPropertyIndex;
+        int len = _properties.length;
+        _typeIds = new String[len];
+        _tokens = new TokenBuffer[len];
+    }
+    
+    public ExternalTypeHandler start() {
+        return new ExternalTypeHandler(this);
+    }
+
+    /**
+     * Method called to ask handler to handle 
+     */
+    public boolean handleToken(JsonParser jp, DeserializationContext ctxt,
+            String propName, Object bean)
+        throws IOException, JsonProcessingException
+    {
+        Integer I = _nameToPropertyIndex.get(propName);
+        if (I == null) {
+            return false;
+        }
+        int index = I.intValue();
+        ExtTypedProperty prop = _properties[index];
+        boolean canDeserialize;
+        if (prop.hasTypePropertyName(propName)) {
+            _typeIds[index] = jp.getText();
+            jp.skipChildren();
+            canDeserialize = (bean != null) && (_tokens[index] != null);
+        } else {
+            TokenBuffer tokens = new TokenBuffer(jp.getCodec());
+            tokens.copyCurrentStructure(jp);
+            _tokens[index] = tokens;
+            canDeserialize = (bean != null) && (_typeIds[index] != null);
+        }
+        /* Minor optimization: let's deserialize properties as soon as
+         * we have all pertinent information:
+         */
+        if (canDeserialize) {
+            _deserialize(jp, ctxt, bean, index);
+            // clear stored data, to avoid deserializing+setting twice:
+            _typeIds[index] = null;
+            _tokens[index] = null;
+        }
+        return true;
+    }
+
+    public Object complete(JsonParser jp, DeserializationContext ctxt, Object bean)
+        throws IOException, JsonProcessingException
+    {
+        for (int i = 0, len = _properties.length; i < len; ++i) {
+            if (_typeIds[i] == null) {
+                // let's allow missing both type and property (may already have been set, too)
+                if (_tokens[i] == null) {
+                    continue;
+                }
+                // but not just one
+                throw ctxt.mappingException("Missing external type id property '"+_properties[i].getTypePropertyName());
+            } else if (_tokens[i] == null) {
+                SettableBeanProperty prop = _properties[i].getProperty();
+                throw ctxt.mappingException("Missing property '"+prop.getName()+"' for external type id '"+_properties[i].getTypePropertyName());
+            }
+            _deserialize(jp, ctxt, bean, i);
+        }
+        return bean;
+    }
+    
+    protected final void _deserialize(JsonParser jp, DeserializationContext ctxt, Object bean, int index)
+        throws IOException, JsonProcessingException
+    {
+        /* Ok: time to mix type id, value; and we will actually use "wrapper-array"
+         * style to ensure we can handle all kinds of JSON constructs.
+         */
+        TokenBuffer merged = new TokenBuffer(jp.getCodec());
+        merged.writeStartArray();
+        merged.writeString(_typeIds[index]);
+        JsonParser p2 = _tokens[index].asParser(jp);
+        p2.nextToken();
+        merged.copyCurrentStructure(p2);
+        merged.writeEndArray();
+        // needs to point to START_OBJECT (or whatever first token is)
+        p2 = merged.asParser(jp);
+        p2.nextToken();
+        _properties[index].getProperty().deserializeAndSet(p2, ctxt, bean);
+    }
+    
+    /*
+    /**********************************************************
+    /* Helper classes
+    /**********************************************************
+     */
+    
+    public static class Builder
+    {
+        private final ArrayList<ExtTypedProperty> _properties = new ArrayList<ExtTypedProperty>();
+        private final HashMap<String, Integer> _nameToPropertyIndex = new HashMap<String, Integer>();
+        
+        public void addExternal(SettableBeanProperty property, String extPropName)
+        {
+            Integer index = _properties.size();
+            _properties.add(new ExtTypedProperty(property, extPropName));
+            _nameToPropertyIndex.put(property.getName(), index);
+            _nameToPropertyIndex.put(extPropName, index);
+        }
+        
+        public ExternalTypeHandler build() {
+            return new ExternalTypeHandler(_properties.toArray(new ExtTypedProperty[_properties.size()]),
+                    _nameToPropertyIndex, null, null);
+        }
+    }
+
+    private final static class ExtTypedProperty
+    {
+        private final SettableBeanProperty _property;
+        private final String _typePropertyName;
+        
+        public ExtTypedProperty(SettableBeanProperty property, String typePropertyName)
+        {
+            _property = property;
+            _typePropertyName = typePropertyName;
+        }
+
+        public boolean hasTypePropertyName(String n) {
+            return n.equals(_typePropertyName);
+        }
+
+        public String getTypePropertyName() { return _typePropertyName; }
+        
+        public SettableBeanProperty getProperty() {
+            return _property;
+        }
+    }
+}

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

@@ -0,0 +1,117 @@
+package sh.calaba.org.codehaus.jackson.map.deser.impl;
+
+import java.io.IOException;
+import java.util.Collection;
+import java.util.HashMap;
+
+import sh.calaba.org.codehaus.jackson.JsonParser;
+import sh.calaba.org.codehaus.jackson.map.DeserializationContext;
+import sh.calaba.org.codehaus.jackson.map.JsonDeserializer;
+import sh.calaba.org.codehaus.jackson.map.deser.SettableBeanProperty;
+import sh.calaba.org.codehaus.jackson.map.deser.ValueInstantiator;
+import sh.calaba.org.codehaus.jackson.map.util.ClassUtil;
+
+/**
+ * Object that is used to collect arguments for non-default creator
+ * (non-default-constructor, or argument-taking factory method)
+ * before creator can be called.
+ * Since ordering of JSON properties is not guaranteed, this may
+ * require buffering of values other than ones being passed to
+ * creator.
+ */
+public final class PropertyBasedCreator
+{
+    protected final ValueInstantiator _valueInstantiator;
+    
+    /**
+     * Map that contains property objects for either constructor or factory
+     * method (whichever one is null: one property for each
+     * parameter for that one), keyed by logical property name
+     */
+    protected final HashMap<String, SettableBeanProperty> _properties;
+
+    /**
+     * If some property values must always have a non-null value (like
+     * primitive types do), this array contains such default values.
+     */
+    protected Object[]  _defaultValues;
+
+    /**
+     * Array that contains properties that expect value to inject, if any;
+     * null if no injectable values are expected.
+     * 
+     * @since 1.9
+     */
+    protected final SettableBeanProperty[] _propertiesWithInjectables;
+    
+    public PropertyBasedCreator(ValueInstantiator valueInstantiator)
+    {
+        _valueInstantiator = valueInstantiator;
+        _properties = new HashMap<String, SettableBeanProperty>();
+        // [JACKSON-372]: primitive types need extra care
+        Object[] defValues = null;
+        SettableBeanProperty[] creatorProps = valueInstantiator.getFromObjectArguments();
+        SettableBeanProperty[] propertiesWithInjectables = null;
+        for (int i = 0, len = creatorProps.length; i < len; ++i) {
+            SettableBeanProperty prop = creatorProps[i];
+            _properties.put(prop.getName(), prop);
+            if (prop.getType().isPrimitive()) {
+                if (defValues == null) {
+                    defValues = new Object[len];
+                }
+                defValues[i] = ClassUtil.defaultValue(prop.getType().getRawClass());
+            }
+            Object injectableValueId = prop.getInjectableValueId();
+            if (injectableValueId != null) {
+                if (propertiesWithInjectables == null) {
+                    propertiesWithInjectables = new SettableBeanProperty[len];
+                }
+                propertiesWithInjectables[i] = prop;
+            }
+        }
+        _defaultValues = defValues;
+        _propertiesWithInjectables = propertiesWithInjectables;        
+    }
+
+    public Collection<SettableBeanProperty> getCreatorProperties() {
+        return _properties.values();
+    }
+    
+    public SettableBeanProperty findCreatorProperty(String name) {
+        return _properties.get(name);
+    }
+
+    public void assignDeserializer(SettableBeanProperty prop, JsonDeserializer<Object> deser) {
+        prop = prop.withValueDeserializer(deser);
+        _properties.put(prop.getName(), prop);
+        Object nullValue = deser.getNullValue();
+        if (nullValue != null) {
+            if (_defaultValues == null) {
+                _defaultValues = new Object[_properties.size()];
+            }
+            _defaultValues[prop.getPropertyIndex()] = nullValue;
+        }
+    }
+    
+    /**
+     * Method called when starting to build a bean instance.
+     */
+    public PropertyValueBuffer startBuilding(JsonParser jp, DeserializationContext ctxt)
+    {
+        PropertyValueBuffer buffer = new PropertyValueBuffer(jp, ctxt, _properties.size());
+        if (_propertiesWithInjectables != null) {
+            buffer.inject(_propertiesWithInjectables);
+        }
+        return buffer;
+    }
+    
+    public Object build(PropertyValueBuffer buffer) throws IOException
+    {
+        Object bean = _valueInstantiator.createFromObjectWith(buffer.getParameters(_defaultValues));
+        // Anything buffered?
+        for (PropertyValue pv = buffer.buffered(); pv != null; pv = pv.next) {
+            pv.assign(bean);
+        }
+        return bean;
+    }
+}

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

@@ -0,0 +1,117 @@
+package sh.calaba.org.codehaus.jackson.map.deser.impl;
+
+import java.io.IOException;
+
+import sh.calaba.org.codehaus.jackson.JsonProcessingException;
+import sh.calaba.org.codehaus.jackson.map.deser.SettableAnyProperty;
+import sh.calaba.org.codehaus.jackson.map.deser.SettableBeanProperty;
+
+/**
+ * Base class for property values that need to be buffered during
+ * deserialization.
+ */
+public abstract class PropertyValue
+{
+    public final PropertyValue next;
+
+    /**
+     * Value to assign when POJO has been instantiated.
+     */
+    public final Object value;
+    
+    protected PropertyValue(PropertyValue next, Object value)
+    {
+        this.next = next;
+        this.value = value;
+    }
+
+    /**
+     * Method called to assign stored value of this property to specified
+     * bean instance
+     */
+    public abstract void assign(Object bean)
+        throws IOException, JsonProcessingException;
+
+    /*
+    /**********************************************************
+    /* Concrete property value classes
+    /**********************************************************
+     */
+
+    /**
+     * Property value that used when assigning value to property using
+     * a setter method or direct field access.
+     */
+    final static class Regular
+        extends PropertyValue
+    {
+        final SettableBeanProperty _property;
+        
+        public Regular(PropertyValue next, Object value,
+                       SettableBeanProperty prop)
+        {
+            super(next, value);
+            _property = prop;
+        }
+
+        @Override
+        public void assign(Object bean)
+            throws IOException, JsonProcessingException
+        {
+            _property.set(bean, value);
+        }
+    }
+    
+    /**
+     * Property value type used when storing entries to be added
+     * to a POJO using "any setter" (method that takes name and
+     * value arguments, allowing setting multiple different
+     * properties using single method).
+     */
+    final static class Any
+        extends PropertyValue
+    {
+        final SettableAnyProperty _property;
+        final String _propertyName;
+        
+        public Any(PropertyValue next, Object value,
+                   SettableAnyProperty prop,
+                   String propName)
+        {
+            super(next, value);
+            _property = prop;
+            _propertyName = propName;
+        }
+
+        @Override
+        public void assign(Object bean)
+            throws IOException, JsonProcessingException
+        {
+            _property.set(bean, _propertyName, value);
+        }
+    }
+
+    /**
+     * Property value type used when storing entries to be added
+     * to a Map.
+     */
+    final static class Map
+        extends PropertyValue
+    {
+        final Object _key;
+        
+        public Map(PropertyValue next, Object value, Object key)
+        {
+            super(next, value);
+            _key = key;
+        }
+
+        @SuppressWarnings("unchecked") 
+        @Override
+        public void assign(Object bean)
+            throws IOException, JsonProcessingException
+        {
+            ((java.util.Map<Object,Object>) bean).put(_key, value);
+        }
+    }
+}