testautoa 0.4.0.pre16

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
+        ;
+    }
+}

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

@@ -0,0 +1,35 @@
+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.jsontype.TypeIdResolver;
+
+/**
+ * Annotation that can be used to plug a custom type identifier handler
+ * ({@link TypeIdResolver})
+ * to be used by
+ * {@link sh.calaba.org.codehaus.jackson.map.TypeSerializer}s
+ * and {@link sh.calaba.org.codehaus.jackson.map.TypeDeserializer}s
+ * for converting between java types and type id included in JSON content.
+ * In simplest cases this can be a simple class with static mapping between
+ * type names and matching classes.
+ * 
+ * @author tatu
+ * @since 1.5
+ */
+@Target({ElementType.TYPE})
+@Retention(RetentionPolicy.RUNTIME)
+@JacksonAnnotation
+public @interface JsonTypeIdResolver
+{
+    /**
+     * Defines implementation class of {@link TypeIdResolver} to use for
+     * converting between external type id (type name) and actual
+     * type of object.
+     */
+    public Class<? extends TypeIdResolver> value();
+}

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

@@ -0,0 +1,28 @@
+package sh.calaba.org.codehaus.jackson.map.annotate;
+
+import java.lang.annotation.*;
+
+import sh.calaba.org.codehaus.jackson.annotate.JacksonAnnotation;
+import sh.calaba.org.codehaus.jackson.map.jsontype.TypeResolverBuilder;
+
+/**
+ * Annotation that can be used to explicitly define custom resolver
+ * used for handling serialization and deserialization of type information,
+ * needed for handling of polymorphic types (or sometimes just for linking
+ * abstract types to concrete types)
+ * 
+ * @since 1.5
+ */
+@Target({ElementType.TYPE})
+@Retention(RetentionPolicy.RUNTIME)
+@JacksonAnnotation
+public @interface JsonTypeResolver
+{
+    /**
+     * Defines implementation class of {@link TypeResolverBuilder} which is used to construct
+     * actual {@link sh.calaba.org.codehaus.jackson.map.TypeDeserializer} and {@link sh.calaba.org.codehaus.jackson.map.TypeDeserializer}
+     * instances that handle reading and writing addition type information needed to support polymorphic
+     * deserialization.
+     */
+    public Class<? extends TypeResolverBuilder<?>> value();
+}

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

@@ -0,0 +1,26 @@
+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.deser.ValueInstantiator;
+
+/**
+ * Annotation that can be used to indicate a {@link ValueInstantiator} to use
+ * for creating instances of specified type.
+ * 
+ * @since 1.9
+ */
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@JacksonAnnotation
+public @interface JsonValueInstantiator
+{
+    /**
+     * @return  {@link ValueInstantiator} to use for annotated type
+     */
+    public Class<? extends ValueInstantiator> value();
+}

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

@@ -0,0 +1,37 @@
+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 for indicating view(s) that the property
+ * that is defined by method or field annotated is part of.
+ *<p>
+ * An example annotation would be:
+ *<pre>
+ *  \@JsonView(BasicView.class)
+ *</pre>
+ * which would specify that property annotated would be included
+ * when processing (serializing, deserializing) View identified
+ * by <code>BasicView.class</code> (or its sub-class).
+ * If multiple View class identifiers are included, property will
+ * be part of all of them.
+ *
+ * @since 1.4
+ */
+
+@Target({ElementType.METHOD, ElementType.FIELD})
+@Retention(RetentionPolicy.RUNTIME)
+@JacksonAnnotation
+public @interface JsonView {
+    /**
+     * View or views that annotated element is part of. Views are identified
+     * by classes, and use expected class inheritance relationship: child
+     * views contain all elements parent views have, for example.
+     */
+    public Class<?>[] value() default { };
+}

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

@@ -0,0 +1,19 @@
+package sh.calaba.org.codehaus.jackson.map.annotate;
+
+/**
+ * Marker class used with annotations to indicate "no class". This is
+ * a silly but necessary work-around -- annotations can not take nulls
+ * as either default or explicit values. Hence for class values we must
+ * explicitly use a bogus placeholder to denote equivalent of
+ * "no class" (for which 'null' is usually the natural choice).
+ *<p>
+ * Note before version 1.4, this marker class was under
+ * "sh.calaba.org.codehaus.jackson.annotate". However, since it is only used
+ * by annotations in "sh.calaba.org.codehaus.jackson.map.annotate" (and not externally
+ * exposed), it was moved to that package as of version 1.5.
+ */
+public final class NoClass
+{
+    private NoClass() { }
+}
+

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

@@ -0,0 +1,5 @@
+/**
+ * Annotations that directly depend on Mapper classes (not just
+ * Jackson core) and are used for configuring Data Mapping functionality.
+ */
+package sh.calaba.org.codehaus.jackson.map.annotate;

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

