calabash-android 0.4.7.pre6 → 0.4.7.pre7

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

@@ -0,0 +1,25 @@
+package sh.calaba.org.codehaus.jackson.map.annotate;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+import sh.calaba.org.codehaus.jackson.annotate.JacksonAnnotation;
+
+/**
+ * Marker interface used to indicate implementation classes
+ * (serializers, deserializers etc) that are standard ones Jackson
+ * uses; not custom ones that application has added. It can be
+ * added in cases where certain optimizations can be made if
+ * default instances are uses; for example when handling conversions
+ * of "natural" JSON types like Strings, booleans and numbers.
+ * 
+ * @since 1.6
+ */
+@Target({ElementType.TYPE})
+@Retention(RetentionPolicy.RUNTIME)
+@JacksonAnnotation
+public @interface JacksonStdImpl {
+
+}

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

@@ -0,0 +1,32 @@
+package sh.calaba.org.codehaus.jackson.map.annotate;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+import sh.calaba.org.codehaus.jackson.annotate.JacksonAnnotation;
+
+/**
+ * Marker annotation used to denote whether given instance
+ * (currently only used with {@link sh.calaba.org.codehaus.jackson.map.JsonDeserializer})
+ * can be cached.
+ *<p>
+ * Default action to take in absence of annotation depends
+ * on object using annotation; with deserializers default is
+ * to assume instances are not cachable.
+ *
+ * @since 1.1
+ */
+@Target({ElementType.TYPE})
+@Retention(RetentionPolicy.RUNTIME)
+@JacksonAnnotation
+public @interface JsonCachable
+{
+    /**
+     * Default value is true, giving semantics for parameterless tag instance
+     * such that empty instance indicates that instances of annotated class
+     * are indeed cachable.
+     */
+    boolean value() default true;
+}

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

@@ -0,0 +1,109 @@
+package sh.calaba.org.codehaus.jackson.map.annotate;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+import sh.calaba.org.codehaus.jackson.annotate.JacksonAnnotation;
+import sh.calaba.org.codehaus.jackson.map.JsonDeserializer;
+import sh.calaba.org.codehaus.jackson.map.KeyDeserializer;
+
+/**
+ * Annotation use for configuring deserialization aspects, by attaching
+ * to "setter" methods or fields, or to value classes.
+ * When annotating value classes, configuration is used for instances
+ * of the value class but can be overridden by more specific annotations
+ * (ones that attach to methods or fields).
+ *<p>
+ * An example annotation would be:
+ *<pre>
+ *  &#64;JsonDeserialize(using=MySerializer.class,
+ *    as=MyHashMap.class,
+ *    keyAs=MyHashKey.class,
+ *    contentAs=MyHashValue.class
+ *  )
+ *</pre>
+ *<p>
+ * NOTE: since version 1.2, annotation has also been applicable
+ * to (constructor) parameters
+ *
+ * @since 1.1
+ */
+@Target({ElementType.METHOD, ElementType.FIELD, ElementType.TYPE, ElementType.PARAMETER})
+@Retention(RetentionPolicy.RUNTIME)
+@JacksonAnnotation
+public @interface JsonDeserialize
+{
+    // // // Annotations for explicitly specifying deserializer
+
+    /**
+     * Deserializer class to use for deserializing associated value.
+     * Depending on what is annotated,
+     * value is either an instance of annotated class (used globablly
+     * anywhere where class deserializer is needed); or only used for
+     * deserializing property access via a setter method.
+     */
+    public Class<? extends JsonDeserializer<?>> using()
+        default JsonDeserializer.None.class;
+
+    /**
+     * Deserializer class to use for deserializing contents (elements
+     * of a Collection/array, values of Maps) of annotated property.
+     * Can only be used on instances (methods, fields, constructors),
+     * and not value classes themselves.
+     *
+     * @since 1.3
+     */
+    public Class<? extends JsonDeserializer<?>> contentUsing()
+        default JsonDeserializer.None.class;
+
+    /**
+     * Deserializer class to use for deserializing Map keys
+     * of annotated property.
+     * Can only be used on instances (methods, fields, constructors),
+     * and not value classes themselves.
+     *
+     * @since 1.3
+     */
+    public Class<? extends KeyDeserializer> keyUsing()
+        default KeyDeserializer.None.class;
+
+    // // // Annotations for explicitly specifying deserialization type
+    // // // (which is used for choosing deserializer, if not explicitly
+    // // // specified
+
+    /**
+     * Concrete type to deserialize values as, instead of type otherwise
+     * declared. Must be a subtype of declared type; otherwise an
+     * exception may be thrown by deserializer.
+     *<p>
+     * Bogus type {@link NoClass} can be used to indicate that declared
+     * type is used as is (i.e. this annotation property has no setting);
+     * this since annotation properties are not allowed to have null value.
+     *<p>
+     * Note: if {@link #using} is also used it has precedence
+     * (since it directly specified
+     * deserializer, whereas this would only be used to locate the
+     * deserializer)
+     * and value of this annotation property is ignored.
+     */
+    public Class<?> as() default NoClass.class;
+
+    /**
+     * Concrete type to deserialize keys of {@link java.util.Map} as,
+     * instead of type otherwise declared.
+     * Must be a subtype of declared type; otherwise an exception may be
+     * thrown by deserializer.
+     */
+    public Class<?> keyAs() default NoClass.class;
+
+    /**
+     * Concrete type to deserialize content (elements
+     * of a Collection/array, values of Maps) values as,
+     * instead of type otherwise declared.
+     * Must be a subtype of declared type; otherwise an exception may be
+     * thrown by deserializer.
+     */
+    public Class<?> contentAs() default NoClass.class;
+}

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

