calabash-android 0.5.2 → 0.5.3

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

@@ -1,41 +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 associated property is part of
- * two-way linkage between fields; and that its role is "child" (or "back") link.
- * Value type of the property must be a bean: it can not be a Collection, Map,
- * Array or enumeration.
- * Linkage is handled such that the property
- * annotated with this annotation is not serialized; and during deserialization,
- * its value is set to instance that has the "managed" (forward) link.
- *<p>
- * All references have logical name to allow handling multiple linkages; typical case
- * would be that where nodes have both parent/child and sibling linkages. If so,
- * pairs of references should be named differently.
- * It is an error for a class to have multiple back references with same name,
- * even if types pointed are different.
- *<p>
- * Note: only methods and fields can be annotated with this annotation: constructor
- * arguments should NOT be annotated, as they can not be either managed or back
- * references.
- * 
- * @author tatu
- */
-@Target({ElementType.FIELD, ElementType.METHOD})
-@Retention(RetentionPolicy.RUNTIME)
-@JacksonAnnotation
-public @interface JsonBackReference
-{
-    /**
-     * Logical have for the reference property pair; used to link managed and
-     * back references. Default name can be used if there is just single
-     * reference pair (for example, node class that just has parent/child linkage,
-     * consisting of one managed reference and matching back reference)
-     */
-    public String value() default "defaultReference";
-}

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

@@ -1,19 +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 constructors and factory
- * methods as one to use for instantiating new instances of the associated
- * class.
- */
-@Target({ElementType.METHOD, ElementType.CONSTRUCTOR})
-@Retention(RetentionPolicy.RUNTIME)
-@JacksonAnnotation
-public @interface JsonCreator
-{
-    // no values, since there's no property
-}

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

@@ -1,35 +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,
- * no-argument value-returning (non-void) method to be used as a "getter"
- * for a logical property,
- * as an alternative to recommended
- * {@link JsonProperty} annotation (which was introduced in version 1.1).
- *<p>
- * Getter means that when serializing Object instance of class that has
- * this method (possibly inherited from a super class), a call is made
- * through the method, and return value will be serialized as value of
- * the property.
- * 
- * @deprecated Use {@link JsonProperty} instead (deprecated since version 1.5)
- */
-@Target(ElementType.METHOD)
-@Retention(RetentionPolicy.RUNTIME)
-@JacksonAnnotation
-@Deprecated
-public @interface JsonGetter
-{
-    /**
-     * Defines name of the logical property this
-     * method is used to access ("get"); empty String means that
-     * name should be derived from the underlying method (using
-     * standard Bean name detection rules)
-     */
-    String value() default "";
-}

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

