calabash-android 0.4.7.pre4 → 0.4.7.pre6

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

@@ -1,33 +0,0 @@
-package sh.calaba.org.codehaus.jackson.annotate;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * Marker annotation that indicates that the annotated method
- * or field should be serialized by including literal String value
- * of the property as is, without quoting of characters.
- * This can be useful for injecting values already serialized in JSON or 
- * passing javascript function definitions from server to a javascript client.
- *<p>
- * Warning: the resulting JSON stream may be invalid depending on your input value.
- * 
- * @since 1.7.0
- */
-@Target( { ElementType.METHOD, ElementType.FIELD })
-@Retention(RetentionPolicy.RUNTIME)
-@JacksonAnnotation
-public @interface JsonRawValue
-{
-    /**
-     * Optional argument that defines whether this annotation is active
-     * or not. The only use for value 'false' if for overriding purposes
-     * (which is not needed often); most likely it is needed for use
-     * with "mix-in annotations" (aka "annotation overrides").
-     * For most cases, however, default value of "true" is just fine
-     * and should be omitted.
-     */
-    boolean value() default true;
-}

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

@@ -1,33 +0,0 @@
-package sh.calaba.org.codehaus.jackson.annotate;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * Marker annotation that can be used to define a non-static,
- * single-argument method to be used as a "setter" for a logical property
- * as an alternative to recommended
- * {@link JsonProperty} annotation (which was introduced in version 1.1).
- *<p>
- * Setter means that when a property with matching name is encountered in
- * JSON content, this method will be used to set value of the property.
- *<p>
- * NOTE: this annotation was briefly deprecated for version 1.5; but has
- * since been un-deprecated to both allow for asymmetric naming (possibly
- * different name when reading and writing JSON), and more importantly to
- * allow multi-argument setter method in future.
- */
-@Target(ElementType.METHOD)
-@Retention(RetentionPolicy.RUNTIME)
-@JacksonAnnotation
-public @interface JsonSetter
-{
-    /**
-     * Optional default argument that defines logical property this
-     * method is used to modify ("set"); this is the property
-     * name used in JSON content.
-     */
-    String value() default "";
-}

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

@@ -1,44 +0,0 @@
-package sh.calaba.org.codehaus.jackson.annotate;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * Annotation used with {@link JsonTypeInfo} to indicate sub types of serializable
- * polymorphic types, and to associate logical names used within JSON content
- * (which is more portable than using physical Java class names).
- * 
- * @since 1.5 (but available to fields, methods and constructor params only since 1.8)
- */
-@Target({ElementType.TYPE, ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER})
-@Retention(RetentionPolicy.RUNTIME)
-@JacksonAnnotation
-public @interface JsonSubTypes {
-    /**
-     * Subtypes of the annotated type (annotated class, or property value type
-     * associated with the annotated method). These will be checked recursively
-     * so that types can be defined by only including direct subtypes.
-     */
-    public Type[] value();
-
-    /**
-     * Definition of a subtype, along with optional name. If name is missing, class
-     * of the type will be checked for {@link JsonTypeName} annotation; and if that
-     * is also missing or empty, a default
-     * name will be constructed by type id mechanism.
-     * Default name is usually based on class name.
-     */
-    public @interface Type {
-        /**
-         * Class of the subtype
-         */
-        public Class<?> value();
-
-        /**
-         * Logical type name used as the type identifier for the class
-         */
-        public String name() default "";
-    }
-}

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

