calabash-android 0.0.1

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

@@ -0,0 +1,31 @@
+package sh.calaba.org.codehaus.jackson.map.jsontype.impl;
+
+import sh.calaba.org.codehaus.jackson.annotate.JsonTypeInfo;
+import sh.calaba.org.codehaus.jackson.map.BeanProperty;
+import sh.calaba.org.codehaus.jackson.map.TypeSerializer;
+import sh.calaba.org.codehaus.jackson.map.jsontype.TypeIdResolver;
+
+/**
+ * @since 1.5
+ */
+public abstract class TypeSerializerBase extends TypeSerializer
+{
+    protected final TypeIdResolver _idResolver;
+
+    protected final BeanProperty _property;
+    
+    protected TypeSerializerBase(TypeIdResolver idRes, BeanProperty property)
+    {
+        _idResolver = idRes;
+        _property = property;
+    }
+
+    @Override
+    public abstract JsonTypeInfo.As getTypeInclusion();
+
+    @Override
+    public String getPropertyName() { return null; }
+    
+    @Override
+    public TypeIdResolver getTypeIdResolver() { return _idResolver; }
+}

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

@@ -0,0 +1,9 @@
+/**
+ * Package that contains standard implementations for
+ * {@link sh.calaba.org.codehaus.jackson.map.jsontype.TypeResolverBuilder}
+ * and
+ * {@link sh.calaba.org.codehaus.jackson.map.jsontype.TypeIdResolver}.
+ *
+ * @since 1.5
+ */
+package sh.calaba.org.codehaus.jackson.map.jsontype.impl;

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

@@ -0,0 +1,10 @@
+/**
+ * Package that contains interfaces that define how to implement
+ * functionality for dynamically resolving type during deserialization.
+ * This is needed for complete handling of polymorphic types, where
+ * actual type can not be determined statically (declared type is
+ * a supertype of actual polymorphic serialized types).
+ *
+ * @since 1.5
+ */
+package sh.calaba.org.codehaus.jackson.map.jsontype;

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

@@ -0,0 +1,86 @@
+package sh.calaba.org.codehaus.jackson.map.module;
+
+import java.lang.reflect.Modifier;
+import java.util.*;
+
+import sh.calaba.org.codehaus.jackson.map.AbstractTypeResolver;
+import sh.calaba.org.codehaus.jackson.map.DeserializationConfig;
+import sh.calaba.org.codehaus.jackson.map.type.ClassKey;
+import sh.calaba.org.codehaus.jackson.type.JavaType;
+
+/**
+ * Simple {@link AbstractTypeResolver} implementation, which is
+ * based on static mapping from abstract super types into
+ * sub types (concrete or abstract), but retaining generic
+ * parameterization.
+ * Can be used for things like specifying which implementation of
+ * {@link java.util.Collection} to use:
+ *<pre>
+ *  SimpleAbstractTypeResolver resolver = new SimpleAbstractTypeResolver();
+ *  // To make all properties declared as Collection, List, to LinkedList
+ *  resolver.addMapping(Collection.class, LinkedList.class);
+ *  resolver.addMapping(List.class, LinkedList.class);
+ *</pre>
+ * Can also be used as an alternative to per-class annotations when defining
+ * concrete implementations; however, only works with abstract types (since
+ * this is only called for abstract types)
+ *
+ * @since 1.8
+ */
+public class SimpleAbstractTypeResolver extends AbstractTypeResolver
+{
+    /**
+     * Mappings from super types to subtypes
+     */
+    protected final HashMap<ClassKey,Class<?>> _mappings = new HashMap<ClassKey,Class<?>>();
+
+    /**
+     * Method for adding a mapping from super type to specific subtype.
+     * Arguments will be checked by method, to ensure that <code>superType</code>
+     * is abstract (since resolver is never called for concrete classes);
+     * as well as to ensure that there is supertype/subtype relationship
+     * (to ensure there won't be cycles during resolution).
+     * 
+     * @param superType Abstract type to resolve
+     * @param subType Sub-class of superType, to map superTo to
+     * 
+     * @return This resolver, to allow chaining of initializations
+     */
+    public <T> SimpleAbstractTypeResolver addMapping(Class<T> superType, Class<? extends T> subType)
+    {
+        // Sanity checks, just in case someone tries to force typing...
+        if (superType == subType) {
+            throw new IllegalArgumentException("Can not add mapping from class to itself");
+        }
+        if (!superType.isAssignableFrom(subType)) {
+            throw new IllegalArgumentException("Can not add mapping from class "+superType.getName()
+                    +" to "+subType.getName()+", as latter is not a subtype of former");
+        }
+        if (!Modifier.isAbstract(superType.getModifiers())) {
+            throw new IllegalArgumentException("Can not add mapping from class "+superType.getName()
+                    +" since it is not abstract");
+        }
+        _mappings.put(new ClassKey(superType), subType);
+        return this;
+    }
+
+    @Override
+    public JavaType findTypeMapping(DeserializationConfig config, JavaType type)
+    {
+        // this is the main mapping base, so let's 
+        Class<?> src = type.getRawClass();
+        Class<?> dst = _mappings.get(new ClassKey(src));
+        if (dst == null) {
+            return null;
+        }
+        return type.narrowBy(dst);
+    }
+
+    
+    @Override
+    public JavaType resolveAbstractType(DeserializationConfig config, JavaType type)
+    {
+        // never materialize anything, so:
+        return null;
+    }
+}

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