@@ -0,0 +1,31 @@
+package sh.calaba.org.codehaus.jackson.map.annotate;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+import sh.calaba.org.codehaus.jackson.annotate.JacksonAnnotation;
+
+/**
+ * Annotation used to indicate which logical filter is to be used
+ * for filtering out properties of type (class) annotated;
+ * association made by this annotation declaring ids of filters,
+ * and  {@link sh.calaba.org.codehaus.jackson.map.ObjectMapper} (or objects
+ * it delegates to) providing matching filters by id.
+ * Filters to use are of type
+ * {@link sh.calaba.org.codehaus.jackson.map.ser.BeanPropertyFilter} and
+ * are registered through {@link sh.calaba.org.codehaus.jackson.map.ObjectMapper}
+ * 
+ * @since 1.7
+ */
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@JacksonAnnotation
+public @interface JsonFilter
+{
+    /**
+     * Id of filter to use; if empty String (""), no filter is to be used.
+     */
+    public String value();
+}

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

@@ -0,0 +1,29 @@
+package sh.calaba.org.codehaus.jackson.map.annotate;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+import sh.calaba.org.codehaus.jackson.annotate.JacksonAnnotation;
+
+/**
+ * Annotation similar to {@link javax.xml.bind.annotation.XmlRootElement},
+ * used to indicate name to use for root-level wrapping, if wrapping is
+ * enabled. Annotation itself does not indicate that wrapping should
+ * be used; but if it is, name used for serialization should be name
+ * specified here, and deserializer will expect the name as well.
+ * 
+ * @since 1.9.0
+ */
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@JacksonAnnotation
+public @interface JsonRootName
+{
+    /**
+     * Root name to use if root-level wrapping is enabled.
+     */
+    public String value();
+
+}

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

