testautoa 0.4.0.pre16

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

@@ -0,0 +1,151 @@
+package sh.calaba.org.codehaus.jackson.map.jsontype;
+
+import java.util.Collection;
+
+import sh.calaba.org.codehaus.jackson.annotate.JsonTypeInfo;
+import sh.calaba.org.codehaus.jackson.annotate.JsonTypeInfo.As;
+import sh.calaba.org.codehaus.jackson.map.BeanProperty;
+import sh.calaba.org.codehaus.jackson.map.DeserializationConfig;
+import sh.calaba.org.codehaus.jackson.map.SerializationConfig;
+import sh.calaba.org.codehaus.jackson.map.TypeDeserializer;
+import sh.calaba.org.codehaus.jackson.map.TypeSerializer;
+import sh.calaba.org.codehaus.jackson.type.JavaType;
+
+/**
+ * Interface that defines builders that are configured based on
+ * annotations (like {@link JsonTypeInfo} or JAXB annotations),
+ * and produce type serializers and deserializers used for
+ * handling type information embedded in JSON to allow for safe
+ * polymorphic type handling.
+ *<p>
+ * Builder is first initialized by calling {@link #init} method, and then
+ * configured using <code>setXxx</code> (and <code>registerXxx</code>)
+ * methods. Finally, after calling all configuration methods,
+ * {@link #buildTypeSerializer} or {@link #buildTypeDeserializer}
+ * will be called to get actual type resolver constructed
+ * and used for resolving types for configured base type and its
+ * subtypes.
+ *<p>
+ * Note that instances are used for two related but distinct use cases:
+ *<ul>
+ * <li>To create builders to use with explicit type information
+ *    inclusion (usually via <code>@JsonTypeInfo</code> annotation)
+ *   </li>
+ * <li>To create builders when "default typing" is used; if so, type information
+ *   is automatically included for certain kind of types, regardless of annotations
+ *   </li>
+ *</ul>
+ * Important distinction between the cases is that in first case, calls to
+ * create builders are only made when builders are certainly needed; whereas
+ * in second case builder has to first verify whether type information is
+ * applicable for given type, and if not, just return null to indicate this.
+ * 
+ * @since 1.5
+ * @author tatu
+ */
+public interface TypeResolverBuilder<T extends TypeResolverBuilder<T>>
+{
+    /*
+    /**********************************************************
+    /* Accessors
+    /**********************************************************
+     */
+
+    /**
+     * Accessor for currently configured default type; implementation
+     * class that may be used in case no valid type information is
+     * available during type resolution
+     * 
+     * @since 1.9
+     */
+    public Class<?> getDefaultImpl();
+    
+    /*
+    /**********************************************************
+    /* Actual builder methods
+    /**********************************************************
+     */
+
+    /**
+     * Method for building type serializer based on current configuration
+     * of this builder.
+     * 
+     * @param baseType Base type that constructed resolver will
+     *    handle; super type of all types it will be used for.
+     */
+    public TypeSerializer buildTypeSerializer(SerializationConfig config,
+            JavaType baseType, Collection<NamedType> subtypes, BeanProperty property);
+
+    /**
+     * Method for building type deserializer based on current configuration
+     * of this builder.
+     * 
+     * @param baseType Base type that constructed resolver will
+     *    handle; super type of all types it will be used for.
+     * @param subtypes Known subtypes of the base type.
+     */
+    public TypeDeserializer buildTypeDeserializer( DeserializationConfig config,
+            JavaType baseType, Collection<NamedType> subtypes, BeanProperty property);
+    
+    /*
+    /**********************************************************
+    /* Initialization method(s) that must be called before other
+    /* configuration
+    /**********************************************************
+     */
+
+    /**
+     * Initialization method that is called right after constructing
+     * the builder instance.
+     *
+     * @param idType Which type metadata is used
+     * @param res (optional) Custom type id resolver used, if any
+     * 
+     * @return Resulting builder instance (usually this builder,
+     *   but not necessarily)
+     */
+    public T init(JsonTypeInfo.Id idType, TypeIdResolver res);
+    
+    /*
+    /**********************************************************
+    /* Methods for configuring resolver to build 
+    /**********************************************************
+     */
+    
+    /**
+     * Method for specifying mechanism to use for including type metadata
+     * in JSON.
+     * If not explicitly called, setting defaults to
+     * {@link As#PROPERTY}.
+     * 
+     * @param includeAs Mechanism used for including type metadata in JSON
+     * 
+     * @return Resulting builder instance (usually this builder,
+     *   but not necessarily)
+     */
+    public T inclusion(As includeAs);
+
+    /**
+     * Method for specifying name of property used for including type
+     * information. Not used for all inclusion mechanisms;
+     * usually only used with {@link As#PROPERTY}.
+     *<p>
+     * If not explicitly called, name of property to use is based on
+     * defaults for {@link sh.calaba.org.codehaus.jackson.annotate.JsonTypeInfo.Id} configured.
+     * 
+     * @param propName Name of JSON property to use for including
+     *    type information
+     * 
+     * @return Resulting builder instance (usually this builder,
+     *   but not necessarily)
+     */
+    public T typeProperty(String propName);
+
+    /**
+     * Method for specifying default implementation to use if type id 
+     * is either not available, or can not be resolved.
+     * 
+     * @since 1.9
+     */
+    public T defaultImpl(Class<?> defaultImpl);
+}

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

