testautoa 0.4.0.pre16

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

@@ -0,0 +1,118 @@
+package sh.calaba.org.codehaus.jackson.map;
+
+import java.io.IOException;
+
+import sh.calaba.org.codehaus.jackson.JsonParser;
+import sh.calaba.org.codehaus.jackson.JsonProcessingException;
+import sh.calaba.org.codehaus.jackson.annotate.JsonTypeInfo.As;
+import sh.calaba.org.codehaus.jackson.map.jsontype.TypeIdResolver;
+
+/**
+ * Interface for deserializing type information from JSON content, to
+ * type-safely deserialize data into correct polymorphic instance
+ * (when type inclusion has been enabled for type handled).
+ *<p>
+ * Separate deserialization methods are needed because serialized
+ * form for inclusion mechanism {@link As#PROPERTY}
+ * is slighty different if value is not expressed as JSON Object:
+ * and as such both type deserializer and serializer need to
+ * JSON Object form (array, object or other (== scalar)) being
+ * used.
+ * 
+ * @since 1.5
+ * @author tatus
+ */
+public abstract class TypeDeserializer
+{
+    /*
+    /**********************************************************
+    /* Introspection
+    /**********************************************************
+     */
+
+    /**
+     * Accessor for type information inclusion method
+     * that deserializer uses; indicates how type information
+     * is (expected to be) embedded in JSON input.
+     */
+    public abstract As getTypeInclusion();
+
+    /**
+     * Name of property that contains type information, if
+     * property-based inclusion is used.
+     */
+    public abstract String getPropertyName();
+
+    /**
+     * Accessor for object that handles conversions between
+     * types and matching type ids.
+     */
+    public abstract TypeIdResolver getTypeIdResolver();
+
+    /**
+     * Accessor for "default implementation" type; optionally defined
+     * class to use in cases where type id is not
+     * accessible for some reason (either missing, or can not be
+     * resolved)
+     * 
+     * @since 1.9
+     */
+    public abstract Class<?> getDefaultImpl();
+    
+    /*
+    /*********************************************************
+    /* Type deserialization methods
+    /**********************************************************
+     */
+
+    /**
+     * Method called to let this type deserializer handle 
+     * deserialization of "typed" object, when value itself
+     * is serialized as JSON Object (regardless of Java type).
+     * Method needs to figure out intended
+     * polymorphic type, locate {@link JsonDeserializer} to use, and
+     * call it with JSON data to deserializer (which does not contain
+     * type information).
+     */
+    public abstract Object deserializeTypedFromObject(JsonParser jp, DeserializationContext ctxt)
+        throws IOException, JsonProcessingException;
+
+    /**
+     * Method called to let this type deserializer handle 
+     * deserialization of "typed" object, when value itself
+     * is serialized as JSON Array (regardless of Java type).
+     * Method needs to figure out intended
+     * polymorphic type, locate {@link JsonDeserializer} to use, and
+     * call it with JSON data to deserializer (which does not contain
+     * type information).
+     */
+    public abstract Object deserializeTypedFromArray(JsonParser jp, DeserializationContext ctxt)
+        throws IOException, JsonProcessingException;
+
+    /**
+     * Method called to let this type deserializer handle 
+     * deserialization of "typed" object, when value itself
+     * is serialized as a scalar JSON value (something other
+     * than Array or Object), regardless of Java type.
+     * Method needs to figure out intended
+     * polymorphic type, locate {@link JsonDeserializer} to use, and
+     * call it with JSON data to deserializer (which does not contain
+     * type information).
+     */
+    public abstract Object deserializeTypedFromScalar(JsonParser jp, DeserializationContext ctxt)
+        throws IOException, JsonProcessingException;
+
+    /**
+     * Method called to let this type deserializer handle 
+     * deserialization of "typed" object, when value itself
+     * may have been serialized using any kind of JSON value
+     * (Array, Object, scalar). Should only be called if JSON
+     * serialization is polymorphic (not Java type); for example when
+     * using JSON node representation, or "untyped" Java object
+     * (which may be Map, Collection, wrapper/primitive etc).
+     */
+    public abstract Object deserializeTypedFromAny(JsonParser jp, DeserializationContext ctxt)
+        throws IOException, JsonProcessingException;
+
+}
+    

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

