calabash-android 0.4.7.pre6 → 0.4.7.pre7

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

@@ -0,0 +1,37 @@
+package sh.calaba.org.codehaus.jackson.map.jsontype.impl;
+
+import sh.calaba.org.codehaus.jackson.annotate.JsonTypeInfo.As;
+import sh.calaba.org.codehaus.jackson.map.BeanProperty;
+import sh.calaba.org.codehaus.jackson.map.jsontype.TypeIdResolver;
+import sh.calaba.org.codehaus.jackson.type.JavaType;
+
+/**
+ * Type deserializer used with {@link As#EXTERNAL_PROPERTY} inclusion mechanism.
+ * Actual implementation may look bit strange since it depends on comprehensive
+ * pre-processing done by {@link sh.calaba.org.codehaus.jackson.map.deser.BeanDeserializer}
+ * to basically transform external type id into structure that looks more like
+ * "wrapper-array" style inclusion. This intermediate form is chosen to allow
+ * supporting all possible JSON structures.
+ * 
+ * @since 1.9
+ */
+public class AsExternalTypeDeserializer extends AsArrayTypeDeserializer
+{
+    protected final String _typePropertyName;
+    
+    public AsExternalTypeDeserializer(JavaType bt, TypeIdResolver idRes, BeanProperty property,
+            Class<?> defaultImpl,
+            String typePropName)
+    {
+        super(bt, idRes, property, defaultImpl);
+        _typePropertyName = typePropName;
+    }
+
+    @Override
+    public As getTypeInclusion() {
+        return As.EXTERNAL_PROPERTY;
+    }
+
+    @Override
+    public String getPropertyName() { return _typePropertyName; }
+}

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

@@ -0,0 +1,129 @@
+package sh.calaba.org.codehaus.jackson.map.jsontype.impl;
+
+import java.io.IOException;
+
+import sh.calaba.org.codehaus.jackson.JsonGenerator;
+import sh.calaba.org.codehaus.jackson.JsonProcessingException;
+import sh.calaba.org.codehaus.jackson.annotate.JsonTypeInfo.As;
+import sh.calaba.org.codehaus.jackson.map.BeanProperty;
+import sh.calaba.org.codehaus.jackson.map.jsontype.TypeIdResolver;
+
+/**
+ * Type serializer that preferably embeds type information as an "external"
+ * type property; embedded in enclosing JSON object.
+ * Note that this serializer should only be used when value is being output
+ * at JSON Object context; otherwise it can not work reliably, and will have
+ * to revert operation similar to {@link AsPropertyTypeSerializer}.
+ *<p>
+ * Note that implementation of serialization is bit cumbersome as we must
+ * serialized external type id AFTER object; this because callback only
+ * occurs after field name has been written.
+ * 
+ * @since 1.9
+ */
+public class AsExternalTypeSerializer
+   extends TypeSerializerBase
+{
+   protected final String _typePropertyName;
+
+   public AsExternalTypeSerializer(TypeIdResolver idRes, BeanProperty property,
+           String propName)
+   {
+       super(idRes, property);
+       _typePropertyName = propName;
+   }
+
+   @Override
+   public String getPropertyName() { return _typePropertyName; }
+
+   @Override
+   public As getTypeInclusion() { return As.EXTERNAL_PROPERTY; }
+   
+   @Override
+   public void writeTypePrefixForObject(Object value, JsonGenerator jgen)
+       throws IOException, JsonProcessingException
+   {
+       _writePrefix(value, jgen);
+   }
+
+   @Override
+   public void writeTypePrefixForObject(Object value, JsonGenerator jgen, Class<?> type)
+       throws IOException, JsonProcessingException
+   {
+       _writePrefix(value, jgen, type);
+   }
+   
+   @Override
+   public void writeTypePrefixForArray(Object value, JsonGenerator jgen)
+       throws IOException, JsonProcessingException
+   {
+       _writePrefix(value, jgen);
+   }
+
+   @Override
+   public void writeTypePrefixForArray(Object value, JsonGenerator jgen, Class<?> type)
+           throws IOException, JsonProcessingException
+   {
+       _writePrefix(value, jgen, type);
+   }
+
+   @Override
+   public void writeTypePrefixForScalar(Object value, JsonGenerator jgen)
+           throws IOException, JsonProcessingException
+   {
+       _writePrefix(value, jgen);
+   }
+
+   @Override
+   public void writeTypePrefixForScalar(Object value, JsonGenerator jgen, Class<?> type)
+           throws IOException, JsonProcessingException
+   {
+       _writePrefix(value, jgen, type);
+   }
+
+   @Override
+   public void writeTypeSuffixForObject(Object value, JsonGenerator jgen)
+       throws IOException, JsonProcessingException
+   {
+       _writeSuffix(value, jgen);
+   }
+
+   @Override
+   public void writeTypeSuffixForArray(Object value, JsonGenerator jgen)
+       throws IOException, JsonProcessingException
+   {
+       _writeSuffix(value, jgen);
+   }
+   
+   @Override
+   public void writeTypeSuffixForScalar(Object value, JsonGenerator jgen)
+       throws IOException, JsonProcessingException
+   {
+       _writeSuffix(value, jgen);
+   }
+
+   /*
+   /**********************************************************
+   /* Helper methods
+   /**********************************************************
+    */
+   
+   protected final void _writePrefix(Object value, JsonGenerator jgen)
+       throws IOException, JsonProcessingException
+   {
+       jgen.writeStartObject();
+   }
+
+   protected final void _writePrefix(Object value, JsonGenerator jgen, Class<?> type)
+       throws IOException, JsonProcessingException
+   {
+       jgen.writeStartObject();
+   }
+   
+   protected final void _writeSuffix(Object value, JsonGenerator jgen)
+       throws IOException, JsonProcessingException
+   {
+       jgen.writeEndObject();
+       jgen.writeStringField(_typePropertyName, _idResolver.idFromValue(value));
+   }
+}

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