@@ -1,57 +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 is to be
- * ignored by introspection-based
- * serialization and deserialization functionality. That is, it should
- * not be consider a "getter", "setter" or "creator".
- *<p>
- * In addition, starting with Jackson 1.9, if this is the only annotation
- * associated with a property, it will also cause cause the whole
- * property to be ignored: that is, if setter has this annotation and
- * getter has no annotations, getter is also effectively ignored.
- * It is still possible for different accessors to use different
- * annotations; so if only "getter" is to be ignored, other accessors
- * (setter or field) would need explicit annotation to prevent
- * ignoral (usually {@link JsonProperty}).
- * <p>
- * For example, a "getter" method that would otherwise denote
- * a property (like, say, "getValue" to suggest property "value")
- * to serialize, would be ignored and no such property would
- * be output unless another annotation defines alternative method to use.
- *<p>
- * Before version 1.9, this annotation worked purely on method-by-method (or field-by-field)
- * basis; annotation on one method or field does not imply ignoring other methods
- * or fields. However, with version 1.9 and above, annotations associated
- * with various accessors (getter, setter, field, constructor parameter) of
- * a logical property are combined; meaning that annotations may be effectly
- * combined.
- *<p>
- * Annotation is usually used just a like a marker annotation, that
- * is, without explicitly defining 'value' argument (which defaults
- * to <code>true</code>): but argument can be explicitly defined.
- * This can be done to override an existing JsonIgnore by explictly
- * defining one with 'false' argument.
- *<p>
- * Annotation is similar to {@link javax.xml.bind.annotation.XmlTransient} 
- */
-@Target({ElementType.METHOD, ElementType.CONSTRUCTOR, ElementType.FIELD})
-@Retention(RetentionPolicy.RUNTIME)
-@JacksonAnnotation
-public @interface JsonIgnore
-{
-    /**
-     * 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/JsonIgnoreProperties.java

@@ -1,48 +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 that can be used to either suppress serialization of
- * properties (during serialization), or ignore processing of
- * JSON properties read (during deserialization).
- *<p>
- * Example:
- *<pre>
- * // to prevent specified fields from being serialized or deserialized
- * // (i.e. not include in JSON output; or being set even if they were included)
- * \@JsonIgnoreProperties({ "internalId", "secretKey" })
- * // To ignore any unknown properties in JSON input without exception:
- * \@JsonIgnoreProperties(ignoreUnknown=true)
- *</pre>
- *<p>
- * Only applicable to classes, not for properties (getters, setters, fields).
- * 
- * @since 1.4
- */
-@Target({ElementType.TYPE})
-@Retention(RetentionPolicy.RUNTIME)
-@JacksonAnnotation
-public @interface JsonIgnoreProperties
-{
-    /**
-     * Names of properties to ignore.
-     */
-    public String[] value() default { };
-
-    /**
-     * Property that defines whether it is ok to just ignore any
-     * unrecognized properties during deserialization.
-     * If true, all properties that are unrecognized -- that is,
-     * there are no setters or creators that accept them -- are
-     * ignored without warnings (although handlers for unknown
-     * properties, if any, will still be called) without
-     * exception.
-     *<p>
-     * Does not have any effect on serialization.
-     */
-    public boolean ignoreUnknown() default false;
-}

data/test-server/instrumentation-backend/src/sh/calaba/org/codehaus/jackson/annotate/JsonIgnoreType.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 all properties of annotated
- * type are to be ignored during serialization and deserialization.
- *<p>
- * Note: annotation does have boolean 'value' property (which defaults
- * to 'true'), so that it is actually possible to override value
- * using mix-in annotations.
- * 
- * @since 1.7
- */
-@Target({ElementType.TYPE})
-@Retention(RetentionPolicy.RUNTIME)
-@JacksonAnnotation
-public @interface JsonIgnoreType
-{
-    /**
-     * 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" ("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/JsonManagedReference.java

@@ -1,41 +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 annotated property is part of
- * two-way linkage between fields; and that its role is "parent" (or "forward") link.
- * Value type (class) of property must have a single compatible property annotated with
- * {@link JsonBackReference}. Linkage is handled such that the property
- * annotated with this annotation is handled normally (serialized normally, no
- * special handling for deserialization); it is the matching back reference
- * that requires special handling
- *<p>
- * All references have logical name to allow handling multiple linkages; typical case
- * would be that where nodes have both parent/child and sibling linkages. If so,
- * pairs of references should be named differently.
- * It is an error for a class too have multiple managed references with same name,
- * even if types pointed are different.
- *<p>
- * Note: only methods and fields can be annotated with this annotation: constructor
- * arguments should NOT be annotated, as they can not be either managed or back
- * references.
- * 
- * @author tatu
- */
-@Target({ElementType.FIELD, ElementType.METHOD})
-@Retention(RetentionPolicy.RUNTIME)
-@JacksonAnnotation
-public @interface JsonManagedReference
-{
-    /**
-     * Logical have for the reference property pair; used to link managed and
-     * back references. Default name can be used if there is just single
-     * reference pair (for example, node class that just has parent/child linkage,
-     * consisting of one managed reference and matching back reference)
-     */
-    public String value() default "defaultReference";
-}

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

@@ -1,90 +0,0 @@
-package sh.calaba.org.codehaus.jackson.annotate;
-
-/**
- * Enumeration used to define kinds of methods that annotations like
- * {@link JsonAutoDetect} apply to.
- *<p>
- * In addition to actual method types (GETTER, SETTER, CREATOR; and
- * sort-of-method, FIELD), 2 pseudo-types
- * are defined for convenience: <code>ALWAYS</code> and <code>NONE</code>. These
- * can be used to indicate, all or none of available method types (respectively),
- * for use by annotations that takes <code>JsonMethod</code> argument.
- */
-public enum JsonMethod
-{
-    /**
-     * Getters are methods used to get a POJO field value for serialization,
-     * or, under certain conditions also for de-serialization. Latter
-     * can be used for effectively setting Collection or Map values
-     * in absence of setters, iff returned value is not a copy but
-     * actual value of the logical property.
-     *<p>
-     * Since version 1.3, this does <b>NOT</b> include "is getters" (methods
-     * that return boolean and named 'isXxx' for property 'xxx'); instead,
-     * {@link #IS_GETTER} is used}.
-     */
-    GETTER,
-
-    /**
-     * Setters are methods used to set a POJO value for deserialization.
-     */
-    SETTER,
-
-        /**
-         * Creators are constructors and (static) factory methods used to
-         * construct POJO instances for deserialization
-         */
-        CREATOR,
-
-        /**
-         * Field refers to fields of regular Java objects. Although
-         * they are not really methods, addition of optional field-discovery
-         * in version 1.1 meant that there was need to enable/disable
-         * their auto-detection, and this is the place to add it in.
-         *
-         * @since 1.1
-         */
-        FIELD,
-
-        /**
-         * "Is getters" are getter-like methods that are named "isXxx"
-         * (instead of "getXxx" for getters) and return boolean value
-         * (either primitive, or {@link java.lang.Boolean}).
-         *
-         * @since 1.3
-         */
-        IS_GETTER,
-
-        /**
-         * This pseudo-type indicates that none of real types is included
-         */
-        NONE,
-
-        /**
-         * This pseudo-type indicates that all of real types are included
-         */
-        ALL
-        ;
-
-    private JsonMethod() { }
-
-    public boolean creatorEnabled() {
-        return (this == CREATOR) || (this == ALL);
-    }
-
-    public boolean getterEnabled() {
-        return (this == GETTER) || (this == ALL);
-    }
-
-    public boolean isGetterEnabled() {
-        return (this == IS_GETTER) || (this == ALL);
-    }
-
-    public boolean setterEnabled() {
-        return (this == SETTER) || (this == ALL);
-    }
-
-    public boolean fieldEnabled() {
-        return (this == FIELD) || (this == ALL);
-    }
-}

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

@@ -1,38 +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
- * method as a "setter" or "getter" for a logical property
- * (depending on its signature),
- * or non-static object field to be used (serialized, deserialized) as
- * a logical property.
- *<p>
- * Default value ("") indicates that the field name is used
- * as the property name without any modifications, but it
- * can be specified to non-empty value to specify different
- * name. Property name refers to name used externally, as
- * the field name in Json objects.
- *<p>
- * NOTE: since version 1.1, annotation has also been applicable
- * to fields (not with 1.0).
- *<p>
- * NOTE: since version 1.2, annotation has also been applicable
- * to (constructor) parameters
- */
-@Target({ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER})
-@Retention(RetentionPolicy.RUNTIME)
-@JacksonAnnotation
-public @interface JsonProperty
-{
-    /**
-     * Defines name of the logical property, i.e. Json object field
-     * name to use for the property: if empty String (which is the
-     * default), will use name of the field that is annotated.
-     */
-    String value() default "";
-}

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

@@ -1,46 +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 that can be used to define ordering (possibly partial) to use
- * when serializing object properties. Properties included in annotation
- * declaration will be serialized first (in defined order), followed by
- * any properties not included in the definition.
- * Annotation definition will override any implicit orderings (such as
- * guarantee that Creator-properties are serialized before non-creator
- * properties)
- *<p>
- * Examples:
- *<pre>
- *  // ensure that "id" and "name" are output before other properties
- *  <div>@</div>JsonPropertyOrder({ "id", "name" })
- *  // order any properties that don't have explicit setting using alphabetic order
- *  <div>@</div>JsonPropertyOrder(alphabetic=true)
- *</pre>
- *<p>
- * This annotation has no effect on deserialization.
- * 
- * @since 1.4
- */
-@Target({ElementType.TYPE})
-@Retention(RetentionPolicy.RUNTIME)
-@JacksonAnnotation
-public @interface JsonPropertyOrder
-{
-    /**
-     * Order in which properties of annotated object are to be serialized in.
-     */
-    public String[] value() default { };
-
-    /**
-     * Property that defines what to do regarding ordering of properties
-     * not explicitly included in annotation instance. If set to true,
-     * they will be alphabetically ordered; if false, order is
-     * undefined (default setting)
-     */
-    public boolean alphabetic() default false;
-}