testautoa 0.4.0.pre16

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

@@ -0,0 +1,90 @@
+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

@@ -0,0 +1,38 @@
+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

@@ -0,0 +1,46 @@
+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;
+}

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

@@ -0,0 +1,33 @@
+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

@@ -0,0 +1,33 @@
+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

@@ -0,0 +1,44 @@
+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

@@ -0,0 +1,236 @@
+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

@@ -0,0 +1,28 @@
+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

@@ -0,0 +1,76 @@
+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;
+}

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

@@ -0,0 +1,46 @@
+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 similar to
+ * {@link javax.xml.bind.annotation.XmlValue} 
+ * that indicates that results of the annotated "getter" method
+ * (which means signature must be that of getters; non-void return
+ * type, no args) is to be used as the single value to serialize
+ * for the instance. Usually value will be of a simple scalar type
+ * (String or Number), but it can be any serializable type (Collection,
+ * Map or Bean).
+ *<p>
+ * At most one method of a Class can be annotated with this annotation;
+ * if more than one is found, an exception may be thrown.
+ * Also, if method signature is not compatible with Getters, an exception
+ * may be thrown.
+ * Whether exception is thrown or not is an implementation detail (due
+ * to filtering during introspection, some annotations may be skipped)
+ * and applications should not rely on specific behavior.
+ *<p>
+ * A typical use case is that of annotating <code>toString()</code>
+ * method so that returned String value is Object's Json serialization.
+ *<p>
+ * Boolean argument is only used so that sub-classes can "disable"
+ * annotation if necessary.
+ */
+@Target({ElementType.METHOD})
+@Retention(RetentionPolicy.RUNTIME)
+@JacksonAnnotation
+public @interface JsonValue
+{
+    /**
+     * Optional argument that defines whether this annotation is active
+     * or not. The only use for value 'false' if for overriding purposes.
+     * Overriding may be necessary when used
+     * 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;
+}