@@ -0,0 +1,191 @@
+package sh.calaba.org.codehaus.jackson.map.jsontype.impl;
+
+import java.io.IOException;
+
+import sh.calaba.org.codehaus.jackson.*;
+import sh.calaba.org.codehaus.jackson.annotate.JsonTypeInfo.As;
+import sh.calaba.org.codehaus.jackson.map.*;
+import sh.calaba.org.codehaus.jackson.map.jsontype.TypeIdResolver;
+import sh.calaba.org.codehaus.jackson.type.JavaType;
+import sh.calaba.org.codehaus.jackson.util.JsonParserSequence;
+import sh.calaba.org.codehaus.jackson.util.TokenBuffer;
+
+/**
+ * Type deserializer used with {@link As#PROPERTY}
+ * inclusion mechanism.
+ * Uses regular form (additional key/value entry before actual data)
+ * when typed object is expressed as JSON Object; otherwise behaves similar to how
+ * {@link As#WRAPPER_ARRAY} works.
+ * Latter is used if JSON representation is polymorphic
+ * 
+ * @since 1.5
+ * @author tatu
+ */
+public class AsPropertyTypeDeserializer extends AsArrayTypeDeserializer
+{
+    protected final String _typePropertyName;
+
+    @Deprecated // since 1.9
+    public AsPropertyTypeDeserializer(JavaType bt, TypeIdResolver idRes, BeanProperty property,
+            String typePropName) {
+        this(bt, idRes, property, null, typePropName);
+    }
+    
+    public AsPropertyTypeDeserializer(JavaType bt, TypeIdResolver idRes, BeanProperty property,
+            Class<?> defaultImpl,
+            String typePropName)
+    {
+        super(bt, idRes, property, defaultImpl);
+        _typePropertyName = typePropName;
+    }
+
+    @Override
+    public As getTypeInclusion() {
+        return As.PROPERTY;
+    }
+
+    @Override
+    public String getPropertyName() { return _typePropertyName; }
+
+    /**
+     * This is the trickiest thing to handle, since property we are looking
+     * for may be anywhere...
+     */
+    @Override
+    public Object deserializeTypedFromObject(JsonParser jp, DeserializationContext ctxt)
+        throws IOException, JsonProcessingException
+    {
+        // but first, sanity check to ensure we have START_OBJECT or FIELD_NAME
+        JsonToken t = jp.getCurrentToken();
+        if (t == JsonToken.START_OBJECT) {
+            t = jp.nextToken();
+        } else if (t == JsonToken.START_ARRAY) {
+            /* This is most likely due to the fact that not all Java types are
+             * serialized as JSON Objects; so if "as-property" inclusion is requested,
+             * serialization of things like Lists must be instead handled as if
+             * "as-wrapper-array" was requested.
+             * But this can also be due to some custom handling: so, if "defaultImpl"
+             * is defined, it will be asked to handle this case.
+             */
+            return _deserializeTypedUsingDefaultImpl(jp, ctxt, null);
+        } else if (t != JsonToken.FIELD_NAME) {
+            return _deserializeTypedUsingDefaultImpl(jp, ctxt, null);
+        }
+        // Ok, let's try to find the property. But first, need token buffer...
+        TokenBuffer tb = null;
+
+        for (; t == JsonToken.FIELD_NAME; t = jp.nextToken()) {
+            String name = jp.getCurrentName();
+            jp.nextToken(); // to point to the value
+            if (_typePropertyName.equals(name)) { // gotcha!
+                String typeId = jp.getText();
+                JsonDeserializer<Object> deser = _findDeserializer(ctxt, typeId);
+                // deserializer should take care of closing END_OBJECT as well
+               if (tb != null) {
+                    jp = JsonParserSequence.createFlattened(tb.asParser(jp), jp);
+                }
+                /* Must point to the next value; tb had no current, jp
+                 * pointed to VALUE_STRING:
+                 */
+                jp.nextToken(); // to skip past String value
+                // deserializer should take care of closing END_OBJECT as well
+                return deser.deserialize(jp, ctxt);
+            }
+            if (tb == null) {
+                tb = new TokenBuffer(null);
+            }
+            tb.writeFieldName(name);
+            tb.copyCurrentStructure(jp);
+        }
+        return _deserializeTypedUsingDefaultImpl(jp, ctxt, tb);
+    }
+    
+    // off-lined to keep main method lean and mean...
+    protected Object _deserializeTypedUsingDefaultImpl(JsonParser jp,
+            DeserializationContext ctxt, TokenBuffer tb)
+        throws IOException, JsonProcessingException
+    {
+        // As per [JACKSON-614], may have default implementation to use
+        if (_defaultImpl != null) { 
+            JsonDeserializer<Object> deser = _findDefaultImplDeserializer(ctxt);
+            if (tb != null) {
+                tb.writeEndObject();
+                jp = tb.asParser(jp);
+                // must move to point to the first token:
+                jp.nextToken();
+            }
+            return deser.deserialize(jp, ctxt);
+        }
+        // or, perhaps we just bumped into a "natural" value (boolean/int/double/String)?
+        Object result = _deserializeIfNatural(jp, ctxt);
+        if (result != null) {
+            return result;
+        }
+        // or, something for which "as-property" won't work, changed into "wrapper-array" type:
+        if (jp.getCurrentToken() == JsonToken.START_ARRAY) {
+            return super.deserializeTypedFromAny(jp, ctxt);
+        }
+        throw ctxt.wrongTokenException(jp, JsonToken.FIELD_NAME,
+                "missing property '"+_typePropertyName+"' that is to contain type id  (for class "+baseTypeName()+")");
+    }
+
+    /* As per [JACKSON-352], also need to re-route "unknown" version. Need to think
+     * this through bit more in future, but for now this does address issue and has
+     * no negative side effects (at least within existing unit test suite).
+     */
+    @Override
+    public Object deserializeTypedFromAny(JsonParser jp, DeserializationContext ctxt)
+        throws IOException, JsonProcessingException
+    {
+        /* [JACKSON-387]: Sometimes, however, we get an array wrapper; specifically
+         *   when an array or list has been serialized with type information.
+         */
+        if (jp.getCurrentToken() == JsonToken.START_ARRAY) {
+            return super.deserializeTypedFromArray(jp, ctxt);
+        }
+        return deserializeTypedFromObject(jp, ctxt);
+    }    
+    
+    // These are fine from base class:
+    //public Object deserializeTypedFromArray(JsonParser jp, DeserializationContext ctxt)
+    //public Object deserializeTypedFromScalar(JsonParser jp, DeserializationContext ctxt)    
+
+    /**
+     * Helper method used to check if given parser might be pointing to
+     * a "natural" value, and one that would be acceptable as the
+     * result value (compatible with declared base type)
+     */
+    protected Object _deserializeIfNatural(JsonParser jp, DeserializationContext ctxt)
+        throws IOException, JsonProcessingException
+    {
+        switch (jp.getCurrentToken()) {
+        case VALUE_STRING:
+            if (_baseType.getRawClass().isAssignableFrom(String.class)) {
+                return jp.getText();
+            }
+            break;
+        case VALUE_NUMBER_INT:
+            if (_baseType.getRawClass().isAssignableFrom(Integer.class)) {
+                return jp.getIntValue();
+            }
+            break;
+
+        case VALUE_NUMBER_FLOAT:
+            if (_baseType.getRawClass().isAssignableFrom(Double.class)) {
+                return Double.valueOf(jp.getDoubleValue());
+            }
+            break;
+        case VALUE_TRUE:
+            if (_baseType.getRawClass().isAssignableFrom(Boolean.class)) {
+                return Boolean.TRUE;
+            }
+            break;
+        case VALUE_FALSE:
+            if (_baseType.getRawClass().isAssignableFrom(Boolean.class)) {
+                return Boolean.FALSE;
+            }
+            break;
+        }
+        return null;
+    }
+}

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

