testautoa 0.4.0.pre16

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

@@ -0,0 +1,191 @@
+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;
+import sh.calaba.org.codehaus.jackson.util.JsonParserSequence;
+import sh.calaba.org.codehaus.jackson.util.TokenBuffer;
+
+/**
+ * Type deserializer used with {@link As#PROPERTY}
+ * inclusion mechanism.
+ * Uses regular form (additional key/value entry before actual data)
+ * when typed object is expressed as JSON Object; otherwise behaves similar to how
+ * {@link As#WRAPPER_ARRAY} works.
+ * Latter is used if JSON representation is polymorphic
+ * 
+ * @since 1.5
+ * @author tatu
+ */
+public class AsPropertyTypeDeserializer extends AsArrayTypeDeserializer
+{
+    protected final String _typePropertyName;
+
+    @Deprecated // since 1.9
+    public AsPropertyTypeDeserializer(JavaType bt, TypeIdResolver idRes, BeanProperty property,
+            String typePropName) {
+        this(bt, idRes, property, null, typePropName);
+    }
+    
+    public AsPropertyTypeDeserializer(JavaType bt, TypeIdResolver idRes, BeanProperty property,
+            Class<?> defaultImpl,
+            String typePropName)
+    {
+        super(bt, idRes, property, defaultImpl);
+        _typePropertyName = typePropName;
+    }
+
+    @Override
+    public As getTypeInclusion() {
+        return As.PROPERTY;
+    }
+
+    @Override
+    public String getPropertyName() { return _typePropertyName; }
+
+    /**
+     * This is the trickiest thing to handle, since property we are looking
+     * for may be anywhere...
+     */
+    @Override
+    public Object deserializeTypedFromObject(JsonParser jp, DeserializationContext ctxt)
+        throws IOException, JsonProcessingException
+    {
+        // but first, sanity check to ensure we have START_OBJECT or FIELD_NAME
+        JsonToken t = jp.getCurrentToken();
+        if (t == JsonToken.START_OBJECT) {
+            t = jp.nextToken();
+        } else if (t == JsonToken.START_ARRAY) {
+            /* This is most likely due to the fact that not all Java types are
+             * serialized as JSON Objects; so if "as-property" inclusion is requested,
+             * serialization of things like Lists must be instead handled as if
+             * "as-wrapper-array" was requested.
+             * But this can also be due to some custom handling: so, if "defaultImpl"
+             * is defined, it will be asked to handle this case.
+             */
+            return _deserializeTypedUsingDefaultImpl(jp, ctxt, null);
+        } else if (t != JsonToken.FIELD_NAME) {
+            return _deserializeTypedUsingDefaultImpl(jp, ctxt, null);
+        }
+        // Ok, let's try to find the property. But first, need token buffer...
+        TokenBuffer tb = null;
+
+        for (; t == JsonToken.FIELD_NAME; t = jp.nextToken()) {
+            String name = jp.getCurrentName();
+            jp.nextToken(); // to point to the value
+            if (_typePropertyName.equals(name)) { // gotcha!
+                String typeId = jp.getText();
+                JsonDeserializer<Object> deser = _findDeserializer(ctxt, typeId);
+                // deserializer should take care of closing END_OBJECT as well
+               if (tb != null) {
+                    jp = JsonParserSequence.createFlattened(tb.asParser(jp), jp);
+                }
+                /* Must point to the next value; tb had no current, jp
+                 * pointed to VALUE_STRING:
+                 */
+                jp.nextToken(); // to skip past String value
+                // deserializer should take care of closing END_OBJECT as well
+                return deser.deserialize(jp, ctxt);
+            }
+            if (tb == null) {
+                tb = new TokenBuffer(null);
+            }
+            tb.writeFieldName(name);
+            tb.copyCurrentStructure(jp);
+        }
+        return _deserializeTypedUsingDefaultImpl(jp, ctxt, tb);
+    }
+    
+    // off-lined to keep main method lean and mean...
+    protected Object _deserializeTypedUsingDefaultImpl(JsonParser jp,
+            DeserializationContext ctxt, TokenBuffer tb)
+        throws IOException, JsonProcessingException
+    {
+        // As per [JACKSON-614], may have default implementation to use
+        if (_defaultImpl != null) { 
+            JsonDeserializer<Object> deser = _findDefaultImplDeserializer(ctxt);
+            if (tb != null) {
+                tb.writeEndObject();
+                jp = tb.asParser(jp);
+                // must move to point to the first token:
+                jp.nextToken();
+            }
+            return deser.deserialize(jp, ctxt);
+        }
+        // or, perhaps we just bumped into a "natural" value (boolean/int/double/String)?
+        Object result = _deserializeIfNatural(jp, ctxt);
+        if (result != null) {
+            return result;
+        }
+        // or, something for which "as-property" won't work, changed into "wrapper-array" type:
+        if (jp.getCurrentToken() == JsonToken.START_ARRAY) {
+            return super.deserializeTypedFromAny(jp, ctxt);
+        }
+        throw ctxt.wrongTokenException(jp, JsonToken.FIELD_NAME,
+                "missing property '"+_typePropertyName+"' that is to contain type id  (for class "+baseTypeName()+")");
+    }
+
+    /* As per [JACKSON-352], also need to re-route "unknown" version. Need to think
+     * this through bit more in future, but for now this does address issue and has
+     * no negative side effects (at least within existing unit test suite).
+     */
+    @Override
+    public Object deserializeTypedFromAny(JsonParser jp, DeserializationContext ctxt)
+        throws IOException, JsonProcessingException
+    {
+        /* [JACKSON-387]: Sometimes, however, we get an array wrapper; specifically
+         *   when an array or list has been serialized with type information.
+         */
+        if (jp.getCurrentToken() == JsonToken.START_ARRAY) {
+            return super.deserializeTypedFromArray(jp, ctxt);
+        }
+        return deserializeTypedFromObject(jp, ctxt);
+    }    
+    
+    // These are fine from base class:
+    //public Object deserializeTypedFromArray(JsonParser jp, DeserializationContext ctxt)
+    //public Object deserializeTypedFromScalar(JsonParser jp, DeserializationContext ctxt)    
+
+    /**
+     * Helper method used to check if given parser might be pointing to
+     * a "natural" value, and one that would be acceptable as the
+     * result value (compatible with declared base type)
+     */
+    protected Object _deserializeIfNatural(JsonParser jp, DeserializationContext ctxt)
+        throws IOException, JsonProcessingException
+    {
+        switch (jp.getCurrentToken()) {
+        case VALUE_STRING:
+            if (_baseType.getRawClass().isAssignableFrom(String.class)) {
+                return jp.getText();
+            }
+            break;
+        case VALUE_NUMBER_INT:
+            if (_baseType.getRawClass().isAssignableFrom(Integer.class)) {
+                return jp.getIntValue();
+            }
+            break;
+
+        case VALUE_NUMBER_FLOAT:
+            if (_baseType.getRawClass().isAssignableFrom(Double.class)) {
+                return Double.valueOf(jp.getDoubleValue());
+            }
+            break;
+        case VALUE_TRUE:
+            if (_baseType.getRawClass().isAssignableFrom(Boolean.class)) {
+                return Boolean.TRUE;
+            }
+            break;
+        case VALUE_FALSE:
+            if (_baseType.getRawClass().isAssignableFrom(Boolean.class)) {
+                return Boolean.FALSE;
+            }
+            break;
+        }
+        return null;
+    }
+}

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