@@ -0,0 +1,126 @@
+package sh.calaba.org.codehaus.jackson.map.jsontype.impl;
+
+import java.io.IOException;
+
+import sh.calaba.org.codehaus.jackson.*;
+import sh.calaba.org.codehaus.jackson.annotate.JsonTypeInfo.As;
+import sh.calaba.org.codehaus.jackson.map.*;
+import sh.calaba.org.codehaus.jackson.map.jsontype.TypeIdResolver;
+import sh.calaba.org.codehaus.jackson.type.JavaType;
+
+/**
+ * Type deserializer used with {@link As#WRAPPER_ARRAY}
+ * inclusion mechanism. Simple since JSON structure used is always
+ * the same, regardless of structure used for actual value: wrapping
+ * is done using a 2-element JSON Array where type id is the first
+ * element, and actual object data as second element.
+ * 
+ * @author tatus
+ */
+public class AsArrayTypeDeserializer extends TypeDeserializerBase
+{
+    @Deprecated // since 1.9
+    public AsArrayTypeDeserializer(JavaType bt, TypeIdResolver idRes, BeanProperty property) {
+        this(bt, idRes, property, null);
+    }
+
+    public AsArrayTypeDeserializer(JavaType bt, TypeIdResolver idRes, BeanProperty property,
+            Class<?> defaultImpl)
+    {
+        super(bt, idRes, property, defaultImpl);
+    }
+    
+    @Override
+    public As getTypeInclusion() {
+        return As.WRAPPER_ARRAY;
+    }
+
+    /**
+     * Method called when actual object is serialized as JSON Array.
+     */
+    @Override
+    public Object deserializeTypedFromArray(JsonParser jp, DeserializationContext ctxt)
+        throws IOException, JsonProcessingException
+    {
+        return _deserialize(jp, ctxt);
+    }
+
+    /**
+     * Method called when actual object is serialized as JSON Object
+     */
+    @Override
+    public Object deserializeTypedFromObject(JsonParser jp, DeserializationContext ctxt)
+        throws IOException, JsonProcessingException
+    {
+        return _deserialize(jp, ctxt);
+    }
+    
+    @Override
+    public Object deserializeTypedFromScalar(JsonParser jp, DeserializationContext ctxt)
+        throws IOException, JsonProcessingException
+    {
+        return _deserialize(jp, ctxt);
+    }    
+
+    @Override
+    public Object deserializeTypedFromAny(JsonParser jp, DeserializationContext ctxt)
+        throws IOException, JsonProcessingException
+    {
+        return _deserialize(jp, ctxt);
+    }    
+    
+    /*
+    /***************************************************************
+    /* Internal methods
+    /***************************************************************
+     */
+
+    /**
+     * Method that handles type information wrapper, locates actual
+     * subtype deserializer to use, and calls it to do actual
+     * deserialization.
+     */
+    private final Object _deserialize(JsonParser jp, DeserializationContext ctxt)
+        throws IOException, JsonProcessingException
+    {
+        boolean hadStartArray = jp.isExpectedStartArrayToken();
+        JsonDeserializer<Object> deser = _findDeserializer(ctxt, _locateTypeId(jp, ctxt));
+        Object value = deser.deserialize(jp, ctxt);
+        // And then need the closing END_ARRAY
+        if (hadStartArray && jp.nextToken() != JsonToken.END_ARRAY) {
+            throw ctxt.wrongTokenException(jp, JsonToken.END_ARRAY,
+                    "expected closing END_ARRAY after type information and deserialized value");
+        }
+        return value;
+    }    
+    
+    protected final String _locateTypeId(JsonParser jp, DeserializationContext ctxt)
+        throws IOException, JsonProcessingException
+    {
+        if (!jp.isExpectedStartArrayToken()) {
+            // Add instanceof check because we cannot add method to TypeIdResolver interface due to backwards
+            // compatibility issues.  We can however add it to the base method, which gets at least some of
+            // the functionality we want.  Falls back to old exception for other types of TypeIdResolvers
+            if (_idResolver instanceof TypeIdResolverBase) {
+                if (_defaultImpl != null) { // but let's require existence of default impl, as a safeguard
+                    return ((TypeIdResolverBase) _idResolver).idFromBaseType();
+                }
+            }
+            throw ctxt.wrongTokenException(jp, JsonToken.START_ARRAY,
+                    "need JSON Array to contain As.WRAPPER_ARRAY type information for class "+baseTypeName());
+        }
+        // And then type id as a String
+        if (jp.nextToken() != JsonToken.VALUE_STRING) {
+            if (_idResolver instanceof TypeIdResolverBase) {
+                if (_defaultImpl != null) { // but let's require existence of default impl, as a safeguard
+                    return ((TypeIdResolverBase) _idResolver).idFromBaseType();
+                }
+            }
+            throw ctxt.wrongTokenException(jp, JsonToken.VALUE_STRING,
+                    "need JSON String that contains type id (for subtype of "+baseTypeName()+")");
+        }
+        String result = jp.getText();
+        jp.nextToken();
+        return result;
+    }
+}

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

