calabash-android 0.0.1

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

@@ -0,0 +1,185 @@
+package sh.calaba.org.codehaus.jackson.map;
+
+import sh.calaba.org.codehaus.jackson.io.SerializedString;
+import sh.calaba.org.codehaus.jackson.map.deser.BeanDeserializerModifier;
+import sh.calaba.org.codehaus.jackson.map.deser.ValueInstantiators;
+import sh.calaba.org.codehaus.jackson.type.JavaType;
+
+/**
+ * Abstract class that defines API used by {@link ObjectMapper} and
+ * {@link JsonDeserializer}s to obtain deserializers capable of
+ * re-constructing instances of handled type from JSON content.
+ */
+public abstract class DeserializerProvider
+{
+    protected DeserializerProvider() { }
+
+    /*
+    /**********************************************************
+    /* Fluent factory methods
+    /**********************************************************
+     */
+    
+    /**
+     * Method that sub-classes need to override, to ensure that fluent-factory
+     * methods will produce proper sub-type.
+     * 
+     * @since 1.9
+     */
+    public abstract DeserializerProvider withFactory(DeserializerFactory factory);
+    
+    /**
+     * Method that is to configure {@link DeserializerFactory} that provider has
+     * to use specified deserializer provider, with highest precedence (that is,
+     * additional providers have higher precedence than default one or previously
+     * added ones)
+     * 
+     * @since 1.7
+     */
+    public abstract DeserializerProvider withAdditionalDeserializers(Deserializers d);
+
+    /**
+     * @since 1.8
+     */
+    public abstract DeserializerProvider withAdditionalKeyDeserializers(KeyDeserializers d);
+    
+    /**
+     * @since 1.7
+     */
+    public abstract DeserializerProvider withDeserializerModifier(BeanDeserializerModifier modifier);
+
+    /**
+     * @since 1.8
+     */
+    public abstract DeserializerProvider withAbstractTypeResolver(AbstractTypeResolver resolver);
+
+    /**
+     * Method that will construct a new instance with specified additional value instantiators
+     * (i.e. does NOT replace existing ones)
+     * 
+     * @since 1.9
+     */
+    public abstract DeserializerProvider withValueInstantiators(ValueInstantiators instantiators);
+    
+    /*
+    /**********************************************************
+    /* General deserializer locating method
+    /**********************************************************
+     */
+
+    /**
+     * Method called to get hold of a deserializer for a value of given type;
+     * or if no such deserializer can be found, a default handler (which
+     * may do a best-effort generic serialization or just simply
+     * throw an exception when invoked).
+     *<p>
+     * Note: this method is only called for value types; not for keys.
+     * Key deserializers can be accessed using {@link #findKeyDeserializer}.
+     *
+     * @param config Deserialization configuration
+     * @param propertyType Declared type of the value to deserializer (obtained using
+     *   'setter' method signature and/or type annotations
+     * @param property Object that represents accessor for property value; field,
+     *    setter method or constructor parameter.
+     *
+     * @throws JsonMappingException if there are fatal problems with
+     *   accessing suitable deserializer; including that of not
+     *   finding any serializer
+     */
+    public abstract JsonDeserializer<Object> findValueDeserializer(DeserializationConfig config,
+            JavaType propertyType, BeanProperty property)
+        throws JsonMappingException;
+    
+    /**
+     * Method called to locate deserializer for given type, as well as matching
+     * type deserializer (if one is needed); and if type deserializer is needed,
+     * construct a "wrapped" deserializer that can extract and use type information
+     * for calling actual deserializer.
+     *<p>
+     * Since this method is only called for root elements, no referral information
+     * is taken.
+     *    
+     * @since 1.5
+     */
+    public abstract JsonDeserializer<Object> findTypedValueDeserializer(DeserializationConfig config,
+            JavaType type, BeanProperty property)
+        throws JsonMappingException;
+
+    /**
+     * Method called to get hold of a deserializer to use for deserializing
+     * keys for {@link java.util.Map}.
+     *
+     * @throws JsonMappingException if there are fatal problems with
+     *   accessing suitable key deserializer; including that of not
+     *   finding any serializer
+     */
+    public abstract KeyDeserializer findKeyDeserializer(DeserializationConfig config,
+            JavaType keyType, BeanProperty property)
+        throws JsonMappingException;
+
+    /**
+     * Method called to find out whether provider would be able to find
+     * a deserializer for given type, using a root reference (i.e. not
+     * through fields or membership in an array or collection)
+     */
+    public abstract boolean hasValueDeserializerFor(DeserializationConfig config, JavaType type);
+
+    /*
+    /**********************************************************
+    /* Additional type handling methods, related
+    /**********************************************************
+     */
+
+    /**
+     * Method that can be called to try to resolve an abstract type
+     * (interface, abstract class) into a concrete type, or at least
+     * something "more concrete" (abstract class instead of interface).
+     * Will either return passed type, or a more specific type.
+     * 
+     * @since 1.9
+     */
+    public abstract JavaType mapAbstractType(DeserializationConfig config, JavaType type)
+        throws JsonMappingException;
+
+
+    /**
+     * Method that can be used to try find expected root name for given type
+     * 
+     * @since 1.9
+     */
+    public abstract SerializedString findExpectedRootName(DeserializationConfig config, JavaType type)
+        throws JsonMappingException;
+    
+    /*
+    /**********************************************************
+    /* Access to caching aspects
+    /**********************************************************
+     */
+
+    /**
+     * Method that can be used to determine how many deserializers this
+     * provider is caching currently 
+     * (if it does caching: default implementation does)
+     * Exact count depends on what kind of deserializers get cached;
+     * default implementation caches only dynamically constructed deserializers,
+     * but not eagerly constructed standard deserializers (which is different
+     * from how serializer provider works).
+     *<p>
+     * The main use case for this method is to allow conditional flushing of
+     * deserializer cache, if certain number of entries is reached.
+     * 
+     * @since 1.4
+     */
+    public abstract int cachedDeserializersCount();
+
+    /**
+     * Method that will drop all dynamically constructed deserializers (ones that
+     * are counted as result value for {@link #cachedDeserializersCount}).
+     * This can be used to remove memory usage (in case some deserializers are
+     * only used once or so), or to force re-construction of deserializers after
+     * configuration changes for mapper than owns the provider.
+     * 
+     * @since 1.4
+     */
+    public abstract void flushCachedDeserializers();
+}

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