@@ -0,0 +1,69 @@
+package sh.calaba.org.codehaus.jackson.map.jsontype.impl;
+
+import java.io.IOException;
+
+import sh.calaba.org.codehaus.jackson.JsonGenerator;
+import sh.calaba.org.codehaus.jackson.JsonProcessingException;
+import sh.calaba.org.codehaus.jackson.annotate.JsonTypeInfo.As;
+import sh.calaba.org.codehaus.jackson.map.BeanProperty;
+import sh.calaba.org.codehaus.jackson.map.jsontype.TypeIdResolver;
+
+/**
+ * Type serializer that preferably embeds type information as an additional
+ * JSON Object property, if possible (when resulting serialization would
+ * use JSON Object). If this is not possible (for JSON Arrays, scalars),
+ * uses a JSON Array wrapper (similar to how
+ * {@link As#WRAPPER_ARRAY} always works) as a fallback.
+ * 
+ * @since 1.5
+ * @author tatus
+ */
+public class AsPropertyTypeSerializer
+    extends AsArrayTypeSerializer
+{
+    protected final String _typePropertyName;
+
+    public AsPropertyTypeSerializer(TypeIdResolver idRes, BeanProperty property,
+            String propName)
+    {
+        super(idRes, property);
+        _typePropertyName = propName;
+    }
+
+    @Override
+    public String getPropertyName() { return _typePropertyName; }
+
+    @Override
+    public As getTypeInclusion() { return As.PROPERTY; }
+    
+    @Override
+    public void writeTypePrefixForObject(Object value, JsonGenerator jgen)
+        throws IOException, JsonProcessingException
+    {
+        jgen.writeStartObject();
+        jgen.writeStringField(_typePropertyName, _idResolver.idFromValue(value));
+    }
+
+    @Override
+    public void writeTypePrefixForObject(Object value, JsonGenerator jgen, Class<?> type)
+        throws IOException, JsonProcessingException
+    {
+        jgen.writeStartObject();
+        jgen.writeStringField(_typePropertyName, _idResolver.idFromValueAndType(value, type));
+    }
+    
+    //public void writeTypePrefixForArray(Object value, JsonGenerator jgen)
+    //public void writeTypePrefixForArray(Object value, JsonGenerator jgen, Class<?> type)
+    //public void writeTypePrefixForScalar(Object value, JsonGenerator jgen)
+    //public void writeTypePrefixForScalar(Object value, JsonGenerator jgen, Class<?> type)
+
+    @Override
+    public void writeTypeSuffixForObject(Object value, JsonGenerator jgen)
+        throws IOException, JsonProcessingException
+    {
+        jgen.writeEndObject();
+    }
+
+    //public void writeTypeSuffixForArray(Object value, JsonGenerator jgen)
+    //public void writeTypeSuffixForScalar(Object value, JsonGenerator jgen)
+}

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