@@ -1,236 +0,0 @@
-package sh.calaba.org.codehaus.jackson.annotate;
-
-import java.lang.annotation.*;
-
-/**
- * Annotation used for configuring details of if and how type information is
- * used with JSON serialization and deserialization, to preserve information
- * about actual class of Object instances. This is necessarily for polymorphic
- * types, and may also be needed to link abstract declared types and matching
- * concrete implementation.
- *<p>
- * Some examples of typical annotations:
- *<pre>
- *  // Include Java class name ("com.myempl.ImplClass") as JSON property "class"
- *  &#064;JsonTypeInfo(use=Id.CLASS, include=As.PROPERTY, property="class")
- *  
- *  // Include logical type name (defined in impl classes) as wrapper; 2 annotations
- *  &#064;JsonTypeInfo(use=Id.NAME, include=As.WRAPPER_OBJECT)
- *  &#064;JsonSubTypes({com.myemp.Impl1.class, com.myempl.Impl2.class})
- *</pre>
- * Alternatively you can also define fully customized type handling by using
- * {@link sh.calaba.org.codehaus.jackson.map.annotate.JsonTypeResolver} annotation.
- *<p>
- * NOTE: originally this annotation was only available to use with types (classes),
- * but starting with 1.7, it is also allowed for properties (fields, methods,
- * constructor parameters).
- *<p>
- * When used for properties (fields, methods), this annotation applies
- * to <b>values</b>: so when applied to structure types
- * (like {@link java.util.Collection}, {@link java.util.Map}, arrays),
- * will apply to contained values, not the container;
- * for non-structured types there is no difference.
- * This is identical to how JAXB handles type information
- * annotations; and is chosen since it is the dominant use case.
- * There is no per-property way to force type information to be included
- * for type of container (structured type); for container types one has
- * to use annotation for type declaration.
- * 
- * @see sh.calaba.org.codehaus.jackson.map.annotate.JsonTypeResolver
- * 
- * @since 1.5 (but available to fields, methods and constructor parameters since 1.7)
- * 
- * @author tatu
- */
-@Target({ElementType.TYPE, ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER})
-@Retention(RetentionPolicy.RUNTIME)
-@JacksonAnnotation
-public @interface JsonTypeInfo
-{    
-    /*
-    /**********************************************************
-    /* Value enumerations used for properties
-    /**********************************************************
-     */
-    
-    /**
-     * Definition of different type identifiers that can be included in JSON
-     * during serialization, and used for deserialization.
-     */
-    public enum Id {
-        /**
-         * This means that no explicit type metadata is included, and typing is
-         * purely done using contextual information possibly augmented with other
-         * annotations.
-         *<p>
-         * Note: no {@link sh.calaba.org.codehaus.jackson.map.jsontype.TypeIdResolver}
-         * is constructed if this value is used.
-         */
-        NONE(null),
-
-        /**
-         * Means that fully-qualified Java class name is used as the type identifier.
-         */
-        CLASS("@class"),
-
-        /**
-         * Means that Java class name with minimal path is used as the type identifier.
-         * Minimal means that only the class name, and that part of preceding Java
-         * package name is included that is needed to construct fully-qualified name
-         * given fully-qualified name of the declared supertype; additionally a single
-         * leading dot ('.') must be used to indicate that partial class name is used.
-         * For example, for supertype "com.foobar.Base", and concrete type
-         * "com.foo.Impl", only ".Impl" would be included; and for "com.foo.impl.Impl2"
-         * only ".impl.Impl2" would be included.<br />
-         * <b>NOTE</b>: leading dot ('.') MUST be used to denote partial (minimal) name;
-         * if it is missing, value is assumed to be fully-qualified name. Fully-qualified
-         * name is used in cases where subtypes are not in same package (or sub-package
-         * thereof) as base class.
-         *<p>
-         * If all related classes are in the same Java package, this option can reduce
-         * amount of type information overhead, especially for small types.
-         * However, please note that using this alternative is inherently risky since it
-         * assumes that the
-         * supertype can be reliably detected. Given that it is based on declared type
-         * (since ultimate supertype, <code>java.lang.Object</code> would not be very
-         * useful reference point), this may not always work as expected.
-         */
-        MINIMAL_CLASS("@c"),
-
-        /**
-         * Means that logical type name is used as type information; name will then need
-         * to be separately resolved to actual concrete type (Class).
-         */
-        NAME("@type"),
-
-        /**
-         * Means that typing mechanism uses customized handling, with possibly
-         * custom configuration. This means that semantics of other properties is
-         * not defined by Jackson package, but by the custom implementation.
-         */
-        CUSTOM(null)
-        ;
-
-        private final String _defaultPropertyName;
-
-        private Id(String defProp) {
-            _defaultPropertyName = defProp;
-        }
-
-        public String getDefaultPropertyName() { return _defaultPropertyName; }
-    }
-
-    /**
-     * Definition of standard type inclusion mechanisms for type metadata.
-     * Used for standard metadata types, except for {@link Id#NONE}.
-     * May or may not be used for custom types ({@link Id#CUSTOM}).
-     */
-    public enum As {
-        /**
-         * Inclusion mechanism that uses a single configurable property, included
-         * along with actual data (POJO properties) as a separate meta-property.
-         * <p>
-         * Default choice for inclusion.
-         */
-        PROPERTY,
-
-        /**
-         * Inclusion mechanism that wraps typed JSON value (POJO
-         * serialized as JSON) in
-         * a JSON Object that has a single entry,
-         * where field name is serialized type identifier,
-         * and value is the actual JSON value.
-         *<p>
-         * Note: can only be used if type information can be serialized as
-         * String. This is true for standard type metadata types, but not
-         * necessarily for custom types.
-         */
-        WRAPPER_OBJECT,
-
-        /**
-         * Inclusion mechanism that wraps typed JSON value (POJO
-         * serialized as JSON) in
-         * a 2-element JSON array: first element is the serialized
-         * type identifier, and second element the serialized POJO
-         * as JSON Object.
-         */
-        WRAPPER_ARRAY,
-        
-        /**
-         * Inclusion mechanism similar to <code>PROPERTY</code>, except that
-         * property is included one-level higher in hierarchy, i.e. as sibling
-         * property at same level as JSON Object to type.
-         * Note that this choice <b>can only be used for properties</b>, not
-         * for types (classes). Trying to use it for classes will result in
-         * inclusion strategy of basic <code>PROPERTY</code> instead.
-         * 
-         * @since 1.9
-         */
-        EXTERNAL_PROPERTY
-        ;
-    }
-    
-    /*
-    /**********************************************************
-    /* Annotation properties
-    /**********************************************************
-     */
-    
-    /**
-     * What kind of type metadata is to be used for serializing and deserializing
-     * type information for instances of annotated type (and its subtypes
-     * unless overridden)
-     */
-    public Id use();    
-    
-    /**
-     * What mechanism is used for including type metadata (if any; for
-     * {@link Id#NONE} nothing is included). Default
-     *<p>
-     * Note that for type metadata type of {@link Id#CUSTOM},
-     * this setting may or may not have any effect.
-     */
-    public As include() default As.PROPERTY;
-
-    /**
-     * Property names used when type inclusion method ({@link As#PROPERTY}) is used
-     * (or possibly when using type metadata of type {@link Id#CUSTOM}).
-     *<p>
-     * Default property name used if this property is not explicitly defined
-     * (or is set to empty String) is based on
-     * type metadata type ({@link #use}) used.
-     */
-    public String property() default "";
-
-    /**
-     * Optional property that can be used to specify default implementation
-     * class to use if type identifier is either not present, or can not
-     * be mapped to a registered type (which can occur for ids, but not when
-     * specifying explicit class to use).
-     *<p>
-     * Note that while this property allows specification of the default
-     * implementation to use, it does not help with structural issues that
-     * may arise if type information is missing. This means that most often
-     * this is used with type-name -based resolution, to cover cases
-     * where new sub-types are added, but base type is not changed to
-     * reference new sub-types.
-     * 
-     * @since 1.9
-     */
-    public Class<?> defaultImpl() default None.class;
-
-    /*
-    /**********************************************************
-    /* Helper classes
-    /**********************************************************
-     */
-
-    /**
-     * This marker class that is only to be used with <code>defaultImpl</code>
-     * annotation property, to indicate that there is no default implementation
-     * specified.
-     * 
-     * @since 1.9
-     */
-    public abstract static class None { }
-}

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

