calabash-android 0.4.7.pre6 → 0.4.7.pre7

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

@@ -0,0 +1,262 @@
+package sh.calaba.org.codehaus.jackson.map;
+
+import java.io.IOException;
+import java.util.Calendar;
+import java.util.Date;
+
+import sh.calaba.org.codehaus.jackson.Base64Variant;
+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.type.TypeFactory;
+import sh.calaba.org.codehaus.jackson.map.util.ArrayBuilders;
+import sh.calaba.org.codehaus.jackson.map.util.ObjectBuffer;
+import sh.calaba.org.codehaus.jackson.node.JsonNodeFactory;
+import sh.calaba.org.codehaus.jackson.type.JavaType;
+
+/**
+ * Context for deserialization process. Used to allow passing in configuration
+ * settings and reusable temporary objects (scrap arrays, containers).
+ */
+public abstract class DeserializationContext
+{
+    protected final DeserializationConfig _config;
+
+    /**
+     * @since 1.7
+     */
+    protected final int _featureFlags;
+    
+    /*
+    /**********************************************************
+    /* Life-cycle
+    /**********************************************************
+     */
+    
+    protected DeserializationContext(DeserializationConfig config)
+    {
+        _config = config;
+        _featureFlags = config._featureFlags;
+    }
+
+    /*
+    /**********************************************************
+    /* Configuration methods
+    /**********************************************************
+     */
+
+    /**
+     * Method for accessing configuration setting object for
+     * currently active deserialization.
+     */
+    public DeserializationConfig getConfig() { return _config; }
+
+    /**
+     * Returns provider that can be used for dynamically locating
+     * other deserializers during runtime.
+     * 
+     * @since 1.5
+     */
+    public DeserializerProvider getDeserializerProvider() {
+        // will be overridden by impl class
+        return null;
+    }
+    
+    /**
+     * Convenience method for checking whether specified on/off
+     * feature is enabled
+     */
+    public boolean isEnabled(DeserializationConfig.Feature feat) {
+        /* 03-Dec-2010, tatu: minor shortcut; since this is called quite often,
+         *   let's use a local copy of feature settings:
+         */
+        return (_featureFlags & feat.getMask()) != 0;
+    }
+
+    /**
+     * Convenience method for accessing the default Base64 encoding
+     * used for decoding base64 encoded binary content.
+     * Same as calling:
+     *<pre>
+     *  getConfig().getBase64Variant();
+     *</pre>
+     */
+    public Base64Variant getBase64Variant() {
+        return _config.getBase64Variant();
+    }
+
+    /**
+     * Accessor for getting access to the underlying JSON parser used
+     * for deserialization.
+     */
+    public abstract JsonParser getParser();
+
+    public final JsonNodeFactory getNodeFactory() {
+        return _config.getNodeFactory();
+    }
+
+    /**
+     * @since 1.8
+     */
+    public JavaType constructType(Class<?> cls) {
+        return _config.constructType(cls);
+    }
+
+    /**
+     * @since 1.9
+     */
+    public TypeFactory getTypeFactory() {
+        return _config.getTypeFactory();
+    }
+
+    /**
+     * @since 1.9
+     */
+    public abstract Object findInjectableValue(Object valueId,
+            BeanProperty forProperty, Object beanInstance);
+    
+    /*
+    /**********************************************************
+    /* Methods for accessing reusable/recyclable helper objects
+    /**********************************************************
+     */
+
+    /**
+     * Method that can be used to get access to a reusable ObjectBuffer,
+     * useful for efficiently constructing Object arrays and Lists.
+     * Note that leased buffers should be returned once deserializer
+     * is done, to allow for reuse during same round of deserialization.
+     */
+    public abstract ObjectBuffer leaseObjectBuffer();
+
+    /**
+     * Method to call to return object buffer previously leased with
+     * {@link #leaseObjectBuffer}.
+     * 
+     * @param buf Returned object buffer
+     */
+    public abstract void returnObjectBuffer(ObjectBuffer buf);
+
+    /**
+     * Method for accessing object useful for building arrays of
+     * primitive types (such as int[]).
+     */
+    public abstract ArrayBuilders getArrayBuilders();
+
+    /*
+    /**********************************************************
+    /* Parsing methods that may use reusable/-cyclable objects
+    /**********************************************************
+     */
+
+    /**
+     * Convenience method for parsing a Date from given String, using
+     * currently configured date format (accessed using
+     * {@link DeserializationConfig#getDateFormat()}).
+     *<p>
+     * Implementation will handle thread-safety issues related to
+     * date formats such that first time this method is called,
+     * date format is cloned, and cloned instance will be retained
+     * for use during this deserialization round.
+     */
+    public abstract java.util.Date parseDate(String dateStr)
+        throws IllegalArgumentException;
+
+    /**
+     * Convenience method for constructing Calendar instance set
+     * to specified time, to be modified and used by caller.
+     */
+    public abstract Calendar constructCalendar(Date d);
+
+    /*
+    /**********************************************************
+    /* Methods for problem handling, reporting
+    /**********************************************************
+     */
+
+    /**
+     * Method deserializers can call to inform configured {@link DeserializationProblemHandler}s
+     * of an unrecognized property.
+     * 
+     * @return True if there was a configured problem handler that was able to handle the
+     *   proble
+     * 
+     * @since 1.5
+     */
+    public abstract boolean handleUnknownProperty(JsonParser jp, JsonDeserializer<?> deser, Object instanceOrClass, String propName)
+        throws IOException, JsonProcessingException;
+
+    /**
+     * Helper method for constructing generic mapping exception for specified type
+     */
+    public abstract JsonMappingException mappingException(Class<?> targetClass);
+
+    /**
+     * @since 1.9
+     */
+    public abstract JsonMappingException mappingException(Class<?> targetClass, JsonToken t);
+    
+    /**
+     * Helper method for constructing generic mapping exception with specified
+     * message and current location information
+     * 
+     * @since 1.7
+     */
+    public JsonMappingException mappingException(String message)
+    {
+        return JsonMappingException.from(getParser(), message);
+    }
+    
+    /**
+     * Helper method for constructing instantiation exception for specified type,
+     * to indicate problem with physically constructing instance of
+     * specified class (missing constructor, exception from constructor)
+     */
+    public abstract JsonMappingException instantiationException(Class<?> instClass, Throwable t);
+
+    public abstract JsonMappingException instantiationException(Class<?> instClass, String msg);
+    
+    /**
+     * Helper method for constructing exception to indicate that input JSON
+     * String was not in recognized format for deserializing into given type.
+     */
+    public abstract JsonMappingException weirdStringException(Class<?> instClass, String msg);
+
+    /**
+     * Helper method for constructing exception to indicate that input JSON
+     * Number was not suitable for deserializing into given type.
+     */
+    public abstract JsonMappingException weirdNumberException(Class<?> instClass, String msg);
+
+    /**
+     * Helper method for constructing exception to indicate that given JSON
+     * Object field name was not in format to be able to deserialize specified
+     * key type.
+     */
+    public abstract JsonMappingException weirdKeyException(Class<?> keyClass, String keyValue, String msg);
+
+    /**
+     * Helper method for indicating that the current token was expected to be another
+     * token.
+     */
+    public abstract JsonMappingException wrongTokenException(JsonParser jp, JsonToken expToken, String msg);
+    
+    /**
+     * Helper method for constructing exception to indicate that JSON Object
+     * field name did not map to a known property of type being
+     * deserialized.
+     * 
+     * @param instanceOrClass Either value being populated (if one has been
+     *   instantiated), or Class that indicates type that would be (or
+     *   have been) instantiated
+     */
+    public abstract JsonMappingException unknownFieldException(Object instanceOrClass, String fieldName);
+
+    /**
+     * Helper method for constructing exception to indicate that given
+     * type id (parsed from JSON) could not be converted to a Java type.
+     * 
+     * @since 1.5
+     */
+    public abstract JsonMappingException unknownTypeException(JavaType baseType, String id);
+}

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