@@ -0,0 +1,110 @@
+package sh.calaba.org.codehaus.jackson.map.jsontype.impl;
+
+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.As;
+import sh.calaba.org.codehaus.jackson.map.BeanProperty;
+import sh.calaba.org.codehaus.jackson.map.jsontype.TypeIdResolver;
+
+/**
+ * Type serializer that will embed type information in an array,
+ * as the first element, and actual value as the second element.
+ * 
+ * @since 1.5
+ * @author tatu
+ */
+public class AsArrayTypeSerializer
+    extends TypeSerializerBase
+{
+    public AsArrayTypeSerializer(TypeIdResolver idRes, BeanProperty property)
+    {
+        super(idRes, property);
+    }
+
+    @Override
+    public As getTypeInclusion() { return As.WRAPPER_ARRAY; }
+    
+    @Override
+    public void writeTypePrefixForObject(Object value, JsonGenerator jgen)
+        throws IOException, JsonProcessingException
+    {
+        jgen.writeStartArray();
+        jgen.writeString(_idResolver.idFromValue(value));
+        jgen.writeStartObject();
+    }
+
+    @Override
+    public void writeTypePrefixForObject(Object value, JsonGenerator jgen,
+            Class<?> type)
+        throws IOException, JsonProcessingException
+    {
+        jgen.writeStartArray();
+        jgen.writeString(_idResolver.idFromValueAndType(value, type));
+        jgen.writeStartObject();
+    }
+    
+    @Override
+    public void writeTypePrefixForArray(Object value, JsonGenerator jgen)
+        throws IOException, JsonProcessingException
+    {
+        jgen.writeStartArray();
+        jgen.writeString(_idResolver.idFromValue(value));
+        jgen.writeStartArray();
+    }
+
+    @Override
+    public void writeTypePrefixForArray(Object value, JsonGenerator jgen,
+            Class<?> type)
+        throws IOException, JsonProcessingException
+    {
+        jgen.writeStartArray();
+        jgen.writeString(_idResolver.idFromValueAndType(value, type));
+        jgen.writeStartArray();
+    }
+    
+    @Override
+    public void writeTypePrefixForScalar(Object value, JsonGenerator jgen)
+            throws IOException, JsonProcessingException
+    {
+        // only need the wrapper array
+        jgen.writeStartArray();
+        jgen.writeString(_idResolver.idFromValue(value));
+    }
+
+    @Override
+    public void writeTypePrefixForScalar(Object value, JsonGenerator jgen,
+            Class<?> type)
+        throws IOException, JsonProcessingException
+    {
+        // only need the wrapper array
+        jgen.writeStartArray();
+        jgen.writeString(_idResolver.idFromValueAndType(value, type));
+    }
+    
+    @Override
+    public void writeTypeSuffixForObject(Object value, JsonGenerator jgen)
+            throws IOException, JsonProcessingException
+    {
+        jgen.writeEndObject();
+        jgen.writeEndArray();
+    }
+
+    @Override
+    public void writeTypeSuffixForArray(Object value, JsonGenerator jgen)
+            throws IOException, JsonProcessingException
+    {
+        // wrapper array first, and then array caller needs to close
+        jgen.writeEndArray();
+        jgen.writeEndArray();
+    }
+
+    @Override
+    public void writeTypeSuffixForScalar(Object value, JsonGenerator jgen)
+            throws IOException, JsonProcessingException
+    {
+        // just the wrapper array to close
+        jgen.writeEndArray();
+    }
+}

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