@@ -0,0 +1,216 @@
+package sh.calaba.org.codehaus.jackson.map.annotate;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+import sh.calaba.org.codehaus.jackson.annotate.JacksonAnnotation;
+import sh.calaba.org.codehaus.jackson.map.*;
+
+/**
+ * Annotation used for configuring serialization aspects, by attaching
+ * to "getter" methods or fields, or to value classes.
+ * When annotating value classes, configuration is used for instances
+ * of the value class but can be overridden by more specific annotations
+ * (ones that attach to methods or fields).
+ *<p>
+ * An example annotation would be:
+ *<pre>
+ *  &#64;JsonSerialize(using=MySerializer.class,
+ *    as=MySubClass.class,
+ *    include=JsonSerialize.Inclusion.NON_NULL,
+ *    typing=JsonSerialize.Typing.STATIC
+ *  )
+ *</pre>
+ * (which would be redundant, since some properties block others:
+ * specifically, 'using' has precedence over 'as', which has precedence
+ * over 'typing' setting)
+ *<p>
+ * NOTE: since version 1.2, annotation has also been applicable
+ * to (constructor) parameters
+ *
+ * @since 1.1
+ */
+@Target({ElementType.METHOD, ElementType.FIELD, ElementType.TYPE, ElementType.PARAMETER})
+@Retention(RetentionPolicy.RUNTIME)
+@JacksonAnnotation
+public @interface JsonSerialize
+{
+    // // // Annotations for explicitly specifying deserializer
+
+    /**
+     * Serializer class to use for
+     * serializing associated value. Depending on what is annotated,
+     * value is either an instance of annotated class (used globablly
+     * anywhere where class serializer is needed); or only used for
+     * serializing property access via a getter method.
+     */
+    public Class<? extends JsonSerializer<?>> using() default JsonSerializer.None.class;
+
+    /**
+     * Serializer class to use for serializing contents (elements
+     * of a Collection/array, values of Maps) of annotated property.
+     * Can only be used on properties (methods, fields, constructors),
+     * and not value classes themselves (as they are typically generic)
+     *
+     * @since 1.8
+     */
+    public Class<? extends JsonSerializer<?>> contentUsing()
+        default JsonSerializer.None.class;
+
+    /**
+     * Serializer class to use for serializing Map keys
+     * of annotated property.
+     * Can only be used on properties (methods, fields, constructors),
+     * and not value classes themselves.
+     *
+     * @since 1.8
+     */
+    public Class<? extends JsonSerializer<?>> keyUsing()
+        default JsonSerializer.None.class;
+    
+    // // // Annotations for type handling, explicit declaration
+    // // // (type used for choosing deserializer, if not explicitly
+    // // // specified)
+
+    /**
+     * Supertype (of declared type, which itself is supertype of runtime type)
+     * to use as type when locating serializer to use.
+     *<p>
+     * Bogus type {@link NoClass} can be used to indicate that declared
+     * type is used as is (i.e. this annotation property has no setting);
+     * this since annotation properties are not allowed to have null value.
+     *<p>
+     * Note: if {@link #using} is also used it has precedence
+     * (since it directly specifies
+     * serializer, whereas this would only be used to locate the
+     * serializer)
+     * and value of this annotation property is ignored.
+     */
+    public Class<?> as() default NoClass.class;
+
+    /**
+     * Concrete type to serialize keys of {@link java.util.Map} as,
+     * instead of type otherwise declared.
+     * Must be a supertype of declared type; otherwise an exception may be
+     * thrown by serializer.
+     */
+    public Class<?> keyAs() default NoClass.class;
+
+    /**
+     * Concrete type to serialize content value (elements
+     * of a Collection/array, values of Maps) as,
+     * instead of type otherwise declared.
+     * Must be a supertype of declared type; otherwise an exception may be
+     * thrown by serializer.
+     */
+    public Class<?> contentAs() default NoClass.class;
+    
+    /**
+     * Whether type detection used is dynamic or static: that is,
+     * whether actual runtime type is used (dynamic), or just the
+     * declared type (static).
+     *
+     * @since 1.2
+     */
+    public Typing typing() default Typing.DYNAMIC;
+
+    // // // Annotation(s) for inclusion criteria
+
+    /**
+     * Which properties of annotated Bean are
+     * to be included in serialization (has no effect on other types
+     * like enums, primitives or collections).
+     * Choices are "all", "properties that have value other than null"
+     * and "properties that have non-default value" (i.e. default value
+     * being property setting for a Bean constructed with default no-arg
+     * constructor, often null).
+     *
+     */
+    public Inclusion include() default Inclusion.ALWAYS;
+    
+    /*
+    /**********************************************************
+    /* Value enumerations needed
+    /**********************************************************
+     */
+
+    /**
+     * Enumeration used with {@link JsonSerialize#include} property
+     * to define which properties
+     * of Java Beans are to be included in serialization
+     *
+     * @since 1.1
+     */
+    public enum Inclusion
+    {
+        /**
+         * Value that indicates that properties are to be always included,
+         * independent of value
+         */
+        ALWAYS,
+
+        /**
+         * Value that indicates that only properties with non-null
+         * values are to be included.
+         */
+        NON_NULL,
+
+        /**
+         * Value that indicates that only properties that have values
+         * that differ from default settings (meaning values they have
+         * when Bean is constructed with its no-arguments constructor)
+         * are to be included. Value is generally not useful with
+         * {@link java.util.Map}s, since they have no default values;
+         * and if used, works same as {@link #ALWAYS}.
+         */
+        NON_DEFAULT,
+
+        /**
+         * Value that indicates that only properties that have values
+         * that values that are null or what is considered empty are
+         * not to be included.
+         * Emptiness is defined for following type:
+         *<ul>
+         * <li>For {@link java.util.Collection}s and {@link java.util.Map}s,
+         *    method <code>isEmpty()</code> is called;
+         *   </li>
+         * <li>For Java arrays, empty arrays are ones with length of 0
+         *   </li>
+         * <li>For Java {@link java.lang.String}s, <code>length()</code> is called,
+         *   and return value of 0 indicates empty String (note that <code>String.isEmpty()</code>
+         *   was added in Java 1.6 and as such can not be used by Jackson
+         *   </li>
+         * <ul>
+         *  For other types, non-null values are to be included.
+         * 
+         * @since 1.9
+         */
+        NON_EMPTY
+        ;
+    }
+
+    /**
+     * Enumeration used with {@link JsonSerialize#typing} property
+     * to define whether type detection is based on dynamic runtime
+     * type (DYNAMIC) or declared type (STATIC).
+     * 
+     * @since 1.1
+     */
+    public enum Typing
+    {
+        /**
+         * Value that indicates that the actual dynamic runtime type is to
+         * be used.
+         */
+        DYNAMIC,
+
+        /**
+         * Value that indicates that the static declared type is to
+         * be used.
+         */
+        STATIC
+        ;
+    }
+}