@@ -0,0 +1,103 @@
+package sh.calaba.org.codehaus.jackson.map.jsontype.impl;
+
+import java.io.IOException;
+
+import sh.calaba.org.codehaus.jackson.*;
+import sh.calaba.org.codehaus.jackson.annotate.JsonTypeInfo.As;
+import sh.calaba.org.codehaus.jackson.map.*;
+import sh.calaba.org.codehaus.jackson.map.jsontype.TypeIdResolver;
+import sh.calaba.org.codehaus.jackson.type.JavaType;
+
+/**
+ * Type deserializer used with {@link As#WRAPPER_OBJECT}
+ * inclusion mechanism. Simple since JSON structure used is always
+ * the same, regardless of structure used for actual value: wrapping
+ * is done using a single-element JSON Object where type id is the key,
+ * and actual object data as the value.
+ * 
+ * @author tatus
+ */
+public class AsWrapperTypeDeserializer extends TypeDeserializerBase
+{
+    @Deprecated // since 1.9
+    public AsWrapperTypeDeserializer(JavaType bt, TypeIdResolver idRes, BeanProperty property) {
+        this(bt, idRes, property, null);
+    }
+
+    public AsWrapperTypeDeserializer(JavaType bt, TypeIdResolver idRes, BeanProperty property,
+            Class<?> defaultImpl)
+    {
+        super(bt, idRes, property, null);
+    }
+
+    @Override
+    public As getTypeInclusion() {
+        return As.WRAPPER_OBJECT;
+    }
+
+    /**
+     * Deserializing type id enclosed using WRAPPER_OBJECT style is straightforward
+     */
+    @Override
+    public Object deserializeTypedFromObject(JsonParser jp, DeserializationContext ctxt)
+        throws IOException, JsonProcessingException
+    {
+        return _deserialize(jp, ctxt);
+    }    
+
+    @Override
+    public Object deserializeTypedFromArray(JsonParser jp, DeserializationContext ctxt)
+        throws IOException, JsonProcessingException
+    {
+        return _deserialize(jp, ctxt);
+    }
+
+    @Override
+    public Object deserializeTypedFromScalar(JsonParser jp, DeserializationContext ctxt)
+        throws IOException, JsonProcessingException
+    {
+        return _deserialize(jp, ctxt);
+    }
+
+    @Override
+    public Object deserializeTypedFromAny(JsonParser jp, DeserializationContext ctxt)
+        throws IOException, JsonProcessingException
+    {
+        return _deserialize(jp, ctxt);
+    }
+    
+    /*
+    /***************************************************************
+    /* Internal methods
+    /***************************************************************
+     */
+
+    /**
+     * Method that handles type information wrapper, locates actual
+     * subtype deserializer to use, and calls it to do actual
+     * deserialization.
+     */
+    private final Object _deserialize(JsonParser jp, DeserializationContext ctxt)
+        throws IOException, JsonProcessingException
+    {
+        // first, sanity checks
+        if (jp.getCurrentToken() != JsonToken.START_OBJECT) {
+            throw ctxt.wrongTokenException(jp, JsonToken.START_OBJECT,
+                    "need JSON Object to contain As.WRAPPER_OBJECT type information for class "+baseTypeName());
+        }
+        // should always get field name, but just in case...
+        if (jp.nextToken() != JsonToken.FIELD_NAME) {
+            throw ctxt.wrongTokenException(jp, JsonToken.FIELD_NAME,
+                    "need JSON String that contains type id (for subtype of "+baseTypeName()+")");
+        }
+        JsonDeserializer<Object> deser = _findDeserializer(ctxt, jp.getText());
+        jp.nextToken();
+        Object value = deser.deserialize(jp, ctxt);
+        // And then need the closing END_OBJECT
+        if (jp.nextToken() != JsonToken.END_OBJECT) {
+            throw ctxt.wrongTokenException(jp, JsonToken.END_OBJECT,
+                    "expected closing END_OBJECT after type information and deserialized value");
+        }
+        return value;
+    }
+}