@@ -1,28 +0,0 @@
-package sh.calaba.org.codehaus.jackson.annotate;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-
-/**
- * Annotation used for binding logical name that the annotated class
- * has. Used with {@link JsonTypeInfo} (and specifically its
- * {@link JsonTypeInfo#use} property) to establish relationship
- * between type names and types.
- * 
- * @since 1.5
- * 
- * @author tatu
- */
-@Target({ElementType.TYPE})
-@Retention(RetentionPolicy.RUNTIME)
-@JacksonAnnotation
-public @interface JsonTypeName {
-    /**
-     * Logical type name for annotated type. If missing (or defined as Empty String),
-     * defaults to using non-qualified class name as the type.
-     */
-    public String value() default "";
-}

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

@@ -1,76 +0,0 @@
-package sh.calaba.org.codehaus.jackson.annotate;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * Annotation used to indicate that a property should be serialized
- * "unwrapped"; that is, if it would be serialized as JSON Object, its
- * properties are instead included as properties of its containing
- * Object. For example, consider case of POJO like:
- * 
- *<pre>
- *  public class Parent {
- *    public int age;
- *    public Name name;
- *  }
- *  public class Name {
- *    public String first, last;
- *  }
- *</pre>  
- * which would normally be serialized as follows (assuming @JsonUnwrapped
- * had no effect):
- *<pre>
- *  {
- *    "age" : 18,
- *    "name" : {
- *      "first" : "Joey",
- *      "last" : "Sixpack"
- *    }
- *  }
- *</pre>
- * can be changed to this:
- *<pre>
- *  {
- *    "age" : 18,
- *    "first" : "Joey",
- *    "last" : "Sixpack"
- *  }
- *</pre>
- * by changing Parent class to:
- *<pre>
- *  public class Parent {
- *    public int age;
- *    \@JsonUnwrapped
- *    public Name name;
- *  }
- *</pre>
- * Annotation can only be added to properties, and not classes, as it is contextual.
- *<p>
- * Also note that annotation only applies if
- *<ul>
- * <li>Value is serialized as JSON Object
- *   </li>
- * <li>Serialization is done using <code>BeanSerializer</code>, not a custom serializer
- *   </li>
- * <li>No type information is added; if type information needs to be added, structure can
- *   not be altered regardless of inclusion strategy; so annotation is basically ignored.
- *   </li>
- * </ul>
- * 
- * @since 1.9
- */
-@Target({ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER})
-@Retention(RetentionPolicy.RUNTIME)
-@JacksonAnnotation
-public @interface JsonUnwrapped
-{
-    /**
-     * Property that is usually only used when overriding (masking) annotations,
-     * using mix-in annotations. Otherwise default value of 'true' is fine, and
-     * value need not be explicitly included.
-     */
-    boolean enabled() default true;
-}