@@ -0,0 +1,69 @@
+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 additional
+ * JSON Object property, if possible (when resulting serialization would
+ * use JSON Object). If this is not possible (for JSON Arrays, scalars),
+ * uses a JSON Array wrapper (similar to how
+ * {@link As#WRAPPER_ARRAY} always works) as a fallback.
+ * 
+ * @since 1.5
+ * @author tatus
+ */
+public class AsPropertyTypeSerializer
+    extends AsArrayTypeSerializer
+{
+    protected final String _typePropertyName;
+
+    public AsPropertyTypeSerializer(TypeIdResolver idRes, BeanProperty property,
+            String propName)
+    {
+        super(idRes, property);
+        _typePropertyName = propName;
+    }
+
+    @Override
+    public String getPropertyName() { return _typePropertyName; }
+
+    @Override
+    public As getTypeInclusion() { return As.PROPERTY; }
+    
+    @Override
+    public void writeTypePrefixForObject(Object value, JsonGenerator jgen)
+        throws IOException, JsonProcessingException
+    {
+        jgen.writeStartObject();
+        jgen.writeStringField(_typePropertyName, _idResolver.idFromValue(value));
+    }
+
+    @Override
+    public void writeTypePrefixForObject(Object value, JsonGenerator jgen, Class<?> type)
+        throws IOException, JsonProcessingException
+    {
+        jgen.writeStartObject();
+        jgen.writeStringField(_typePropertyName, _idResolver.idFromValueAndType(value, type));
+    }
+    
+    //public void writeTypePrefixForArray(Object value, JsonGenerator jgen)
+    //public void writeTypePrefixForArray(Object value, JsonGenerator jgen, Class<?> type)
+    //public void writeTypePrefixForScalar(Object value, JsonGenerator jgen)
+    //public void writeTypePrefixForScalar(Object value, JsonGenerator jgen, Class<?> type)
+
+    @Override
+    public void writeTypeSuffixForObject(Object value, JsonGenerator jgen)
+        throws IOException, JsonProcessingException
+    {
+        jgen.writeEndObject();
+    }
+
+    //public void writeTypeSuffixForArray(Object value, JsonGenerator jgen)
+    //public void writeTypeSuffixForScalar(Object value, JsonGenerator jgen)
+}

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

@@ -0,0 +1,103 @@
+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_OBJECT}
+ * inclusion mechanism. Simple since JSON structure used is always
+ * the same, regardless of structure used for actual value: wrapping
+ * is done using a single-element JSON Object where type id is the key,
+ * and actual object data as the value.
+ * 
+ * @author tatus
+ */
+public class AsWrapperTypeDeserializer extends TypeDeserializerBase
+{
+    @Deprecated // since 1.9
+    public AsWrapperTypeDeserializer(JavaType bt, TypeIdResolver idRes, BeanProperty property) {
+        this(bt, idRes, property, null);
+    }
+
+    public AsWrapperTypeDeserializer(JavaType bt, TypeIdResolver idRes, BeanProperty property,
+            Class<?> defaultImpl)
+    {
+        super(bt, idRes, property, null);
+    }
+
+    @Override
+    public As getTypeInclusion() {
+        return As.WRAPPER_OBJECT;
+    }
+
+    /**
+     * Deserializing type id enclosed using WRAPPER_OBJECT style is straightforward
+     */
+    @Override
+    public Object deserializeTypedFromObject(JsonParser jp, DeserializationContext ctxt)
+        throws IOException, JsonProcessingException
+    {
+        return _deserialize(jp, ctxt);
+    }    
+
+    @Override
+    public Object deserializeTypedFromArray(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
+    {
+        // first, sanity checks
+        if (jp.getCurrentToken() != JsonToken.START_OBJECT) {
+            throw ctxt.wrongTokenException(jp, JsonToken.START_OBJECT,
+                    "need JSON Object to contain As.WRAPPER_OBJECT type information for class "+baseTypeName());
+        }
+        // should always get field name, but just in case...
+        if (jp.nextToken() != JsonToken.FIELD_NAME) {
+            throw ctxt.wrongTokenException(jp, JsonToken.FIELD_NAME,
+                    "need JSON String that contains type id (for subtype of "+baseTypeName()+")");
+        }
+        JsonDeserializer<Object> deser = _findDeserializer(ctxt, jp.getText());
+        jp.nextToken();
+        Object value = deser.deserialize(jp, ctxt);
+        // And then need the closing END_OBJECT
+        if (jp.nextToken() != JsonToken.END_OBJECT) {
+            throw ctxt.wrongTokenException(jp, JsonToken.END_OBJECT,
+                    "expected closing END_OBJECT after type information and deserialized value");
+        }
+        return value;
+    }
+}

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

@@ -0,0 +1,121 @@
+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 wrapper that tries to use an extra JSON Object, with a single
+ * entry that has type name as key, to serialize type information.
+ * If this is not possible (value is serialize as array or primitive),
+ * will use {@link As#WRAPPER_ARRAY} mechanism as fallback: that is,
+ * just use a wrapping array with type information as the first element
+ * and value as second.
+ * 
+ * @since 1.5
+ * @author tatus
+ */
+public class AsWrapperTypeSerializer
+    extends TypeSerializerBase
+{
+    public AsWrapperTypeSerializer(TypeIdResolver idRes, BeanProperty property)
+    {
+        super(idRes, property);
+    }
+
+    @Override
+    public As getTypeInclusion() { return As.WRAPPER_OBJECT; }
+    
+    @Override
+    public void writeTypePrefixForObject(Object value, JsonGenerator jgen)
+        throws IOException, JsonProcessingException
+    {
+        // wrapper
+        jgen.writeStartObject();
+        // and then JSON Object start caller wants
+        jgen.writeObjectFieldStart(_idResolver.idFromValue(value));
+    }
+
+    @Override
+    public void writeTypePrefixForObject(Object value, JsonGenerator jgen,
+            Class<?> type)
+        throws IOException, JsonProcessingException
+    {
+        // wrapper
+        jgen.writeStartObject();
+        // and then JSON Object start caller wants
+        jgen.writeObjectFieldStart(_idResolver.idFromValueAndType(value, type));
+    }
+    
+    @Override
+    public void writeTypePrefixForArray(Object value, JsonGenerator jgen)
+        throws IOException, JsonProcessingException
+    {
+        // can still wrap ok
+        jgen.writeStartObject();
+        // and then JSON Array start caller wants
+        jgen.writeArrayFieldStart(_idResolver.idFromValue(value));
+    }
+
+    @Override
+    public void writeTypePrefixForArray(Object value, JsonGenerator jgen,
+            Class<?> type)
+        throws IOException, JsonProcessingException
+    {
+        // can still wrap ok
+        jgen.writeStartObject();
+        // and then JSON Array start caller wants
+        jgen.writeArrayFieldStart(_idResolver.idFromValueAndType(value, type));
+    }
+    
+    @Override
+    public void writeTypePrefixForScalar(Object value, JsonGenerator jgen)
+        throws IOException, JsonProcessingException
+    {
+        // can still wrap ok
+        jgen.writeStartObject();
+        jgen.writeFieldName(_idResolver.idFromValue(value));
+    }
+
+    @Override
+    public void writeTypePrefixForScalar(Object value, JsonGenerator jgen,
+            Class<?> type)
+        throws IOException, JsonProcessingException
+    {
+        // can still wrap ok
+        jgen.writeStartObject();
+        jgen.writeFieldName(_idResolver.idFromValueAndType(value, type));
+    }
+    
+    @Override
+    public void writeTypeSuffixForObject(Object value, JsonGenerator jgen)
+        throws IOException, JsonProcessingException
+    {
+        // first close JSON Object caller used
+        jgen.writeEndObject();
+        // and then wrapper
+        jgen.writeEndObject();
+    }
+
+    @Override
+    public void writeTypeSuffixForArray(Object value, JsonGenerator jgen)
+        throws IOException, JsonProcessingException
+    {
+        // first close array caller needed
+        jgen.writeEndArray();
+        // then wrapper object
+        jgen.writeEndObject();
+    }
+    
+    @Override
+    public void writeTypeSuffixForScalar(Object value, JsonGenerator jgen)
+        throws IOException, JsonProcessingException
+    {
+        // just need to close the wrapper object
+        jgen.writeEndObject();
+    }    
+}

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

@@ -0,0 +1,138 @@
+package sh.calaba.org.codehaus.jackson.map.jsontype.impl;
+
+import java.util.*;
+
+import sh.calaba.org.codehaus.jackson.annotate.JsonTypeInfo;
+import sh.calaba.org.codehaus.jackson.map.type.TypeFactory;
+import sh.calaba.org.codehaus.jackson.map.util.ClassUtil;
+import sh.calaba.org.codehaus.jackson.type.JavaType;
+
+/**
+ * {@link sh.calaba.org.codehaus.jackson.map.jsontype.TypeIdResolver} implementation
+ * that converts between fully-qualified
+ * Java class names and (JSON) Strings.
+ */
+public class ClassNameIdResolver
+    extends TypeIdResolverBase
+{
+    public ClassNameIdResolver(JavaType baseType, TypeFactory typeFactory) {
+        super(baseType, typeFactory);
+    }
+
+    @Override
+    public JsonTypeInfo.Id getMechanism() { return JsonTypeInfo.Id.CLASS; }
+
+    public void registerSubtype(Class<?> type, String name) {
+        // not used with class name - based resolvers
+    }
+    
+    @Override
+    public String idFromValue(Object value)
+    {
+        return _idFrom(value, value.getClass());
+    }
+
+    @Override
+    public String idFromValueAndType(Object value, Class<?> type)
+    {
+        return _idFrom(value, type);
+    }
+
+    @Override
+    public JavaType typeFromId(String id)
+    {
+        /* 30-Jan-2010, tatu: Most ids are basic class names; so let's first
+         *    check if any generics info is added; and only then ask factory
+         *    to do translation when necessary
+         */
+        if (id.indexOf('<') > 0) {
+            JavaType t = TypeFactory.fromCanonical(id);
+            // note: may want to try combining with specialization (esp for EnumMap)
+            return t;
+        }
+        try {
+            /* [JACKSON-350]: Default Class.forName() won't work too well; context class loader
+             *    seems like slightly better choice
+             */
+//          Class<?> cls = Class.forName(id);
+            ClassLoader loader = Thread.currentThread().getContextClassLoader();
+            Class<?> cls = Class.forName(id, true, loader);
+            return _typeFactory.constructSpecializedType(_baseType, cls);
+        } catch (ClassNotFoundException e) {
+            throw new IllegalArgumentException("Invalid type id '"+id+"' (for id type 'Id.class'): no such class found");
+        } catch (Exception e) {
+            throw new IllegalArgumentException("Invalid type id '"+id+"' (for id type 'Id.class'): "+e.getMessage(), e);
+        }
+    }
+
+    /*
+    /**********************************************************
+    /* Internal methods
+    /**********************************************************
+     */
+    
+    protected final String _idFrom(Object value, Class<?> cls)
+    {
+        // [JACKSON-380] Need to ensure that "enum subtypes" work too
+        if (Enum.class.isAssignableFrom(cls)) {
+            if (!cls.isEnum()) { // means that it's sub-class of base enum, so:
+                cls = cls.getSuperclass();
+            }
+        }
+        String str = cls.getName();
+        if (str.startsWith("java.util")) {
+            /* 25-Jan-2009, tatu: There are some internal classes that
+             *   we can not access as is. We need better mechanism; for
+             *   now this has to do...
+             */
+            /* Enum sets and maps are problematic since we MUST know
+             * type of contained enums, to be able to deserialize.
+             * In addition, EnumSet is not a concrete type either
+             */
+            if (value instanceof EnumSet<?>) { // Regular- and JumboEnumSet...
+                Class<?> enumClass = ClassUtil.findEnumType((EnumSet<?>) value);
+                // not optimal: but EnumSet is not a customizable type so this is sort of ok
+                str = TypeFactory.defaultInstance().constructCollectionType(EnumSet.class, enumClass).toCanonical();
+            } else if (value instanceof EnumMap<?,?>) {
+                Class<?> enumClass = ClassUtil.findEnumType((EnumMap<?,?>) value);
+                Class<?> valueClass = Object.class;
+                // not optimal: but EnumMap is not a customizable type so this is sort of ok
+                str = TypeFactory.defaultInstance().constructMapType(EnumMap.class, enumClass, valueClass).toCanonical();
+            } else {
+                String end = str.substring(9);
+                if ((end.startsWith(".Arrays$") || end.startsWith(".Collections$"))
+                       && str.indexOf("List") >= 0) {
+                    /* 17-Feb-2010, tatus: Another such case: result of
+                     *    Arrays.asList() is named like so in Sun JDK...
+                     *   Let's just plain old ArrayList in its place
+                     * NOTE: chances are there are plenty of similar cases
+                     * for other wrappers... (immutable, singleton, synced etc)
+                     */
+                    str = "java.util.ArrayList";
+                }
+            }
+        } else if (str.indexOf('$') >= 0) {
+            /* Other special handling may be needed for inner classes, [JACKSON-584].
+             * The best way to handle would be to find 'hidden' constructor; pass parent
+             * value etc (which is actually done for non-anonymous static classes!),
+             * but that is just not possible due to various things. So, we will instead
+             * try to generalize type into something we will be more likely to be able
+             * construct.
+             */
+            Class<?> outer = ClassUtil.getOuterClass(cls);
+            if (outer != null) {
+                /* one more check: let's actually not worry if the declared
+                 * static type is non-static as well; if so, deserializer does
+                 * have a chance at figuring it all out.
+                 */
+                Class<?> staticType = _baseType.getRawClass();
+                if (ClassUtil.getOuterClass(staticType) == null) {
+                    // Is this always correct? Seems like it should be...
+                    cls = _baseType.getRawClass();
+                    str = cls.getName();
+                }
+            }
+        }
+        return str;
+    }
+}

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

@@ -0,0 +1,66 @@
+package sh.calaba.org.codehaus.jackson.map.jsontype.impl;
+
+import sh.calaba.org.codehaus.jackson.annotate.JsonTypeInfo;
+import sh.calaba.org.codehaus.jackson.map.type.TypeFactory;
+import sh.calaba.org.codehaus.jackson.type.JavaType;
+
+public class MinimalClassNameIdResolver
+    extends ClassNameIdResolver
+{
+    /**
+     * Package name of the base class, to be used for determining common
+     * prefix that can be omitted from included type id.
+     * Does not include the trailing dot.
+     */
+    protected final String _basePackageName;
+
+    /**
+     * Same as {@link #_basePackageName}, but includes trailing dot.
+     */
+    protected final String _basePackagePrefix;
+    
+    protected MinimalClassNameIdResolver(JavaType baseType, TypeFactory typeFactory)
+    {
+        super(baseType, typeFactory);
+        String base = baseType.getRawClass().getName();
+        int ix = base.lastIndexOf('.');
+        if (ix < 0) { // can this ever occur?
+            _basePackageName = "";
+            _basePackagePrefix = ".";
+        } else {
+            _basePackagePrefix = base.substring(0, ix+1);
+            _basePackageName = base.substring(0, ix);
+        }
+    }
+
+    @Override
+    public JsonTypeInfo.Id getMechanism() { return JsonTypeInfo.Id.MINIMAL_CLASS; }
+    
+    @Override
+    public String idFromValue(Object value)
+    {
+        String n = value.getClass().getName();
+        if (n.startsWith(_basePackagePrefix)) {
+            // note: we will leave the leading dot in there
+            return n.substring(_basePackagePrefix.length()-1);
+        }
+        return n;
+    }
+
+    @Override
+    public JavaType typeFromId(String id)
+    {
+        if (id.startsWith(".")) {
+            StringBuilder sb = new StringBuilder(id.length() + _basePackageName.length());
+            if  (_basePackageName.length() == 0) {
+                // no package; must remove leading '.' from id
+                sb.append(id.substring(1));
+            } else {
+                // otherwise just concatenate package, with leading-dot-partial name
+                sb.append(_basePackageName).append(id);
+            }
+            id = sb.toString();
+        }
+        return super.typeFromId(id);
+    }
+}