@@ -0,0 +1,130 @@
+package sh.calaba.org.codehaus.jackson.map.module;
+
+import java.util.*;
+
+import sh.calaba.org.codehaus.jackson.JsonNode;
+import sh.calaba.org.codehaus.jackson.map.*;
+import sh.calaba.org.codehaus.jackson.map.type.*;
+import sh.calaba.org.codehaus.jackson.type.JavaType;
+
+/**
+ * Simple implementation {@link Deserializers} which allows registration of
+ * deserializers based on raw (type erased class).
+ * It can work well for basic bean and scalar type deserializers, but is not
+ * a good fit for handling generic types (like {@link Map}s and {@link Collection}s
+ * or array types).
+ *<p>
+ * Unlike {@link SimpleSerializers}, this class does not currently support generic mappings;
+ * all mappings must be to exact declared deserialization type.
+ * 
+ * @since 1.7
+ */
+public class SimpleDeserializers implements Deserializers
+{
+    protected HashMap<ClassKey,JsonDeserializer<?>> _classMappings = null;
+
+    /*
+    /**********************************************************
+    /* Life-cycle, construction and configuring
+    /**********************************************************
+     */
+    
+    public SimpleDeserializers() { }
+
+    public <T> void addDeserializer(Class<T> forClass, JsonDeserializer<? extends T> deser)
+    {
+        ClassKey key = new ClassKey(forClass);
+        if (_classMappings == null) {
+            _classMappings = new HashMap<ClassKey,JsonDeserializer<?>>();
+        }
+        _classMappings.put(key, deser);
+    }
+    
+    /*
+    /**********************************************************
+    /* Serializers implementation
+    /**********************************************************
+     */
+    
+    @Override
+    public JsonDeserializer<?> findArrayDeserializer(ArrayType type,
+            DeserializationConfig config, DeserializerProvider provider,
+            BeanProperty property,
+            TypeDeserializer elementTypeDeserializer,
+            JsonDeserializer<?> elementDeserializer)
+        throws JsonMappingException
+    {
+        return (_classMappings == null) ? null : _classMappings.get(new ClassKey(type.getRawClass()));
+    }
+
+    @Override
+    public JsonDeserializer<?> findBeanDeserializer(JavaType type,
+            DeserializationConfig config, DeserializerProvider provider,
+            BeanDescription beanDesc, BeanProperty property)
+        throws JsonMappingException
+    {
+        return (_classMappings == null) ? null : _classMappings.get(new ClassKey(type.getRawClass()));
+    }
+
+    @Override
+    public JsonDeserializer<?> findCollectionDeserializer(CollectionType type,
+            DeserializationConfig config, DeserializerProvider provider,
+            BeanDescription beanDesc, BeanProperty property,
+            TypeDeserializer elementTypeDeserializer,
+            JsonDeserializer<?> elementDeserializer)
+        throws JsonMappingException
+    {
+        return (_classMappings == null) ? null : _classMappings.get(new ClassKey(type.getRawClass()));
+    }
+
+    @Override
+    public JsonDeserializer<?> findCollectionLikeDeserializer(CollectionLikeType type,
+            DeserializationConfig config, DeserializerProvider provider,
+            BeanDescription beanDesc, BeanProperty property,
+            TypeDeserializer elementTypeDeserializer,
+            JsonDeserializer<?> elementDeserializer)
+        throws JsonMappingException
+    {
+        return (_classMappings == null) ? null : _classMappings.get(new ClassKey(type.getRawClass()));
+    }
+    
+    @Override
+    public JsonDeserializer<?> findEnumDeserializer(Class<?> type,
+            DeserializationConfig config, BeanDescription beanDesc, BeanProperty property)
+        throws JsonMappingException
+    {
+        return (_classMappings == null) ? null : _classMappings.get(new ClassKey(type));
+    }
+
+    @Override
+    public JsonDeserializer<?> findMapDeserializer(MapType type,
+            DeserializationConfig config, DeserializerProvider provider,
+            BeanDescription beanDesc, BeanProperty property,
+            KeyDeserializer keyDeserializer,
+            TypeDeserializer elementTypeDeserializer,
+            JsonDeserializer<?> elementDeserializer)
+        throws JsonMappingException
+    {
+        return (_classMappings == null) ? null : _classMappings.get(new ClassKey(type.getRawClass()));
+    }
+
+    @Override
+    public JsonDeserializer<?> findMapLikeDeserializer(MapLikeType type,
+            DeserializationConfig config, DeserializerProvider provider,
+            BeanDescription beanDesc, BeanProperty property,
+            KeyDeserializer keyDeserializer,
+            TypeDeserializer elementTypeDeserializer,
+            JsonDeserializer<?> elementDeserializer)
+        throws JsonMappingException
+    {
+        return (_classMappings == null) ? null : _classMappings.get(new ClassKey(type.getRawClass()));
+    }
+    
+    @Override
+    public JsonDeserializer<?> findTreeNodeDeserializer(Class<? extends JsonNode> nodeType,
+            DeserializationConfig config, BeanProperty property)
+        throws JsonMappingException
+    {
+        return (_classMappings == null) ? null : _classMappings.get(new ClassKey(nodeType));
+    }
+}

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