@@ -0,0 +1,102 @@
+package sh.calaba.org.codehaus.jackson.map.deser;
+
+import java.io.IOException;
+
+import sh.calaba.org.codehaus.jackson.JsonParser;
+import sh.calaba.org.codehaus.jackson.JsonProcessingException;
+import sh.calaba.org.codehaus.jackson.map.*;
+import sh.calaba.org.codehaus.jackson.type.JavaType;
+
+/**
+ * Deserializer only used as placeholder for abstract types during polymorphic
+ * type handling deserialization. If so, there is no real deserializer associated
+ * with nominal type, just {@link TypeDeserializer}; and any calls that do not
+ * pass such resolver will result in an error.
+ * 
+ * @author tatu
+ * 
+ * @since 1.6
+ */
+public class AbstractDeserializer
+    extends JsonDeserializer<Object>
+{
+    protected final JavaType _baseType;
+
+    // support for "native" types, which require special care:
+    
+    protected final boolean _acceptString;
+    protected final boolean _acceptBoolean;
+    protected final boolean _acceptInt;
+    protected final boolean _acceptDouble;
+    
+    public AbstractDeserializer(JavaType bt)
+    {
+        _baseType = bt;
+        Class<?> cls = bt.getRawClass();
+        _acceptString = cls.isAssignableFrom(String.class);
+        _acceptBoolean = (cls == Boolean.TYPE) || cls.isAssignableFrom(Boolean.class);
+        _acceptInt = (cls == Integer.TYPE) || cls.isAssignableFrom(Integer.class);
+        _acceptDouble = (cls == Double.TYPE) || cls.isAssignableFrom(Double.class);
+    }
+
+    @Override
+    public Object deserializeWithType(JsonParser jp, DeserializationContext ctxt,
+            TypeDeserializer typeDeserializer)
+        throws IOException, JsonProcessingException
+    {
+        // First: support "natural" values (which are always serialized without type info!)
+        Object result = _deserializeIfNatural(jp, ctxt);
+        if (result != null) {
+            return result;
+        }
+        return typeDeserializer.deserializeTypedFromObject(jp, ctxt);
+    }
+
+    @Override
+    public Object deserialize(JsonParser jp, DeserializationContext ctxt)
+            throws IOException, JsonProcessingException
+    {
+        // This method should never be called...
+        throw ctxt.instantiationException(_baseType.getRawClass(), "abstract types can only be instantiated with additional type information");
+    }
+
+    protected Object _deserializeIfNatural(JsonParser jp, DeserializationContext ctxt)
+        throws IOException, JsonProcessingException
+    {
+        /* As per [JACKSON-417], there is a chance we might be "natular" types
+         * (String, Boolean, Integer, Double), which do not include any type information...
+         * Care must be taken to only return this if return type matches, however.
+         * Finally, we may have to consider possibility of custom handlers for
+         * these values: but for now this should work ok.
+         */
+        switch (jp.getCurrentToken()) {
+        case VALUE_STRING:
+            if (_acceptString) {
+                return jp.getText();
+            }
+            break;
+        case VALUE_NUMBER_INT:
+            if (_acceptInt) {
+                return jp.getIntValue();
+            }
+            break;
+
+        case VALUE_NUMBER_FLOAT:
+            if (_acceptDouble) {
+                return Double.valueOf(jp.getDoubleValue());
+            }
+            break;
+        case VALUE_TRUE:
+            if (_acceptBoolean) {
+                return Boolean.TRUE;
+            }
+            break;
+        case VALUE_FALSE:
+            if (_acceptBoolean) {
+                return Boolean.FALSE;
+            }
+            break;
+        }
+        return null;
+    }
+}

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

@@ -0,0 +1,28 @@
+package sh.calaba.org.codehaus.jackson.map.deser;
+
+import sh.calaba.org.codehaus.jackson.map.*;
+import sh.calaba.org.codehaus.jackson.map.type.ArrayType;
+
+/**
+ * @deprecated Since 1.9, use {@link sh.calaba.org.codehaus.jackson.map.deser.std.ObjectArrayDeserializer} instead.
+ */
+@Deprecated
+public class ArrayDeserializer
+    extends sh.calaba.org.codehaus.jackson.map.deser.std.ObjectArrayDeserializer
+{
+    /**
+     * @deprecated
+     */
+    @Deprecated
+    public ArrayDeserializer(ArrayType arrayType, JsonDeserializer<Object> elemDeser)
+    {
+        this(arrayType, elemDeser, null);
+    }
+
+    public ArrayDeserializer(ArrayType arrayType, JsonDeserializer<Object> elemDeser,
+            TypeDeserializer elemTypeDeser)
+    {
+        super(arrayType, elemDeser, elemTypeDeser);
+    }
+}
+

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

@@ -0,0 +1,11 @@
+package sh.calaba.org.codehaus.jackson.map.deser;
+
+/**
+ * @deprecated Since 1.9, use {@link sh.calaba.org.codehaus.jackson.map.deser.std.PrimitiveArrayDeserializers} instead.
+ */
+@Deprecated
+public class ArrayDeserializers
+    extends sh.calaba.org.codehaus.jackson.map.deser.std.PrimitiveArrayDeserializers
+{
+    private ArrayDeserializers() { super(); }
+}