@@ -0,0 +1,56 @@
+package sh.calaba.org.codehaus.jackson.map;
+
+import java.io.IOException;
+
+import sh.calaba.org.codehaus.jackson.JsonProcessingException;
+
+/**
+ * This is the class that can be registered (via
+ * {@link DeserializationConfig} object owner by
+ * {@link ObjectMapper}) to get calledn when a potentially
+ * recoverable problem is encountered during deserialization
+ * process. Handlers can try to resolve the problem, throw
+ * an exception or do nothing.
+ *<p>
+ * Default implementations for all methods implemented minimal
+ * "do nothing" functionality, which is roughly equivalent to
+ * not having a registered listener at all. This allows for
+ * only implemented handler methods one is interested in, without
+ * handling other cases.
+ * 
+ * @author tatu
+ */
+public abstract class DeserializationProblemHandler
+{
+    /**
+     * Method called when a Json Map ("Object") entry with an unrecognized
+     * name is encountered.
+     * Content (supposedly) matching the property are accessible via
+     * parser that can be obtained from passed deserialization context.
+     * Handler can also choose to skip the content; if so, it MUST return
+     * true to indicate it did handle property succesfully.
+     * Skipping is usually done like so:
+     *<pre>
+     *  ctxt.getParser().skipChildren();
+     *</pre>
+     *<p>
+     * Note: version 1.2 added new deserialization feature
+     * (<code>DeserializationConfig.Feature.FAIL_ON_UNKNOWN_PROPERTIES</code>).
+     * It will only have effect <b>after</b> handler is called, and only
+     * if handler did <b>not</b> handle the problem.
+     *
+     * @param beanOrClass Either bean instance being deserialized (if one
+     *   has been instantiated so far); or Class that indicates type that
+     *   will be instantiated (if no instantiation done yet: for example
+     *   when bean uses non-default constructors)
+     * 
+     * @return True if the problem was succesfully resolved (and content available
+     *    used or skipped); false if listen
+     */
+    public boolean handleUnknownProperty(DeserializationContext ctxt, JsonDeserializer<?> deserializer,
+                                         Object beanOrClass, String propertyName)
+        throws IOException, JsonProcessingException
+    {
+        return false;
+    }
+}

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