@@ -0,0 +1,37 @@
+package sh.calaba.org.codehaus.jackson.map.jsontype.impl;
+
+import sh.calaba.org.codehaus.jackson.annotate.JsonTypeInfo.As;
+import sh.calaba.org.codehaus.jackson.map.BeanProperty;
+import sh.calaba.org.codehaus.jackson.map.jsontype.TypeIdResolver;
+import sh.calaba.org.codehaus.jackson.type.JavaType;
+
+/**
+ * Type deserializer used with {@link As#EXTERNAL_PROPERTY} inclusion mechanism.
+ * Actual implementation may look bit strange since it depends on comprehensive
+ * pre-processing done by {@link sh.calaba.org.codehaus.jackson.map.deser.BeanDeserializer}
+ * to basically transform external type id into structure that looks more like
+ * "wrapper-array" style inclusion. This intermediate form is chosen to allow
+ * supporting all possible JSON structures.
+ * 
+ * @since 1.9
+ */
+public class AsExternalTypeDeserializer extends AsArrayTypeDeserializer
+{
+    protected final String _typePropertyName;
+    
+    public AsExternalTypeDeserializer(JavaType bt, TypeIdResolver idRes, BeanProperty property,
+            Class<?> defaultImpl,
+            String typePropName)
+    {
+        super(bt, idRes, property, defaultImpl);
+        _typePropertyName = typePropName;
+    }
+
+    @Override
+    public As getTypeInclusion() {
+        return As.EXTERNAL_PROPERTY;
+    }
+
+    @Override
+    public String getPropertyName() { return _typePropertyName; }
+}

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