@@ -0,0 +1,339 @@
+package sh.calaba.org.codehaus.jackson.map;
+
+import sh.calaba.org.codehaus.jackson.JsonNode;
+import sh.calaba.org.codehaus.jackson.map.type.ArrayType;
+import sh.calaba.org.codehaus.jackson.map.type.CollectionLikeType;
+import sh.calaba.org.codehaus.jackson.map.type.CollectionType;
+import sh.calaba.org.codehaus.jackson.map.type.MapLikeType;
+import sh.calaba.org.codehaus.jackson.map.type.MapType;
+import sh.calaba.org.codehaus.jackson.type.JavaType;
+
+/**
+ * Interface that defines API for simple extensions that can provide additional deserializers
+ * for various types. Access is by a single callback method; instance is to either return
+ * a configured {@link JsonDeserializer} for specified type, or null to indicate that it
+ * does not support handling of the type. In latter case, further calls can be made
+ * for other providers; in former case returned deserializer is used for handling of
+ * instances of specified type.
+ *<p>
+ * Unlike with {@link Serializers}, multiple different methods are used since different
+ * kinds of types typically require different kinds of inputs.
+ * 
+ * @since 1.7
+ */
+public interface Deserializers
+{
+    /**
+     * Method called to locate serializer for specified array type.
+     *<p>
+     * Deserializer for element type may be passed, if configured explicitly at higher level (by
+     * annotations, typically), but usually are not.
+     * Type deserializer for element is passed if one is needed based on contextual information
+     * (annotations on declared element class; or on field or method type is associated with).
+     * 
+     * @param type Type of array instances to deserialize
+     * @param config Configuration in effect
+     * @param provider Provider that can be used to locate deserializer for component type (if
+     *    one not provided, or needs to be overridden)
+     * @param property Property that contains array value  (null for root values)
+     * @param elementTypeDeserializer If element type needs polymorphic type handling, this is
+     *    the type information deserializer to use; should usually be used as is when constructing
+     *    array deserializer.
+     * @param elementDeserializer Deserializer to use for elements, if explicitly defined (by using
+     *    annotations, for exmple). May be null, in which case it should be resolved here (or using
+     *    {@link ResolvableDeserializer} callback)
+     * 
+     * @return Deserializer to use for the type; or null if this provider does not know how to construct it
+     */
+    public JsonDeserializer<?> findArrayDeserializer(ArrayType type, DeserializationConfig config,
+            DeserializerProvider provider,
+            BeanProperty property,
+            TypeDeserializer elementTypeDeserializer, JsonDeserializer<?> elementDeserializer)
+        throws JsonMappingException;
+
+    /**
+     * Method called to locate serializer for specified {@link java.util.Collection} (List, Set etc) type.
+     *<p>
+     * Deserializer for element type may be passed, if configured explicitly at higher level (by
+     * annotations, typically), but usually are not.
+     * Type deserializer for element is passed if one is needed based on contextual information
+     * (annotations on declared element class; or on field or method type is associated with).
+     * 
+     * @param type Type of collection instances to deserialize
+     * @param config Configuration in effect
+     * @param provider Provider that can be used to locate dependant deserializers if and as necessary
+     *   (but note that in many cases resolution must be deferred by using {@link ResolvableDeserializer} callback)
+     * @param property Property that contains array value  (null for root values)
+     * @param beanDesc Definition of the enumeration type that contains class annotations and
+     *    other information typically needed for building deserializers (note: always instance
+     *    of {@link sh.calaba.org.codehaus.jackson.map.introspect.BasicBeanDescription})
+     * @param elementTypeDeserializer If element type needs polymorphic type handling, this is
+     *    the type information deserializer to use; should usually be used as is when constructing
+     *    array deserializer.
+     * @param elementDeserializer Deserializer to use for elements, if explicitly defined (by using
+     *    annotations, for exmple). May be null, in which case it should be resolved here (or using
+     *    {@link ResolvableDeserializer} callback)
+     * 
+     * @return Deserializer to use for the type; or null if this provider does not know how to construct it
+     */
+    public JsonDeserializer<?> findCollectionDeserializer(CollectionType type, DeserializationConfig config,
+            DeserializerProvider provider, BeanDescription beanDesc, BeanProperty property,
+            TypeDeserializer elementTypeDeserializer, JsonDeserializer<?> elementDeserializer)
+        throws JsonMappingException;
+
+    /**
+     * Method called to locate serializer for specified
+     * "Collection-like" type (one that acts
+     * like {@link java.util.Collection} but does not implement it).
+     *<p>
+     * Deserializer for element type may be passed, if configured explicitly at higher level (by
+     * annotations, typically), but usually are not.
+     * Type deserializer for element is passed if one is needed based on contextual information
+     * (annotations on declared element class; or on field or method type is associated with).
+     * 
+     * @param type Type of instances to deserialize
+     * @param config Configuration in effect
+     * @param provider Provider that can be used to locate dependant deserializers if and as necessary
+     *   (but note that in many cases resolution must be deferred by using {@link ResolvableDeserializer} callback)
+     * @param property Property that contains array value  (null for root values)
+     * @param beanDesc Definition of the enumeration type that contains class annotations and
+     *    other information typically needed for building deserializers (note: always instance
+     *    of {@link sh.calaba.org.codehaus.jackson.map.introspect.BasicBeanDescription})
+     * @param elementTypeDeserializer If element type needs polymorphic type handling, this is
+     *    the type information deserializer to use; should usually be used as is when constructing
+     *    array deserializer.
+     * @param elementDeserializer Deserializer to use for elements, if explicitly defined (by using
+     *    annotations, for exmple). May be null, in which case it should be resolved here (or using
+     *    {@link ResolvableDeserializer} callback)
+     * 
+     * @return Deserializer to use for the type; or null if this provider does not know how to construct it
+     * 
+     * @since 1.8
+     */
+    public JsonDeserializer<?> findCollectionLikeDeserializer(CollectionLikeType type, DeserializationConfig config,
+            DeserializerProvider provider, BeanDescription beanDesc, BeanProperty property,
+            TypeDeserializer elementTypeDeserializer, JsonDeserializer<?> elementDeserializer)
+        throws JsonMappingException;
+    
+    /**
+     * Method called to locate deserializer for specified {@link java.lang.Enum} type.
+     * 
+     * @param type Type of {@link java.lang.Enum} instances to deserialize
+     * @param config Configuration in effect
+     * @param beanDesc Definition of the enumeration type that contains class annotations and
+     *    other information typically needed for building deserializers (note: always instance
+     *    of {@link sh.calaba.org.codehaus.jackson.map.introspect.BasicBeanDescription})
+     * 
+     * @return Deserializer to use for the type; or null if this provider does not know how to construct it
+     */
+    public JsonDeserializer<?> findEnumDeserializer(Class<?> type, DeserializationConfig config,
+            BeanDescription beanDesc, BeanProperty property)
+        throws JsonMappingException;
+
+    /**
+     * Method called to locate deserializer for specified {@link java.util.Map} type.
+     *<p>
+     * Deserializer for element type may be passed, if configured explicitly at higher level (by
+     * annotations, typically), but usually are not.
+     * Type deserializer for element is passed if one is needed based on contextual information
+     * (annotations on declared element class; or on field or method type is associated with).
+     *<p>
+     * Similarly, a {@link KeyDeserializer} may be passed, but this is only done if there is
+     * a specific configuration override (annotations) to indicate instance to use. Otherwise
+     * null is passed, and key deserializer needs to be obtained using {@link DeserializerProvider}
+     * 
+     * @param type Type of {@link java.util.Map} instances to deserialize
+     * @param config Configuration in effect
+     * @param provider Provider that can be used to locate dependant deserializers if and as necessary
+     *   (but note that in many cases resolution must be deferred by using {@link ResolvableDeserializer} callback)
+     * @param beanDesc Definition of the enumeration type that contains class annotations and
+     *    other information typically needed for building deserializers (note: always instance
+     *    of {@link sh.calaba.org.codehaus.jackson.map.introspect.BasicBeanDescription})
+     * @param keyDeserializer Key deserializer use, if it is defined via annotations or other configuration;
+     *    null if default key deserializer for key type can be used.
+     * @param elementTypeDeserializer If element type needs polymorphic type handling, this is
+     *    the type information deserializer to use; should usually be used as is when constructing
+     *    array deserializer.
+     * @param elementDeserializer Deserializer to use for elements, if explicitly defined (by using
+     *    annotations, for exmple). May be null, in which case it should be resolved here (or using
+     *    {@link ResolvableDeserializer} callback)
+     * 
+     * @return Deserializer to use for the type; or null if this provider does not know how to construct it
+     */
+    public JsonDeserializer<?> findMapDeserializer(MapType type, DeserializationConfig config,
+            DeserializerProvider provider, BeanDescription beanDesc, BeanProperty property,
+            KeyDeserializer keyDeserializer,
+            TypeDeserializer elementTypeDeserializer, JsonDeserializer<?> elementDeserializer)
+        throws JsonMappingException;
+
+    /**
+     * Method called to locate serializer for specified
+     * "Map-like" type (one that acts
+     * like {@link java.util.Map} but does not implement it).
+     *<p>
+     * Deserializer for element type may be passed, if configured explicitly at higher level (by
+     * annotations, typically), but usually are not.
+     * Type deserializer for element is passed if one is needed based on contextual information
+     * (annotations on declared element class; or on field or method type is associated with).
+     *<p>
+     * Similarly, a {@link KeyDeserializer} may be passed, but this is only done if there is
+     * a specific configuration override (annotations) to indicate instance to use. Otherwise
+     * null is passed, and key deserializer needs to be obtained using {@link DeserializerProvider}
+     * 
+     * @param type Type of {@link java.util.Map} instances to deserialize
+     * @param config Configuration in effect
+     * @param provider Provider that can be used to locate dependant deserializers if and as necessary
+     *   (but note that in many cases resolution must be deferred by using {@link ResolvableDeserializer} callback)
+     * @param beanDesc Definition of the enumeration type that contains class annotations and
+     *    other information typically needed for building deserializers (note: always instance
+     *    of {@link sh.calaba.org.codehaus.jackson.map.introspect.BasicBeanDescription})
+     * @param keyDeserializer Key deserializer use, if it is defined via annotations or other configuration;
+     *    null if default key deserializer for key type can be used.
+     * @param elementTypeDeserializer If element type needs polymorphic type handling, this is
+     *    the type information deserializer to use; should usually be used as is when constructing
+     *    array deserializer.
+     * @param elementDeserializer Deserializer to use for elements, if explicitly defined (by using
+     *    annotations, for exmple). May be null, in which case it should be resolved here (or using
+     *    {@link ResolvableDeserializer} callback)
+     * 
+     * @return Deserializer to use for the type; or null if this provider does not know how to construct it
+     * 
+     * @since 1.8
+     */
+    public JsonDeserializer<?> findMapLikeDeserializer(MapLikeType type, DeserializationConfig config,
+            DeserializerProvider provider, BeanDescription beanDesc, BeanProperty property,
+            KeyDeserializer keyDeserializer,
+            TypeDeserializer elementTypeDeserializer, JsonDeserializer<?> elementDeserializer)
+        throws JsonMappingException;
+    
+    /**
+     * Method called to locate deserializer for specified JSON tree node type.
+     * 
+     * @param nodeType Specific type of JSON tree nodes to deserialize (subtype of {@link sh.calaba.org.codehaus.jackson.JsonNode})
+     * @param config Configuration in effect
+     * 
+     * @return Deserializer to use for the type; or null if this provider does not know how to construct it
+     */
+    public JsonDeserializer<?> findTreeNodeDeserializer(Class<? extends JsonNode> nodeType, DeserializationConfig config,
+            BeanProperty property)
+        throws JsonMappingException;
+    
+    /**
+     * Method called to locate deserializer for specified value type which does not belong to any other
+     * category (not an Enum, Collection, Map, Array or tree node)
+     * 
+     * @param type Bean type to deserialize
+     * @param config Configuration in effect
+     * @param provider Provider that can be used to locate dependant deserializers if and as necessary
+     *   (but note that in many cases resolution must be deferred by using {@link ResolvableDeserializer} callback)
+     * @param beanDesc Definition of the enumeration type that contains class annotations and
+     *    other information typically needed for building deserializers (note: always instance
+     *    of {@link sh.calaba.org.codehaus.jackson.map.introspect.BasicBeanDescription})
+     * 
+     * @return Deserializer to use for the type; or null if this provider does not know how to construct it
+     */
+    public JsonDeserializer<?> findBeanDeserializer(JavaType type, DeserializationConfig config,
+            DeserializerProvider provider, BeanDescription beanDesc,
+            BeanProperty property)
+        throws JsonMappingException;
+
+    /*
+    /**********************************************************
+    /* Helper classes
+    /**********************************************************
+     */
+
+    /**
+     * Basic {@link Deserializers} implementation that implements all methods but provides
+     * no deserializers. Its main purpose is to serve as a base class so that
+     * sub-classes only need to override methods they need, as most of the time some
+     * of methods are not needed (especially enumeration and array deserializers are
+     * very rarely overridden).
+     * 
+     * @since 1.9
+     */
+    public static class Base implements Deserializers
+    {
+        @Override
+        public JsonDeserializer<?> findArrayDeserializer(ArrayType type, DeserializationConfig config,
+                DeserializerProvider provider, BeanProperty property,
+                TypeDeserializer elementTypeDeserializer, JsonDeserializer<?> elementDeserializer)
+            throws JsonMappingException
+        {
+            return null;
+        }
+
+        @Override
+        public JsonDeserializer<?> findCollectionDeserializer(CollectionType type, DeserializationConfig config,
+                DeserializerProvider provider, BeanDescription beanDesc, BeanProperty property,
+                TypeDeserializer elementTypeDeserializer, JsonDeserializer<?> elementDeserializer)
+            throws JsonMappingException
+        {
+            return null;
+        }
+
+        @Override
+        public JsonDeserializer<?> findCollectionLikeDeserializer(CollectionLikeType type, DeserializationConfig config,
+                DeserializerProvider provider, BeanDescription beanDesc, BeanProperty property,
+                TypeDeserializer elementTypeDeserializer, JsonDeserializer<?> elementDeserializer)
+            throws JsonMappingException
+        {
+            return null;
+        }
+
+        @Override
+        public JsonDeserializer<?> findMapDeserializer(MapType type, DeserializationConfig config,
+                DeserializerProvider provider, BeanDescription beanDesc, BeanProperty property,
+                KeyDeserializer keyDeserializer,
+                TypeDeserializer elementTypeDeserializer, JsonDeserializer<?> elementDeserializer)
+            throws JsonMappingException
+        {
+            return null;
+        }
+
+        @Override
+        public JsonDeserializer<?> findMapLikeDeserializer(MapLikeType type, DeserializationConfig config,
+                DeserializerProvider provider, BeanDescription beanDesc, BeanProperty property,
+                KeyDeserializer keyDeserializer,
+                TypeDeserializer elementTypeDeserializer, JsonDeserializer<?> elementDeserializer)
+            throws JsonMappingException
+        {
+            return null;
+        }
+
+        @Override
+        public JsonDeserializer<?> findEnumDeserializer(Class<?> type, DeserializationConfig config,
+                BeanDescription beanDesc,
+                BeanProperty property)
+            throws JsonMappingException
+        {
+            return null;
+        }
+        
+        @Override
+        public JsonDeserializer<?> findTreeNodeDeserializer(Class<? extends JsonNode> nodeType,
+                DeserializationConfig config,
+                BeanProperty property)
+            throws JsonMappingException
+        {
+            return null;
+        }
+
+        @Override
+        public JsonDeserializer<?> findBeanDeserializer(JavaType type, DeserializationConfig config,
+                DeserializerProvider provider,
+                BeanDescription beanDesc,
+                BeanProperty property)
+            throws JsonMappingException
+        {
+            return null;
+        }
+    }
+
+
+    /**
+     * @deprecated As of 1.9, use {@link Base} instead
+     */
+    @Deprecated
+    public static class None extends Base { }
+}