@@ -0,0 +1,356 @@
+package sh.calaba.org.codehaus.jackson.map;
+
+import sh.calaba.org.codehaus.jackson.map.deser.BeanDeserializerModifier;
+import sh.calaba.org.codehaus.jackson.map.deser.ValueInstantiator;
+import sh.calaba.org.codehaus.jackson.map.deser.ValueInstantiators;
+import sh.calaba.org.codehaus.jackson.map.introspect.BasicBeanDescription;
+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;
+
+/**
+ * Abstract class that defines API used by {@link DeserializerProvider}
+ * to obtain actual
+ * {@link JsonDeserializer} instances from multiple distinct factories.
+ *<p>
+ * Since there are multiple broad categories of deserializers, there are 
+ * multiple factory methods:
+ *<ul>
+ * <li>For JSON "Array" type, we need 2 methods: one to deal with expected
+ *   Java arrays ({@link #createArrayDeserializer})
+ *   and the other for other Java containers like {@link java.util.List}s
+ *   and {@link java.util.Set}s ({@link #createCollectionDeserializer(DeserializationConfig, DeserializerProvider, CollectionType, BeanProperty)})
+ *  </li>
+ * <li>For JSON "Object" type, we need 2 methods: one to deal with
+ *   expected Java {@link java.util.Map}s
+ *   ({@link #createMapDeserializer}), and another for POJOs
+ *   ({@link #createBeanDeserializer(DeserializationConfig, DeserializerProvider, JavaType, BeanProperty)}.
+ *  </li>
+ * <li>For Tree Model ({@link sh.calaba.org.codehaus.jackson.JsonNode}) properties there is
+ *    {@link #createTreeDeserializer(DeserializationConfig, DeserializerProvider, JavaType, BeanProperty)}
+ * <li>For enumerated types ({@link java.lang.Enum}) there is
+ *    {@link #createEnumDeserializer(DeserializationConfig, DeserializerProvider, JavaType, BeanProperty)}
+ *  </li>
+ * <li>For all other types, {@link #createBeanDeserializer(DeserializationConfig, DeserializerProvider, JavaType, BeanProperty)}
+ *   is used.
+ * </ul>
+ *<p>
+ * All above methods take 2 type arguments, except for the first one
+ * which takes just a single argument.
+ */
+public abstract class DeserializerFactory
+{
+    protected final static Deserializers[] NO_DESERIALIZERS = new Deserializers[0];
+
+    /*
+    /**********************************************************
+    /* Helper class to contain configuration settings
+    /**********************************************************
+     */
+
+    /**
+     * Configuration settings container class for bean deserializer factory
+     * 
+     * @since 1.7
+     */
+    public abstract static class Config
+    {
+        /**
+         * Fluent/factory method used to construct a configuration object that
+         * has same deserializer providers as this instance, plus one specified
+         * as argument. Additional provider will be added before existing ones,
+         * meaning it has priority over existing definitions.
+         */
+        public abstract Config withAdditionalDeserializers(Deserializers additional);
+
+        /**
+         * Fluent/factory method used to construct a configuration object that
+         * has same key deserializer providers as this instance, plus one specified
+         * as argument. Additional provider will be added before existing ones,
+         * meaning it has priority over existing definitions.
+         */
+        public abstract Config withAdditionalKeyDeserializers(KeyDeserializers additional);
+        
+        /**
+         * Fluent/factory method used to construct a configuration object that
+         * has same configuration as this instance plus one additional
+         * deserialiazer modifier. Added modifier has the highest priority (that is, it
+         * gets called before any already registered modifier).
+         */
+        public abstract Config withDeserializerModifier(BeanDeserializerModifier modifier);
+
+        /**
+         * Fluent/factory method used to construct a configuration object that
+         * has same configuration as this instance plus one additional
+         * abstract type resolver.
+         * Added resolver has the highest priority (that is, it
+         * gets called before any already registered resolver).
+         * 
+         * @since 1.8
+         */
+        public abstract Config withAbstractTypeResolver(AbstractTypeResolver resolver);
+
+        /**
+         * Fluent/factory method used to construct a configuration object that
+         * has same configuration as this instance plus specified additional
+         * value instantiator provider object.
+         * Added instantiator provider has the highest priority (that is, it
+         * gets called before any already registered resolver).
+         * 
+         * @param instantiators Object that can provide {@link sh.calaba.org.codehaus.jackson.map.deser.ValueInstantiator}s for
+         *    constructing POJO values during deserialization
+         * 
+         * @since 1.9
+         */
+        public abstract Config withValueInstantiators(ValueInstantiators instantiators);
+        
+        public abstract Iterable<Deserializers> deserializers();
+
+        /**
+         * @since 1.8
+         */
+        public abstract Iterable<KeyDeserializers> keyDeserializers();
+        
+        public abstract Iterable<BeanDeserializerModifier> deserializerModifiers();
+
+        /**
+         * @since 1.8
+         */
+        public abstract Iterable<AbstractTypeResolver> abstractTypeResolvers();
+
+        /**
+         * @since 1.9
+         */
+        public abstract Iterable<ValueInstantiators> valueInstantiators();
+        
+        public abstract boolean hasDeserializers();
+
+        /**
+         * @since 1.8
+         */
+        public abstract boolean hasKeyDeserializers();
+        
+        public abstract boolean hasDeserializerModifiers();
+
+        /**
+         * @since 1.8
+         */
+        public abstract boolean hasAbstractTypeResolvers();
+
+        /**
+         * @since 1.9
+         */
+        public abstract boolean hasValueInstantiators();
+    }
+
+    /*
+    /********************************************************
+    /* Configuration handling
+    /********************************************************
+     */
+
+    /**
+     * @since 1.7
+     */
+    public abstract Config getConfig();
+    
+    /**
+     * Method used for creating a new instance of this factory, but with different
+     * configuration. Reason for specifying factory method (instead of plain constructor)
+     * is to allow proper sub-classing of factories.
+     *<p>
+     * Note that custom sub-classes <b>must override</b> implementation
+     * of this method, as it usually requires instantiating a new instance of
+     * factory type. Check out javadocs for
+     * {@link sh.calaba.org.codehaus.jackson.map.deser.BeanDeserializerFactory} for more details.
+     * 
+     * @since 1.7
+     */
+    public abstract DeserializerFactory withConfig(Config config);
+
+    /**
+     * Convenience method for creating a new factory instance with additional deserializer
+     * provider.
+     * 
+     * @since 1.7
+     */
+    public final DeserializerFactory withAdditionalDeserializers(Deserializers additional) {
+        return withConfig(getConfig().withAdditionalDeserializers(additional));
+    }
+
+    /**
+     * Convenience method for creating a new factory instance with additional
+     * {@link KeyDeserializers}.
+     * 
+     * @since 1.8
+     */
+    public final DeserializerFactory withAdditionalKeyDeserializers(KeyDeserializers additional) {
+        return withConfig(getConfig().withAdditionalKeyDeserializers(additional));
+    }
+    
+    /**
+     * Convenience method for creating a new factory instance with additional
+     * {@link BeanDeserializerModifier}.
+     * 
+     * @since 1.7
+     */
+    public final DeserializerFactory withDeserializerModifier(BeanDeserializerModifier modifier) {
+        return withConfig(getConfig().withDeserializerModifier(modifier));
+    }
+
+    /**
+     * Convenience method for creating a new factory instance with additional
+     * {@link AbstractTypeResolver}.
+     * 
+     * @since 1.7
+     */
+    public final DeserializerFactory withAbstractTypeResolver(AbstractTypeResolver resolver) {
+        return withConfig(getConfig().withAbstractTypeResolver(resolver));
+    }
+
+    /**
+     * Convenience method for creating a new factory instance with additional
+     * {@link ValueInstantiators}.
+     * 
+     * @since 1.9
+     */
+    public final DeserializerFactory withValueInstantiators(ValueInstantiators instantiators) {
+        return withConfig(getConfig().withValueInstantiators(instantiators));
+    }
+    
+    /*
+    /**********************************************************
+    /* Basic DeserializerFactory API:
+    /**********************************************************
+     */
+
+    /**
+     * 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 is to find all creators (constructors, factory methods)
+     * for the bean type to deserialize.
+     * 
+     * @since 1.9
+     */
+    public abstract ValueInstantiator findValueInstantiator(DeserializationConfig config,
+            BasicBeanDescription beanDesc)
+        throws JsonMappingException;
+    
+    /**
+     * Method called to create (or, for completely immutable deserializers,
+     * reuse) a deserializer that can convert JSON content into values of
+     * specified Java "bean" (POJO) type.
+     * At this point it is known that the type is not otherwise recognized
+     * as one of structured types (array, Collection, Map) or a well-known
+     * JDK type (enum, primitives/wrappers, String); this method only
+     * gets called if other options are exhausted. This also means that
+     * this method can be overridden to add support for custom types.
+     *
+     * @param type Type to be deserialized
+     * @param p Provider that can be called to create deserializers for
+     *   contained member types
+     */
+    public abstract JsonDeserializer<Object> createBeanDeserializer(DeserializationConfig config, DeserializerProvider p,
+            JavaType type, BeanProperty property)
+        throws JsonMappingException;
+
+    /**
+     * Method called to create (or, for completely immutable deserializers,
+     * reuse) a deserializer that can convert JSON content into values of
+     * specified Java type.
+     *
+     * @param type Type to be deserialized
+     * @param p Provider that can be called to create deserializers for
+     *   contained member types
+     */
+    public abstract JsonDeserializer<?> createArrayDeserializer(DeserializationConfig config, DeserializerProvider p,
+            ArrayType type, BeanProperty property)
+        throws JsonMappingException;
+
+    public abstract JsonDeserializer<?> createCollectionDeserializer(DeserializationConfig config,
+            DeserializerProvider p, CollectionType type, BeanProperty property)
+        throws JsonMappingException;
+
+    /**
+     * @since 1.8
+     */
+    public abstract JsonDeserializer<?> createCollectionLikeDeserializer(DeserializationConfig config,
+            DeserializerProvider p, CollectionLikeType type, BeanProperty property)
+        throws JsonMappingException;
+    
+    public abstract JsonDeserializer<?> createEnumDeserializer(DeserializationConfig config,
+            DeserializerProvider p, JavaType type, BeanProperty property)
+        throws JsonMappingException;
+
+    public abstract JsonDeserializer<?> createMapDeserializer(DeserializationConfig config,
+            DeserializerProvider p, MapType type, BeanProperty property)
+        throws JsonMappingException;
+
+    /**
+     * @since 1.8
+     */
+    public abstract JsonDeserializer<?> createMapLikeDeserializer(DeserializationConfig config,
+            DeserializerProvider p, MapLikeType type, BeanProperty property)
+        throws JsonMappingException;
+
+    /**
+     * Method called to create and return a deserializer that can construct
+     * JsonNode(s) from JSON content.
+     */
+    public abstract JsonDeserializer<?> createTreeDeserializer(DeserializationConfig config, DeserializerProvider p,
+            JavaType type, BeanProperty property)
+        throws JsonMappingException;
+
+    /**
+     * Method called to find if factory knows how to create a key deserializer
+     * for specified type; currently this means checking if a module has registered
+     * possible deserializers.
+     * 
+     * @return Key deserializer to use for specified type, if one found; null if not
+     *   (and default key deserializer should be used)
+     * 
+     * @since 1.8
+     */
+    public KeyDeserializer createKeyDeserializer(DeserializationConfig config, JavaType type,
+            BeanProperty property)
+        throws JsonMappingException
+    {
+        // Default implementation returns null for backwards compatibility reasons
+        return null;
+    }
+    
+    /**
+     * Method called to find and create a type information deserializer for given base type,
+     * if one is needed. If not needed (no polymorphic handling configured for type),
+     * should return null.
+     *<p>
+     * Note that this method is usually only directly called for values of container (Collection,
+     * array, Map) types and root values, but not for bean property values.
+     *
+     * @param baseType Declared base type of the value to deserializer (actual
+     *    deserializer type will be this type or its subtype)
+     * 
+     * @return Type deserializer to use for given base type, if one is needed; null if not.
+     * 
+     * @since 1.5
+     */
+    public TypeDeserializer findTypeDeserializer(DeserializationConfig config, JavaType baseType,
+            BeanProperty property)
+        throws JsonMappingException
+    {
+        // Default implementation returns null for backwards compatibility reasons
+        return null;
+    }
+}