@@ -0,0 +1,59 @@
+package sh.calaba.org.codehaus.jackson.map.module;
+
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+
+import sh.calaba.org.codehaus.jackson.map.*;
+import sh.calaba.org.codehaus.jackson.map.type.ClassKey;
+import sh.calaba.org.codehaus.jackson.type.JavaType;
+
+/**
+ * Simple implementation {@link KeyDeserializers} which allows registration of
+ * deserializers based on raw (type erased class).
+ * It can work well for basic bean and scalar type deserializers, but is not
+ * a good fit for handling generic types (like {@link Map}s and {@link Collection}s
+ * or array types).
+ *<p>
+ * Unlike {@link SimpleSerializers}, this class does not currently support generic mappings;
+ * all mappings must be to exact declared deserialization type.
+ * 
+ * @since 1.7
+ */
+public class SimpleKeyDeserializers implements KeyDeserializers
+{
+    protected HashMap<ClassKey,KeyDeserializer> _classMappings = null;
+
+    /*
+    /**********************************************************
+    /* Life-cycle, construction and configuring
+    /**********************************************************
+     */
+    
+    public SimpleKeyDeserializers() { }
+
+    public SimpleKeyDeserializers addDeserializer(Class<?> forClass, KeyDeserializer deser)
+    {
+        if (_classMappings == null) {
+            _classMappings = new HashMap<ClassKey,KeyDeserializer>();
+        }
+        _classMappings.put(new ClassKey(forClass), deser);
+        return this;
+    }
+
+    /*
+    /**********************************************************
+    /* Serializers implementation
+    /**********************************************************
+     */
+
+    @Override
+    public KeyDeserializer findKeyDeserializer(JavaType type, DeserializationConfig config, 
+            BeanDescription beanDesc, BeanProperty property)
+    {
+        if (_classMappings == null) {
+            return null;
+        }
+        return _classMappings.get(new ClassKey(type.getRawClass()));
+    }
+}

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