@@ -0,0 +1,129 @@
+package sh.calaba.org.codehaus.jackson.map.jsontype.impl;
+
+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.As;
+import sh.calaba.org.codehaus.jackson.map.BeanProperty;
+import sh.calaba.org.codehaus.jackson.map.jsontype.TypeIdResolver;
+
+/**
+ * Type serializer that preferably embeds type information as an "external"
+ * type property; embedded in enclosing JSON object.
+ * Note that this serializer should only be used when value is being output
+ * at JSON Object context; otherwise it can not work reliably, and will have
+ * to revert operation similar to {@link AsPropertyTypeSerializer}.
+ *<p>
+ * Note that implementation of serialization is bit cumbersome as we must
+ * serialized external type id AFTER object; this because callback only
+ * occurs after field name has been written.
+ * 
+ * @since 1.9
+ */
+public class AsExternalTypeSerializer
+   extends TypeSerializerBase
+{
+   protected final String _typePropertyName;
+
+   public AsExternalTypeSerializer(TypeIdResolver idRes, BeanProperty property,
+           String propName)
+   {
+       super(idRes, property);
+       _typePropertyName = propName;
+   }
+
+   @Override
+   public String getPropertyName() { return _typePropertyName; }
+
+   @Override
+   public As getTypeInclusion() { return As.EXTERNAL_PROPERTY; }
+   
+   @Override
+   public void writeTypePrefixForObject(Object value, JsonGenerator jgen)
+       throws IOException, JsonProcessingException
+   {
+       _writePrefix(value, jgen);
+   }
+
+   @Override
+   public void writeTypePrefixForObject(Object value, JsonGenerator jgen, Class<?> type)
+       throws IOException, JsonProcessingException
+   {
+       _writePrefix(value, jgen, type);
+   }
+   
+   @Override
+   public void writeTypePrefixForArray(Object value, JsonGenerator jgen)
+       throws IOException, JsonProcessingException
+   {
+       _writePrefix(value, jgen);
+   }
+
+   @Override
+   public void writeTypePrefixForArray(Object value, JsonGenerator jgen, Class<?> type)
+           throws IOException, JsonProcessingException
+   {
+       _writePrefix(value, jgen, type);
+   }
+
+   @Override
+   public void writeTypePrefixForScalar(Object value, JsonGenerator jgen)
+           throws IOException, JsonProcessingException
+   {
+       _writePrefix(value, jgen);
+   }
+
+   @Override
+   public void writeTypePrefixForScalar(Object value, JsonGenerator jgen, Class<?> type)
+           throws IOException, JsonProcessingException
+   {
+       _writePrefix(value, jgen, type);
+   }
+
+   @Override
+   public void writeTypeSuffixForObject(Object value, JsonGenerator jgen)
+       throws IOException, JsonProcessingException
+   {
+       _writeSuffix(value, jgen);
+   }
+
+   @Override
+   public void writeTypeSuffixForArray(Object value, JsonGenerator jgen)
+       throws IOException, JsonProcessingException
+   {
+       _writeSuffix(value, jgen);
+   }
+   
+   @Override
+   public void writeTypeSuffixForScalar(Object value, JsonGenerator jgen)
+       throws IOException, JsonProcessingException
+   {
+       _writeSuffix(value, jgen);
+   }
+
+   /*
+   /**********************************************************
+   /* Helper methods
+   /**********************************************************
+    */
+   
+   protected final void _writePrefix(Object value, JsonGenerator jgen)
+       throws IOException, JsonProcessingException
+   {
+       jgen.writeStartObject();
+   }
+
+   protected final void _writePrefix(Object value, JsonGenerator jgen, Class<?> type)
+       throws IOException, JsonProcessingException
+   {
+       jgen.writeStartObject();
+   }
+   
+   protected final void _writeSuffix(Object value, JsonGenerator jgen)
+       throws IOException, JsonProcessingException
+   {
+       jgen.writeEndObject();
+       jgen.writeStringField(_typePropertyName, _idResolver.idFromValue(value));
+   }
+}