@@ -0,0 +1,164 @@
+package sh.calaba.org.codehaus.jackson.map;
+
+import java.io.IOException;
+
+import sh.calaba.org.codehaus.jackson.JsonGenerator;
+import sh.calaba.org.codehaus.jackson.JsonProcessingException;
+import sh.calaba.org.codehaus.jackson.annotate.JsonTypeInfo;
+import sh.calaba.org.codehaus.jackson.map.jsontype.TypeIdResolver;
+
+/**
+ * Interface for serializing type information regarding instances of specified
+ * base type (super class), so that exact subtype can be properly deserialized
+ * later on. These instances are to be called by regular
+ * {@link sh.calaba.org.codehaus.jackson.map.JsonSerializer}s using proper contextual
+ * calls, to add type information using mechanism type serializer was
+ * configured with.
+ * 
+ * @since 1.5
+ * @author tatus
+ */
+public abstract class TypeSerializer
+{
+    /*
+    /**********************************************************
+    /* Introspection
+    /**********************************************************
+     */
+
+    /**
+     * Accessor for type information inclusion method
+     * that serializer uses; indicates how type information
+     * is embedded in resulting JSON.
+     */
+    public abstract JsonTypeInfo.As getTypeInclusion();
+
+    /**
+     * Name of property that contains type information, if
+     * property-based inclusion is used.
+     */
+    public abstract String getPropertyName();
+    
+    /**
+     * Accessor for object that handles conversions between
+     * types and matching type ids.
+     */
+    public abstract TypeIdResolver getTypeIdResolver();
+    
+    /*
+    /**********************************************************
+    /* Type serialization methods
+    /**********************************************************
+     */
+    
+    /**
+     * Method called to write initial part of type information for given
+     * value, when it will be output as scalar JSON value (not as JSON
+     * Object or Array).
+     * This means that the context after call can not be that of JSON Object;
+     * it may be Array or root context.
+     * 
+     * @param value Value that will be serialized, for which type information is
+     *   to be written
+     * @param jgen Generator to use for writing type information
+     */
+    public abstract void writeTypePrefixForScalar(Object value, JsonGenerator jgen)
+        throws IOException, JsonProcessingException;
+
+    /**
+     * Method called to write initial part of type information for given
+     * value, when it will be output as JSON Object value (not as JSON
+     * Array or scalar).
+     * This means that context after call must be JSON Object, meaning that
+     * caller can then proceed to output field entries.
+     * 
+     * @param value Value that will be serialized, for which type information is
+     *   to be written
+     * @param jgen Generator to use for writing type information
+     */
+    public abstract void writeTypePrefixForObject(Object value, JsonGenerator jgen)
+        throws IOException, JsonProcessingException;
+
+    /**
+     * Method called to write initial part of type information for given
+     * value, when it will be output as JSON Array value (not as JSON
+     * Object or scalar).
+     * This means that context after call must be JSON Array, that is, there
+     * must be an open START_ARRAY to write contents in.
+     * 
+     * @param value Value that will be serialized, for which type information is
+     *   to be written
+     * @param jgen Generator to use for writing type information
+     */
+    public abstract void writeTypePrefixForArray(Object value, JsonGenerator jgen)
+        throws IOException, JsonProcessingException;
+    
+    /**
+     * Method called after value has been serialized, to close any scopes opened
+     * by earlier matching call to {@link #writeTypePrefixForScalar}.
+     * Actual action to take may depend on various factors, but has to match with
+     * action {@link #writeTypePrefixForScalar} did (close array or object; or do nothing).
+     */
+    public abstract void writeTypeSuffixForScalar(Object value, JsonGenerator jgen)
+        throws IOException, JsonProcessingException;
+
+    /**
+     * Method called after value has been serialized, to close any scopes opened
+     * by earlier matching call to {@link #writeTypePrefixForObject}.
+     * It needs to write closing END_OBJECT marker, and any other decoration
+     * that needs to be matched.
+     */
+    public abstract void writeTypeSuffixForObject(Object value, JsonGenerator jgen)
+        throws IOException, JsonProcessingException;
+
+    /**
+     * Method called after value has been serialized, to close any scopes opened
+     * by earlier matching call to {@link #writeTypeSuffixForScalar}.
+     * It needs to write closing END_ARRAY marker, and any other decoration
+     * that needs to be matched.
+     */
+    public abstract void writeTypeSuffixForArray(Object value, JsonGenerator jgen)
+        throws IOException, JsonProcessingException;
+
+    /**
+     * Alternative version of the prefix-for-scalar method, which is given
+     * actual type to use (instead of using exact type of the value); typically
+     * a super type of actual value type
+     * 
+     * @since 1.8
+     */
+    public void writeTypePrefixForScalar(Object value, JsonGenerator jgen,
+            Class<?> type)
+        throws IOException, JsonProcessingException
+    {
+        writeTypePrefixForScalar(value, jgen);
+    }
+
+    /**
+     * Alternative version of the prefix-for-object method, which is given
+     * actual type to use (instead of using exact type of the value); typically
+     * a super type of actual value type
+     * 
+     * @since 1.8
+     */
+    public void writeTypePrefixForObject(Object value, JsonGenerator jgen,
+            Class<?> type)
+        throws IOException, JsonProcessingException
+    {
+        writeTypePrefixForObject(value, jgen);
+    }
+
+    /**
+     * Alternative version of the prefix-for-array method, which is given
+     * actual type to use (instead of using exact type of the value); typically
+     * a super type of actual value type
+     * 
+     * @since 1.8
+     */
+    public void writeTypePrefixForArray(Object value, JsonGenerator jgen,
+            Class<?> type)
+        throws IOException, JsonProcessingException
+    {
+        writeTypePrefixForArray(value, jgen);
+    }
+}

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

@@ -0,0 +1,30 @@
+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;
+
+/**
+ * Jackson-specific annotation used for indicating that value of
+ * annotated property will be "injected", i.e. set based on value
+ * configured by <code>ObjectMapper</code> (usually on per-call basis).
+ * Usually property is not deserialized from JSON, although it possible
+ * to have injected value as default and still allow optional override
+ * from JSON.
+ * 
+ * @since 1.9
+ */
+@Target({ElementType.METHOD, ElementType.FIELD, ElementType.PARAMETER})
+@Retention(RetentionPolicy.RUNTIME)
+@JacksonAnnotation
+public @interface JacksonInject
+{
+    /**
+     * Logical id of the value to inject; if not specified (or specified
+     * as empty String), will use id based on declared type of property.
+     */
+    public String value() default "";
+}

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