@@ -0,0 +1,265 @@
+package sh.calaba.org.codehaus.jackson.map.module;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import sh.calaba.org.codehaus.jackson.Version;
+import sh.calaba.org.codehaus.jackson.map.*;
+import sh.calaba.org.codehaus.jackson.map.deser.ValueInstantiator;
+
+/**
+ * Simple {@link Module} implementation that allows registration
+ * of serializers and deserializers, and bean serializer
+ * and deserializer modifiers.
+ * 
+ * @since 1.7
+ */
+public class SimpleModule extends Module
+{
+    protected final String _name;
+    protected final Version _version;
+    
+    protected SimpleSerializers _serializers = null;
+    protected SimpleDeserializers _deserializers = null;
+
+    protected SimpleSerializers _keySerializers = null;
+    protected SimpleKeyDeserializers _keyDeserializers = null;
+
+    /**
+     * Lazily-constructed resolver used for storing mappings from
+     * abstract classes to more specific implementing classes
+     * (which may be abstract or concrete)
+     */
+    protected SimpleAbstractTypeResolver _abstractTypes = null;
+
+    /**
+     * Lazily-constructed resolver used for storing mappings from
+     * abstract classes to more specific implementing classes
+     * (which may be abstract or concrete)
+     */
+    protected SimpleValueInstantiators _valueInstantiators = null;
+
+    /**
+     * Lazily-constructed map that contains mix-in definitions, indexed
+     * by target class, value being mix-in to apply.
+     * 
+     * @since 1.9
+     */
+    protected HashMap<Class<?>, Class<?>> _mixins = null;
+    
+    /*
+    /**********************************************************
+    /* Life-cycle: creation
+    /**********************************************************
+     */
+    
+    public SimpleModule(String name, Version version)
+    {
+        _name = name;
+        _version = version;
+    }
+
+    /*
+    /**********************************************************
+    /* Simple setters to allow overriding
+    /**********************************************************
+     */
+
+    /**
+     * Resets all currently configured serializers.
+     * 
+     * @since 1.9
+     */
+    public void setSerializers(SimpleSerializers s) {
+        _serializers = s;
+    }
+
+    /**
+     * Resets all currently configured deserializers.
+     * 
+     * @since 1.9
+     */
+    public void setDeserializers(SimpleDeserializers d) {
+        _deserializers = d;
+    }
+
+    /**
+     * Resets all currently configured key serializers.
+     * 
+     * @since 1.9
+     */
+    public void setKeySerializers(SimpleSerializers ks) {
+        _keySerializers = ks;
+    }
+
+    /**
+     * Resets all currently configured key deserializers.
+     * 
+     * @since 1.9
+     */
+    public void setKeyDeserializers(SimpleKeyDeserializers kd) {
+        _keyDeserializers = kd;
+    }
+
+    /**
+     * Resets currently configured abstract type mappings
+     *
+     * @since 1.9
+     */
+    public void setAbstractTypes(SimpleAbstractTypeResolver atr) {
+        _abstractTypes = atr;        
+    }
+
+    /**
+     * Resets all currently configured value instantiators
+     * 
+     * @since 1.9
+     */
+    public void setValueInstantiators(SimpleValueInstantiators svi) {
+        _valueInstantiators = svi;
+    }
+    
+    /*
+    /**********************************************************
+    /* Configuration methods
+    /**********************************************************
+     */
+    
+    public SimpleModule addSerializer(JsonSerializer<?> ser)
+    {
+        if (_serializers == null) {
+            _serializers = new SimpleSerializers();
+        }
+        _serializers.addSerializer(ser);
+        return this;
+    }
+    
+    public <T> SimpleModule addSerializer(Class<? extends T> type, JsonSerializer<T> ser)
+    {
+        if (_serializers == null) {
+            _serializers = new SimpleSerializers();
+        }
+        _serializers.addSerializer(type, ser);
+        return this;
+    }
+
+    public <T> SimpleModule addKeySerializer(Class<? extends T> type, JsonSerializer<T> ser)
+    {
+        if (_keySerializers == null) {
+            _keySerializers = new SimpleSerializers();
+        }
+        _keySerializers.addSerializer(type, ser);
+        return this;
+    }
+    
+    public <T> SimpleModule addDeserializer(Class<T> type, JsonDeserializer<? extends T> deser)
+    {
+        if (_deserializers == null) {
+            _deserializers = new SimpleDeserializers();
+        }
+        _deserializers.addDeserializer(type, deser);
+        return this;
+    }
+
+    public SimpleModule addKeyDeserializer(Class<?> type, KeyDeserializer deser)
+    {
+        if (_keyDeserializers == null) {
+            _keyDeserializers = new SimpleKeyDeserializers();
+        }
+        _keyDeserializers.addDeserializer(type, deser);
+        return this;
+    }
+
+    /**
+     * Lazily-constructed resolver used for storing mappings from
+     * abstract classes to more specific implementing classes
+     * (which may be abstract or concrete)
+     */
+    public <T> SimpleModule addAbstractTypeMapping(Class<T> superType,
+            Class<? extends T> subType)
+    {
+        if (_abstractTypes == null) {
+            _abstractTypes = new SimpleAbstractTypeResolver();
+        }
+        // note: addMapping() will verify arguments
+        _abstractTypes = _abstractTypes.addMapping(superType, subType);
+        return this;
+    }
+
+    /**
+     * Method for registering {@link ValueInstantiator} to use when deserializing
+     * instances of type <code>beanType</code>.
+     *<p>
+     * Instantiator is
+     * registered when module is registered for <code>ObjectMapper</code>.
+     */
+    public SimpleModule addValueInstantiator(Class<?> beanType, ValueInstantiator inst)
+    {
+        if (_valueInstantiators == null) {
+            _valueInstantiators = new SimpleValueInstantiators();
+        }
+        _valueInstantiators = _valueInstantiators.addValueInstantiator(beanType, inst);
+        return this;
+    }
+
+    /**
+     * Method for specifying that annotations define by <code>mixinClass</code>
+     * should be "mixed in" with annotations that <code>targetType</code>
+     * has (as if they were directly included on it!).
+     *<p>
+     * Mix-in annotations are
+     * registered when module is registered for <code>ObjectMapper</code>.
+     */
+    public SimpleModule setMixInAnnotation(Class<?> targetType, Class<?> mixinClass)
+    {
+        if (_mixins == null) {
+            _mixins = new HashMap<Class<?>, Class<?>>();
+        }
+        _mixins.put(targetType, mixinClass);
+        return this;
+    }
+    
+    /*
+    /**********************************************************
+    /* Module impl
+    /**********************************************************
+     */
+    
+    @Override
+    public String getModuleName() {
+        return _name;
+    }
+
+    @Override
+    public void setupModule(SetupContext context)
+    {
+        if (_serializers != null) {
+            context.addSerializers(_serializers);
+        }
+        if (_deserializers != null) {
+            context.addDeserializers(_deserializers);
+        }
+        if (_keySerializers != null) {
+            context.addKeySerializers(_keySerializers);
+        }
+        if (_keyDeserializers != null) {
+            context.addKeyDeserializers(_keyDeserializers);
+        }
+        if (_abstractTypes != null) {
+            context.addAbstractTypeResolver(_abstractTypes);
+        }
+        if (_valueInstantiators != null) {
+            context.addValueInstantiators(_valueInstantiators);
+        }
+        if (_mixins != null) {
+            for (Map.Entry<Class<?>,Class<?>> entry : _mixins.entrySet()) {
+                context.setMixInAnnotations(entry.getKey(), entry.getValue());
+            }
+        }
+    }
+
+    @Override
+    public Version version() {
+        return _version;
+    }
+}