calabash-android 0.4.7.pre4 → 0.4.7.pre6

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

@@ -1,206 +0,0 @@
-package sh.calaba.org.codehaus.jackson.map.module;
-
-import java.util.*;
-
-import sh.calaba.org.codehaus.jackson.map.*;
-import sh.calaba.org.codehaus.jackson.map.type.ArrayType;
-import sh.calaba.org.codehaus.jackson.map.type.ClassKey;
-import sh.calaba.org.codehaus.jackson.map.type.CollectionLikeType;
-import sh.calaba.org.codehaus.jackson.map.type.CollectionType;
-import sh.calaba.org.codehaus.jackson.map.type.MapLikeType;
-import sh.calaba.org.codehaus.jackson.map.type.MapType;
-import sh.calaba.org.codehaus.jackson.type.JavaType;
-
-/**
- * Simple implementation {@link Serializers} which allows registration of
- * serializers based on raw (type erased class).
- * It can work well for basic bean and scalar type serializers, but is not
- * a good fit for handling generic types (like {@link Map}s and {@link Collection}s).
- *<p>
- * Type registrations are assumed to be general; meaning that registration of serializer
- * for a super type will also be used for handling subtypes, unless an exact match
- * is found first. As an example, handler for {@link CharSequence} would also be used
- * serializing {@link StringBuilder} instances, unless a direct mapping was found.
- * 
- * @since 1.7
- */
-public class SimpleSerializers extends Serializers.Base
-{
-    /**
-     * Class-based mappings that are used both for exact and
-     * sub-class matches.
-     */
-    protected HashMap<ClassKey,JsonSerializer<?>> _classMappings = null;
-
-    /**
-     * Interface-based matches.
-     */
-    protected HashMap<ClassKey,JsonSerializer<?>> _interfaceMappings = null;
-
-    /*
-    /**********************************************************
-    /* Life-cycle, construction and configuring
-    /**********************************************************
-     */
-    
-    public SimpleSerializers() { }
-
-    /**
-     * Method for adding given serializer for type that {@link JsonSerializer#handledType}
-     * specifies (which MUST return a non-null class; and can NOT be {@link Object}, as a
-     * sanity check).
-     * For serializers that do not declare handled type, use the variant that takes
-     * two arguments.
-     * 
-     * @param ser
-     */
-    public void addSerializer(JsonSerializer<?> ser)
-    {
-        // Interface to match?
-        Class<?> cls = ser.handledType();
-        if (cls == null || cls == Object.class) {
-            throw new IllegalArgumentException("JsonSerializer of type "+ser.getClass().getName()
-                    +" does not define valid handledType() -- must either register with method that takes type argument "
-                    +" or make serializer extend 'sh.calaba.org.codehaus.jackson.map.ser.std.SerializerBase'"); 
-        }
-        _addSerializer(cls, ser);
-    }
-
-    public <T> void addSerializer(Class<? extends T> type, JsonSerializer<T> ser)
-    {
-        _addSerializer(type, ser);
-    }
-    
-    private void _addSerializer(Class<?> cls, JsonSerializer<?> ser)
-    {
-        ClassKey key = new ClassKey(cls);
-        // Interface or class type?
-        if (cls.isInterface()) {
-            if (_interfaceMappings == null) {
-                _interfaceMappings = new HashMap<ClassKey,JsonSerializer<?>>();
-            }
-            _interfaceMappings.put(key, ser);
-        } else { // nope, class:
-            if (_classMappings == null) {
-                _classMappings = new HashMap<ClassKey,JsonSerializer<?>>();
-            }
-            _classMappings.put(key, ser);
-        }
-    }
-    
-    /*
-    /**********************************************************
-    /* Serializers implementation
-    /**********************************************************
-     */
-    
-    @Override
-    public JsonSerializer<?> findSerializer(SerializationConfig config, JavaType type,
-             BeanDescription beanDesc, BeanProperty property)
-    {
-        Class<?> cls = type.getRawClass();
-        ClassKey key = new ClassKey(cls);
-        JsonSerializer<?> ser = null;
-
-        // First: direct match?
-        if (cls.isInterface()) {
-            if (_interfaceMappings != null) {
-                ser = _interfaceMappings.get(key);
-                if (ser != null) {
-                    return ser;
-                }
-            }
-        } else {
-            if (_classMappings != null) {
-                ser = _classMappings.get(key);
-                if (ser != null) {
-                    return ser;
-                }
-                // If not direct match, maybe super-class match?
-                for (Class<?> curr = cls; (curr != null); curr = curr.getSuperclass()) {
-                    key.reset(curr);
-                    ser = _classMappings.get(key);
-                    if (ser != null) {
-                        return ser;
-                    }
-                }
-            }
-        }
-        // No direct match? How about super-interfaces?
-        if (_interfaceMappings != null) {
-            ser = _findInterfaceMapping(cls, key);
-            if (ser != null) {
-                return ser;
-            }
-            // still no matches? Maybe interfaces of super classes
-            if (!cls.isInterface()) {
-                while ((cls = cls.getSuperclass()) != null) {
-                    ser = _findInterfaceMapping(cls, key);
-                    if (ser != null) {
-                        return ser;
-                    }
-                }
-            }
-        }
-        return null;
-    }
-
-    @Override
-    public JsonSerializer<?> findArraySerializer(SerializationConfig config,
-            ArrayType type, BeanDescription beanDesc, BeanProperty property,
-            TypeSerializer elementTypeSerializer, JsonSerializer<Object> elementValueSerializer) {
-        return findSerializer(config, type, beanDesc, property);
-    }
-
-    @Override
-    public JsonSerializer<?> findCollectionSerializer(SerializationConfig config,
-            CollectionType type, BeanDescription beanDesc, BeanProperty property,
-            TypeSerializer elementTypeSerializer, JsonSerializer<Object> elementValueSerializer) {
-        return findSerializer(config, type, beanDesc, property);
-    }
-
-    @Override
-    public JsonSerializer<?> findCollectionLikeSerializer(SerializationConfig config,
-            CollectionLikeType type, BeanDescription beanDesc, BeanProperty property,
-            TypeSerializer elementTypeSerializer, JsonSerializer<Object> elementValueSerializer) {
-        return findSerializer(config, type, beanDesc, property);
-    }
-        
-    @Override
-    public JsonSerializer<?> findMapSerializer(SerializationConfig config,
-            MapType type, BeanDescription beanDesc, BeanProperty property,
-            JsonSerializer<Object> keySerializer,
-            TypeSerializer elementTypeSerializer, JsonSerializer<Object> elementValueSerializer) {
-        return findSerializer(config, type, beanDesc, property);
-    }
-
-    @Override
-    public JsonSerializer<?> findMapLikeSerializer(SerializationConfig config,
-            MapLikeType type, BeanDescription beanDesc, BeanProperty property,
-            JsonSerializer<Object> keySerializer,
-            TypeSerializer elementTypeSerializer, JsonSerializer<Object> elementValueSerializer) {
-        return findSerializer(config, type, beanDesc, property);
-    }
-    
-    /*
-    /**********************************************************
-    /* Internal methods
-    /**********************************************************
-     */
-    
-    protected JsonSerializer<?> _findInterfaceMapping(Class<?> cls, ClassKey key)
-    {
-        for (Class<?> iface : cls.getInterfaces()) {
-            key.reset(iface);
-            JsonSerializer<?> ser = _interfaceMappings.get(key);
-            if (ser != null) {
-                return ser;
-            }
-            ser = _findInterfaceMapping(iface, key);
-            if (ser != null) {
-                return ser;
-            }
-        }
-        return null;
-    }
-}

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

@@ -1,45 +0,0 @@
-package sh.calaba.org.codehaus.jackson.map.module;
-
-import java.util.HashMap;
-
-import sh.calaba.org.codehaus.jackson.map.BeanDescription;
-import sh.calaba.org.codehaus.jackson.map.DeserializationConfig;
-import sh.calaba.org.codehaus.jackson.map.deser.ValueInstantiator;
-import sh.calaba.org.codehaus.jackson.map.deser.ValueInstantiators;
-import sh.calaba.org.codehaus.jackson.map.type.ClassKey;
-
-public class SimpleValueInstantiators
-    extends ValueInstantiators.Base
-{
-    /**
-     * Mappings from raw (type-erased, i.e. non-generic) types
-     * to matching {@link ValueInstantiator} instances.
-     */
-    protected HashMap<ClassKey,ValueInstantiator> _classMappings;
-
-    /*
-    /**********************************************************
-    /* Life-cycle, construction and configuring
-    /**********************************************************
-     */
-
-    public SimpleValueInstantiators()
-    {
-        _classMappings = new HashMap<ClassKey,ValueInstantiator>();        
-    }
-    
-    public SimpleValueInstantiators addValueInstantiator(Class<?> forType,
-            ValueInstantiator inst)
-    {
-        _classMappings.put(new ClassKey(forType), inst);
-        return this;
-    }
-    
-    @Override
-    public ValueInstantiator findValueInstantiator(DeserializationConfig config,
-            BeanDescription beanDesc, ValueInstantiator defaultInstantiator)
-    {
-        ValueInstantiator inst = _classMappings.get(new ClassKey(beanDesc.getBeanClass()));
-        return (inst == null) ? defaultInstantiator : inst;
-    }
-}

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

@@ -1,16 +0,0 @@
-/**
- * Package that contains classes and interfaces to help implement
- * custom extension {@link sh.calaba.org.codehaus.jackson.map.Module}s
- * (which are registered using
- * {@link sh.calaba.org.codehaus.jackson.map.ObjectMapper#registerModule}.
- *<p>
- * Note that classes in the package only support registering
- * handlers for non-generic types (types without type
- * parameterization) -- hence "simple" -- which works for
- * many cases, but not all. So if you will need to register
- * handlers for generic types, you will usually need to either
- * sub-class handlers, or implement/extend base types directly.
- * 
- * @since 1.7
- */
-package sh.calaba.org.codehaus.jackson.map.module;

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

@@ -1,34 +0,0 @@
-/**
-Contains basic mapper (conversion) functionality that
-allows for converting between regular streaming json content and
-Java objects (beans or Tree Model: support for both is via
-{@link sh.calaba.org.codehaus.jackson.map.ObjectMapper} class, as well
-as convenience methods included in
-{@link sh.calaba.org.codehaus.jackson.JsonParser}
-<p>
-Object mapper will convert Json content to ant from
-basic Java wrapper types (Integer, Boolean, Double),
-Collection types (List, Map), Java Beans,
-Strings and nulls.
-<p>
-Tree mapper builds dynamically typed tree of <code>JsonNode</code>s
-from Json content (and writes such trees as Json),
-similar to how DOM model works with xml.
-Main benefits over Object mapping are:
-<ul>
- <li>No null checks are needed (dummy
-nodes are created as necessary to represent "missing" Object fields
-and Array elements)
-  </li>
- <li>No type casts are usually needed: all public access methods are defined
-in basic JsonNode class, and when "incompatible" method (such as Array
-element access on, say, Boolean node) is used, returned node is
-virtual "missing" node.
-  </li>
-</ul>
-Because of its dynamic nature, Tree mapping is often convenient
-for basic path access and tree navigation, where structure of
-the resulting tree is known in advance.
-*/
-
-package sh.calaba.org.codehaus.jackson.map;

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

@@ -1,48 +0,0 @@
-package sh.calaba.org.codehaus.jackson.map.ser;
-
-import java.lang.reflect.Method;
-import java.util.Map;
-
-import sh.calaba.org.codehaus.jackson.*;
-import sh.calaba.org.codehaus.jackson.map.*;
-import sh.calaba.org.codehaus.jackson.map.introspect.AnnotatedMethod;
-import sh.calaba.org.codehaus.jackson.map.ser.std.MapSerializer;
-
-/**
- * Class similar to {@link BeanPropertyWriter}, but that will be used
- * for serializing {@link sh.calaba.org.codehaus.jackson.annotate.JsonAnyGetter} annotated
- * (Map) properties
- * 
- * @since 1.6
- */
-public class AnyGetterWriter
-{
-    protected final Method _anyGetter;
-    
-    protected final MapSerializer _serializer;
-    
-    public AnyGetterWriter(AnnotatedMethod anyGetter, MapSerializer serializer)
-    {
-        _anyGetter = anyGetter.getAnnotated();
-        _serializer = serializer;
-    }
-
-    public void getAndSerialize(Object bean, JsonGenerator jgen, SerializerProvider provider)
-        throws Exception
-    {
-        Object value = _anyGetter.invoke(bean);
-        if (value == null) {
-            return;
-        }
-        if (!(value instanceof Map<?,?>)) {
-            throw new JsonMappingException("Value returned by 'any-getter' ("+_anyGetter.getName()+"()) not java.util.Map but "
-                    +value.getClass().getName());
-        }
-        _serializer.serializeFields((Map<?,?>) value, jgen, provider);
-    }
-
-    public void resolve(SerializerProvider provider) throws JsonMappingException
-    {
-        _serializer.resolve(provider);
-    }
-}

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

@@ -1,7 +0,0 @@
-package sh.calaba.org.codehaus.jackson.map.ser;
-
-/**
- * @deprecated Since 1.9 use {@link sh.calaba.org.codehaus.jackson.map.ser.std.StdArraySerializers}
- */
-@Deprecated
-public class ArraySerializers extends sh.calaba.org.codehaus.jackson.map.ser.std.StdArraySerializers { }

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

@@ -1,806 +0,0 @@
-package sh.calaba.org.codehaus.jackson.map.ser;
-
-import java.lang.reflect.Method;
-import java.math.BigDecimal;
-import java.math.BigInteger;
-import java.net.InetAddress;
-import java.util.*;
-
-import sh.calaba.org.codehaus.jackson.map.*;
-import sh.calaba.org.codehaus.jackson.map.annotate.JsonSerialize;
-import sh.calaba.org.codehaus.jackson.map.ext.OptionalHandlerFactory;
-import sh.calaba.org.codehaus.jackson.map.introspect.*;
-import sh.calaba.org.codehaus.jackson.map.jsontype.NamedType;
-import sh.calaba.org.codehaus.jackson.map.jsontype.TypeResolverBuilder;
-import sh.calaba.org.codehaus.jackson.map.ser.std.CalendarSerializer;
-import sh.calaba.org.codehaus.jackson.map.ser.std.DateSerializer;
-import sh.calaba.org.codehaus.jackson.map.ser.std.EnumMapSerializer;
-import sh.calaba.org.codehaus.jackson.map.ser.std.EnumSerializer;
-import sh.calaba.org.codehaus.jackson.map.ser.std.IndexedStringListSerializer;
-import sh.calaba.org.codehaus.jackson.map.ser.std.InetAddressSerializer;
-import sh.calaba.org.codehaus.jackson.map.ser.std.JsonValueSerializer;
-import sh.calaba.org.codehaus.jackson.map.ser.std.MapSerializer;
-import sh.calaba.org.codehaus.jackson.map.ser.std.NullSerializer;
-import sh.calaba.org.codehaus.jackson.map.ser.std.ObjectArraySerializer;
-import sh.calaba.org.codehaus.jackson.map.ser.std.SerializableSerializer;
-import sh.calaba.org.codehaus.jackson.map.ser.std.SerializableWithTypeSerializer;
-import sh.calaba.org.codehaus.jackson.map.ser.std.StdArraySerializers;
-import sh.calaba.org.codehaus.jackson.map.ser.std.StdContainerSerializers;
-import sh.calaba.org.codehaus.jackson.map.ser.std.StdJdkSerializers;
-import sh.calaba.org.codehaus.jackson.map.ser.std.StringCollectionSerializer;
-import sh.calaba.org.codehaus.jackson.map.ser.std.StringSerializer;
-import sh.calaba.org.codehaus.jackson.map.ser.std.TimeZoneSerializer;
-import sh.calaba.org.codehaus.jackson.map.ser.std.ToStringSerializer;
-import sh.calaba.org.codehaus.jackson.map.ser.std.TokenBufferSerializer;
-import sh.calaba.org.codehaus.jackson.map.type.*;
-import sh.calaba.org.codehaus.jackson.map.util.ClassUtil;
-import sh.calaba.org.codehaus.jackson.map.util.EnumValues;
-import sh.calaba.org.codehaus.jackson.type.JavaType;
-import sh.calaba.org.codehaus.jackson.util.TokenBuffer;
-
-/**
- * Factory class that can provide serializers for standard JDK classes,
- * as well as custom classes that extend standard classes or implement
- * one of "well-known" interfaces (such as {@link java.util.Collection}).
- *<p>
- * Since all the serializers are eagerly instantiated, and there is
- * no additional introspection or customizability of these types,
- * this factory is essentially stateless.
- */
-public abstract class BasicSerializerFactory
-    extends SerializerFactory
-{
-    
-    /*
-    /**********************************************************
-    /* Configuration, lookup tables/maps
-    /**********************************************************
-     */
-
-    /**
-     * Since these are all JDK classes, we shouldn't have to worry
-     * about ClassLoader used to load them. Rather, we can just
-     * use the class name, and keep things simple and efficient.
-     */
-    protected final static HashMap<String, JsonSerializer<?>> _concrete =
-        new HashMap<String, JsonSerializer<?>>();
-    
-    /**
-     * Actually it may not make much sense to eagerly instantiate all
-     * kinds of serializers: so this Map actually contains class references,
-     * not instances
-     *
-     * @since 1.6
-     */
-    protected final static HashMap<String, Class<? extends JsonSerializer<?>>> _concreteLazy =
-        new HashMap<String, Class<? extends JsonSerializer<?>>>();
-    
-    static {
-        /* String and string-like types (note: date types explicitly
-         * not included -- can use either textual or numeric serialization)
-         */
-        _concrete.put(String.class.getName(), new StringSerializer());
-        final ToStringSerializer sls = ToStringSerializer.instance;
-        _concrete.put(StringBuffer.class.getName(), sls);
-        _concrete.put(StringBuilder.class.getName(), sls);
-        _concrete.put(Character.class.getName(), sls);
-        _concrete.put(Character.TYPE.getName(), sls);
-
-        // Primitives/wrappers for primitives (primitives needed for Beans)
-        _concrete.put(Boolean.TYPE.getName(), new StdSerializers.BooleanSerializer(true));
-        _concrete.put(Boolean.class.getName(), new StdSerializers.BooleanSerializer(false));
-        final JsonSerializer<?> intS = new StdSerializers.IntegerSerializer();
-        _concrete.put(Integer.class.getName(), intS);
-        _concrete.put(Integer.TYPE.getName(), intS);
-        _concrete.put(Long.class.getName(), StdSerializers.LongSerializer.instance);
-        _concrete.put(Long.TYPE.getName(), StdSerializers.LongSerializer.instance);
-        _concrete.put(Byte.class.getName(), StdSerializers.IntLikeSerializer.instance);
-        _concrete.put(Byte.TYPE.getName(), StdSerializers.IntLikeSerializer.instance);
-        _concrete.put(Short.class.getName(), StdSerializers.IntLikeSerializer.instance);
-        _concrete.put(Short.TYPE.getName(), StdSerializers.IntLikeSerializer.instance);
-
-        // Numbers, limited length floating point
-        _concrete.put(Float.class.getName(), StdSerializers.FloatSerializer.instance);
-        _concrete.put(Float.TYPE.getName(), StdSerializers.FloatSerializer.instance);
-        _concrete.put(Double.class.getName(), StdSerializers.DoubleSerializer.instance);
-        _concrete.put(Double.TYPE.getName(), StdSerializers.DoubleSerializer.instance);
-
-        // Other numbers, more complicated
-        final JsonSerializer<?> ns = new StdSerializers.NumberSerializer();
-        _concrete.put(BigInteger.class.getName(), ns);
-        _concrete.put(BigDecimal.class.getName(), ns);
-        
-        // Other discrete non-container types:
-        // First, Date/Time zoo:
-        _concrete.put(Calendar.class.getName(), CalendarSerializer.instance);
-        DateSerializer dateSer = DateSerializer.instance;
-        _concrete.put(java.util.Date.class.getName(), dateSer);
-        // note: timestamps are very similar to java.util.Date, thus serialized as such
-        _concrete.put(java.sql.Timestamp.class.getName(), dateSer);
-        _concrete.put(java.sql.Date.class.getName(), new StdSerializers.SqlDateSerializer());
-        _concrete.put(java.sql.Time.class.getName(), new StdSerializers.SqlTimeSerializer());
-
-        // And then other standard non-structured JDK types
-        for (Map.Entry<Class<?>,Object> en : new StdJdkSerializers().provide()) {
-            Object value = en.getValue();
-            if (value instanceof JsonSerializer<?>) {
-                _concrete.put(en.getKey().getName(), (JsonSerializer<?>) value);
-            } else if (value instanceof Class<?>) {
-                @SuppressWarnings("unchecked")
-                Class<? extends JsonSerializer<?>> cls = (Class<? extends JsonSerializer<?>>) value;
-                _concreteLazy.put(en.getKey().getName(), cls);
-            } else { // should never happen, but:
-                throw new IllegalStateException("Internal error: unrecognized value of type "+en.getClass().getName());
-            }
-        }
-
-        // Jackson-specific type(s)
-        // (Q: can this ever be sub-classed?)
-        _concreteLazy.put(TokenBuffer.class.getName(), TokenBufferSerializer.class);
-    }
-
-    protected final static HashMap<String, JsonSerializer<?>> _arraySerializers =
-        new HashMap<String, JsonSerializer<?>>();
-    static {
-        // Arrays of various types (including common object types)
-        _arraySerializers.put(boolean[].class.getName(), new StdArraySerializers.BooleanArraySerializer());
-        _arraySerializers.put(byte[].class.getName(), new StdArraySerializers.ByteArraySerializer());
-        _arraySerializers.put(char[].class.getName(), new StdArraySerializers.CharArraySerializer());
-        _arraySerializers.put(short[].class.getName(), new StdArraySerializers.ShortArraySerializer());
-        _arraySerializers.put(int[].class.getName(), new StdArraySerializers.IntArraySerializer());
-        _arraySerializers.put(long[].class.getName(), new StdArraySerializers.LongArraySerializer());
-        _arraySerializers.put(float[].class.getName(), new StdArraySerializers.FloatArraySerializer());
-        _arraySerializers.put(double[].class.getName(), new StdArraySerializers.DoubleArraySerializer());
-    }
-    
-    /**
-     * Helper object used to deal with serializers for optional JDK types (like ones
-     * omitted from GAE, Android)
-     */
-    protected OptionalHandlerFactory optionalHandlers = OptionalHandlerFactory.instance;
-
-    /*
-    /**********************************************************
-    /* Life cycle
-    /**********************************************************
-     */
-
-    /**
-     * We will provide default constructor to allow sub-classing,
-     * but make it protected so that no non-singleton instances of
-     * the class will be instantiated.
-     */
-    protected BasicSerializerFactory() { }
-
-    /*
-    /**********************************************************
-    /* SerializerFactory impl
-    /**********************************************************
-     */
-
-    // Implemented by sub-classes
-    @Override
-    public abstract JsonSerializer<Object> createSerializer(SerializationConfig config, JavaType type,
-            BeanProperty property)
-        throws JsonMappingException;
-
-    /**
-     * Method called to construct a type serializer for values with given declared
-     * base type. This is called for values other than those of bean property
-     * types.
-     */
-    @Override
-    public TypeSerializer createTypeSerializer(SerializationConfig config, JavaType baseType,
-            BeanProperty property)
-    {
-        BasicBeanDescription bean = config.introspectClassAnnotations(baseType.getRawClass());
-        AnnotatedClass ac = bean.getClassInfo();
-        AnnotationIntrospector ai = config.getAnnotationIntrospector();
-        TypeResolverBuilder<?> b = ai.findTypeResolver(config, ac, baseType);
-        /* Ok: if there is no explicit type info handler, we may want to
-         * use a default. If so, config object knows what to use.
-         */
-        Collection<NamedType> subtypes = null;
-        if (b == null) {
-            b = config.getDefaultTyper(baseType);
-        } else {
-            subtypes = config.getSubtypeResolver().collectAndResolveSubtypes(ac, config, ai);
-        }
-        return (b == null) ? null : b.buildTypeSerializer(config, baseType, subtypes, property);
-    }
-
-    
-    /*
-    /**********************************************************
-    /* Additional API for other core classes
-    /**********************************************************
-     */
-
-    public final JsonSerializer<?> getNullSerializer() {
-        return NullSerializer.instance;
-    }    
-
-    protected abstract Iterable<Serializers> customSerializers();
-    
-    /*
-    /**********************************************************
-    /* Overridable secondary serializer accessor methods
-    /**********************************************************
-     */
-    
-    /**
-     * Method that will use fast lookup (and identity comparison) methods to
-     * see if we know serializer to use for given type.
-     */
-    public final JsonSerializer<?> findSerializerByLookup(JavaType type, SerializationConfig config,
-            BasicBeanDescription beanDesc, BeanProperty property,
-            boolean staticTyping)
-    {
-        Class<?> raw = type.getRawClass();
-        String clsName = raw.getName();
-        JsonSerializer<?> ser = _concrete.get(clsName);
-        if (ser != null) {
-            return ser;
-        }
-        Class<? extends JsonSerializer<?>> serClass = _concreteLazy.get(clsName);
-        if (serClass != null) {
-            try {
-                return serClass.newInstance();
-            } catch (Exception e) {
-                throw new IllegalStateException("Failed to instantiate standard serializer (of type "+serClass.getName()+"): "
-                        +e.getMessage(), e);
-            }
-        }
-        return null;
-    }
-
-    /**
-     * Method for checking if we can determine serializer to use based on set of
-     * known primary types, checking for set of known base types (exact matches
-     * having been compared against with <code>findSerializerByLookup</code>).
-     * This does not include "secondary" interfaces, but
-     * mostly concrete or abstract base classes.
-     */
-    @SuppressWarnings("deprecation")
-    public final JsonSerializer<?> findSerializerByPrimaryType(JavaType type, SerializationConfig config,
-            BasicBeanDescription beanDesc, BeanProperty property,
-            boolean staticTyping)
-        throws JsonMappingException
-    {
-        Class<?> raw = type.getRawClass();
-        // First: JsonSerializable and related
-        if (JsonSerializable.class.isAssignableFrom(raw)) {
-            if (JsonSerializableWithType.class.isAssignableFrom(raw)) {
-                return SerializableWithTypeSerializer.instance;
-            }
-            return SerializableSerializer.instance;
-        }
-        // Second: as per [JACKSON-193] consider @JsonValue for any types:
-        AnnotatedMethod valueMethod = beanDesc.findJsonValueMethod();
-        if (valueMethod != null) {
-            // [JACKSON-586]: need to ensure accessibility of method
-            Method m = valueMethod.getAnnotated();
-            if (config.isEnabled(SerializationConfig.Feature.CAN_OVERRIDE_ACCESS_MODIFIERS)) {
-                ClassUtil.checkAndFixAccess(m);
-            }
-            JsonSerializer<Object> ser = findSerializerFromAnnotation(config, valueMethod, property);
-            return new JsonValueSerializer(m, ser, property);
-        }
-        
-        // One unfortunate special case, as per [JACKSON-484]
-        if (InetAddress.class.isAssignableFrom(raw)) {
-            return InetAddressSerializer.instance;
-        }
-        // ... and another one, [JACKSON-522], for TimeZone
-        if (TimeZone.class.isAssignableFrom(raw)) {
-            return TimeZoneSerializer.instance;
-        }
-        // and yet one more [JACKSON-789]
-        if (java.nio.charset.Charset.class.isAssignableFrom(raw)) {
-            return ToStringSerializer.instance;
-        }
-        
-        // Then check for optional/external serializers [JACKSON-386]
-        JsonSerializer<?> ser = optionalHandlers.findSerializer(config, type);
-        if (ser != null) {
-            return ser;
-        }
-        
-        if (Number.class.isAssignableFrom(raw)) {
-            return StdSerializers.NumberSerializer.instance;
-        }
-        if (Enum.class.isAssignableFrom(raw)) {
-            @SuppressWarnings("unchecked")
-            Class<Enum<?>> enumClass = (Class<Enum<?>>) raw;
-            return EnumSerializer.construct(enumClass, config, beanDesc);
-        }
-        if (Calendar.class.isAssignableFrom(raw)) {
-            return CalendarSerializer.instance;
-        }
-        if (java.util.Date.class.isAssignableFrom(raw)) {
-            return DateSerializer.instance;
-        }
-        return null;
-    }
-        
-    /**
-     * Reflection-based serialized find method, which checks if
-     * given class implements one of recognized "add-on" interfaces.
-     * Add-on here means a role that is usually or can be a secondary
-     * trait: for example,
-     * bean classes may implement {@link Iterable}, but their main
-     * function is usually something else. The reason for
-     */
-    public final JsonSerializer<?> findSerializerByAddonType(SerializationConfig config, JavaType javaType,
-            BasicBeanDescription beanDesc, BeanProperty property,
-            boolean staticTyping)
-        throws JsonMappingException
-    {
-        Class<?> type = javaType.getRawClass();
-
-        // These need to be in decreasing order of specificity...
-        if (Iterator.class.isAssignableFrom(type)) {
-            return buildIteratorSerializer(config, javaType, beanDesc, property, staticTyping);
-        }
-        if (Iterable.class.isAssignableFrom(type)) {
-            return buildIterableSerializer(config, javaType, beanDesc, property, staticTyping);
-        }
-        if (CharSequence.class.isAssignableFrom(type)) {
-            return ToStringSerializer.instance;
-        }
-        return null;
-    }
-    
-    /**
-     * Helper method called to check if a class or method
-     * has an annotation
-     * (@link sh.calaba.org.codehaus.jackson.map.ser.JsonSerialize#using)
-     * that tells the class to use for serialization.
-     * Returns null if no such annotation found.
-     */
-    @SuppressWarnings("unchecked")
-    protected JsonSerializer<Object> findSerializerFromAnnotation(SerializationConfig config, Annotated a,
-            BeanProperty property)
-        throws JsonMappingException
-    {
-        Object serDef = config.getAnnotationIntrospector().findSerializer(a);
-        if (serDef == null) {
-            return null;
-        }
-        if (serDef instanceof JsonSerializer) {
-            JsonSerializer<Object> ser = (JsonSerializer<Object>) serDef;
-            if (ser instanceof ContextualSerializer<?>) {
-                return ((ContextualSerializer<Object>) ser).createContextual(config, property);
-            }
-            return ser;
-        }
-        /* Alas, there's no way to force return type of "either class
-         * X or Y" -- need to throw an exception after the fact
-         */
-        if (!(serDef instanceof Class)) {
-            throw new IllegalStateException("AnnotationIntrospector returned value of type "+serDef.getClass().getName()+"; expected type JsonSerializer or Class<JsonSerializer> instead");
-        }
-        Class<?> cls = (Class<?>) serDef;
-        if (!JsonSerializer.class.isAssignableFrom(cls)) {
-            throw new IllegalStateException("AnnotationIntrospector returned Class "+cls.getName()+"; expected Class<JsonSerializer>");
-        }
-        JsonSerializer<Object> ser = config.serializerInstance(a, (Class<? extends JsonSerializer<?>>) cls);
-        if (ser instanceof ContextualSerializer<?>) {
-            return ((ContextualSerializer<Object>) ser).createContextual(config, property);
-        }
-        return ser;
-    }
-
-    /*
-    /**********************************************************
-    /* Factory methods, container types:
-    /**********************************************************
-     */
-    
-    public JsonSerializer<?> buildContainerSerializer(SerializationConfig config, JavaType type,
-            BasicBeanDescription beanDesc, BeanProperty property, boolean staticTyping)
-    {
-        // Let's see what we can learn about element/content/value type, type serializer for it:
-        JavaType elementType = type.getContentType();
-        TypeSerializer elementTypeSerializer = createTypeSerializer(config, elementType, property);
-        
-        // if elements have type serializer, can not force static typing:
-        if (elementTypeSerializer != null) {
-            staticTyping = false;
-        } else if (!staticTyping) {
-            staticTyping = usesStaticTyping(config, beanDesc, elementTypeSerializer, property);
-        }
-        JsonSerializer<Object> elementValueSerializer = findContentSerializer(config,
-                beanDesc.getClassInfo(), property);
-        
-        if (type.isMapLikeType()) { // implements java.util.Map
-            MapLikeType mlt = (MapLikeType) type;
-            JsonSerializer<Object> keySerializer = findKeySerializer(config, beanDesc.getClassInfo(), property);
-            if (mlt.isTrueMapType()) {
-                return buildMapSerializer(config, (MapType) mlt, beanDesc, property, staticTyping,
-                        keySerializer, elementTypeSerializer, elementValueSerializer);
-            }
-            return buildMapLikeSerializer(config, mlt, beanDesc, property, staticTyping,
-                    keySerializer, elementTypeSerializer, elementValueSerializer);
-        }
-        if (type.isCollectionLikeType()) {
-            CollectionLikeType clt = (CollectionLikeType) type;
-            if (clt.isTrueCollectionType()) {
-                return buildCollectionSerializer(config, (CollectionType) clt, beanDesc, property, staticTyping,
-                        elementTypeSerializer, elementValueSerializer);
-            }
-            return buildCollectionLikeSerializer(config, clt, beanDesc, property, staticTyping,
-                    elementTypeSerializer, elementValueSerializer);
-        }
-        if (type.isArrayType()) {
-            return buildArraySerializer(config, (ArrayType) type, beanDesc, property, staticTyping,
-                    elementTypeSerializer, elementValueSerializer);
-        }
-        return null;
-    }
-    
-    /**
-     * Helper method that handles configuration details when constructing serializers for
-     * Collection and Collection-like types.
-     * 
-     * @since 1.8
-     */
-    protected JsonSerializer<?> buildCollectionLikeSerializer(SerializationConfig config,
-            CollectionLikeType type,
-            BasicBeanDescription beanDesc, BeanProperty property,
-            boolean staticTyping,
-            TypeSerializer elementTypeSerializer, JsonSerializer<Object> elementValueSerializer) 
-    {
-        for (Serializers serializers : customSerializers()) {
-            JsonSerializer<?> ser = serializers.findCollectionLikeSerializer(config, type, beanDesc, property,
-                    elementTypeSerializer, elementValueSerializer);
-            if (ser != null) {
-                return ser;
-            }
-        }
-        return null;
-    }
-
-    /**
-     * Helper method that handles configuration details when constructing serializers for
-     * {@link java.util.List} types that support efficient by-index access
-     *<p> 
-     * Note: signature changed in 1.8, to take 'staticTyping' argument
-     */
-    protected JsonSerializer<?> buildCollectionSerializer(SerializationConfig config,
-            CollectionType type,
-            BasicBeanDescription beanDesc, BeanProperty property,
-            boolean staticTyping,
-            TypeSerializer elementTypeSerializer, JsonSerializer<Object> elementValueSerializer) 
-    {
-        // Module-provided custom collection serializers?
-        for (Serializers serializers : customSerializers()) {
-            JsonSerializer<?> ser = serializers.findCollectionSerializer(config, type, beanDesc, property,
-                    elementTypeSerializer, elementValueSerializer);
-            if (ser != null) {
-                return ser;
-            }
-        }
-        Class<?> raw = type.getRawClass();
-        if (EnumSet.class.isAssignableFrom(raw)) {
-            return buildEnumSetSerializer(config, type, beanDesc, property, staticTyping,
-                    elementTypeSerializer, elementValueSerializer);
-        }
-        Class<?> elementRaw = type.getContentType().getRawClass();
-        if (isIndexedList(raw)) {
-            if (elementRaw == String.class) {
-                return new IndexedStringListSerializer(property);
-            }
-            return StdContainerSerializers.indexedListSerializer(type.getContentType(), staticTyping,
-                    elementTypeSerializer, property, elementValueSerializer);
-        }
-        if (elementRaw == String.class) {
-            return new StringCollectionSerializer(property);
-        }
-        return StdContainerSerializers.collectionSerializer(type.getContentType(), staticTyping,
-                elementTypeSerializer, property, elementValueSerializer);
-    }
-
-    protected JsonSerializer<?> buildEnumSetSerializer(SerializationConfig config, JavaType type,
-            BasicBeanDescription beanDesc, BeanProperty property,
-            boolean staticTyping,
-            TypeSerializer elementTypeSerializer, JsonSerializer<Object> elementValueSerializer) 
-    {
-        // this may or may not be available (Class doesn't; type of field/method does)
-        JavaType enumType = type.getContentType();
-        // and even if nominally there is something, only use if it really is enum
-        if (!enumType.isEnumType()) {
-            enumType = null;
-        }
-        return StdContainerSerializers.enumSetSerializer(enumType, property);
-    }
-    
-    /**
-     * @since 1.8
-     */
-    protected boolean isIndexedList(Class<?> cls)
-    {
-        return RandomAccess.class.isAssignableFrom(cls);
-    }
-    
-    /*
-    /**********************************************************
-    /* Factory methods, for Maps
-    /**********************************************************
-     */
-    
-    /**
-     * Helper method that handles configuration details when constructing serializers for
-     * all "Map-like" types; both ones that implement {@link java.util.Map} and
-     * ones that do not (but that have been indicated to behave like Maps).
-     * 
-     * @since 1.8
-     */
-    protected JsonSerializer<?> buildMapLikeSerializer(SerializationConfig config, MapLikeType type,
-            BasicBeanDescription beanDesc, BeanProperty property,
-            boolean staticTyping,
-            JsonSerializer<Object> keySerializer,
-            TypeSerializer elementTypeSerializer, JsonSerializer<Object> elementValueSerializer)
-    {
-        for (Serializers serializers : customSerializers()) {
-            JsonSerializer<?> ser = serializers.findMapLikeSerializer(config, type, beanDesc, property,
-                    keySerializer, elementTypeSerializer, elementValueSerializer);
-            if (ser != null) {
-                return ser;
-            }
-        }
-        return null;
-    }
-    
-    /**
-     * Helper method that handles configuration details when constructing serializers for
-     * {@link java.util.Map} types.
-     *<p> 
-     * Note: signature changed in 1.8, to take 'staticTyping' argument
-     */
-    protected JsonSerializer<?> buildMapSerializer(SerializationConfig config, MapType type,
-            BasicBeanDescription beanDesc, BeanProperty property,
-            boolean staticTyping,
-            JsonSerializer<Object> keySerializer,
-            TypeSerializer elementTypeSerializer, JsonSerializer<Object> elementValueSerializer)
-    {
-        for (Serializers serializers : customSerializers()) {
-            JsonSerializer<?> ser = serializers.findMapSerializer(config, type, beanDesc, property,
-                    keySerializer, elementTypeSerializer, elementValueSerializer);
-            if (ser != null) {
-                return ser;
-            }
-        }
-        if (EnumMap.class.isAssignableFrom(type.getRawClass())) {
-            return buildEnumMapSerializer(config, type, beanDesc, property, staticTyping,
-                    elementTypeSerializer, elementValueSerializer);
-        }
-        return MapSerializer.construct(config.getAnnotationIntrospector().findPropertiesToIgnore(beanDesc.getClassInfo()),
-                type, staticTyping, elementTypeSerializer, property,
-                keySerializer, elementValueSerializer);
-    }
-    
-    /**
-     * Helper method that handles configuration details when constructing serializers for
-     * {@link java.util.EnumMap} types.
-     *<p> 
-     * Note: signature changed in 1.8, to take 'staticTyping' argument
-     */
-    protected JsonSerializer<?> buildEnumMapSerializer(SerializationConfig config, JavaType type,
-            BasicBeanDescription beanDesc, BeanProperty property,
-            boolean staticTyping,
-            TypeSerializer elementTypeSerializer, JsonSerializer<Object> elementValueSerializer) 
-    {
-        JavaType keyType = type.getKeyType();
-        // Need to find key enum values...
-        EnumValues enums = null;
-        if (keyType.isEnumType()) { // non-enum if we got it as type erased class (from instance)
-            @SuppressWarnings("unchecked")
-            Class<Enum<?>> enumClass = (Class<Enum<?>>) keyType.getRawClass();
-            enums = EnumValues.construct(enumClass, config.getAnnotationIntrospector());
-        }
-        return new EnumMapSerializer(type.getContentType(), staticTyping, enums,
-            elementTypeSerializer, property, elementValueSerializer);
-    }
-
-    /*
-    /**********************************************************
-    /* Factory methods, for Arrays
-    /**********************************************************
-     */
-    
-    /**
-     * Helper method that handles configuration details when constructing serializers for
-     * <code>Object[]</code> (and subtypes, except for String).
-     */
-    protected JsonSerializer<?> buildArraySerializer(SerializationConfig config, ArrayType type,
-            BasicBeanDescription beanDesc, BeanProperty property,
-            boolean staticTyping,
-            TypeSerializer elementTypeSerializer, JsonSerializer<Object> elementValueSerializer)
-    {
-        Class<?> raw = type.getRawClass();
-        if (String[].class == raw) {
-            return new StdArraySerializers.StringArraySerializer(property);
-        }
-        // other standard types?
-        JsonSerializer<?> ser = _arraySerializers.get(raw.getName());
-        if (ser != null) {
-            return ser;
-        }
-        return new ObjectArraySerializer(type.getContentType(), staticTyping, elementTypeSerializer,
-                property, elementValueSerializer);
-    }
-
-    /*
-    /**********************************************************
-    /* Factory methods, for non-container types
-    /**********************************************************
-     */
-
-    protected JsonSerializer<?> buildIteratorSerializer(SerializationConfig config, JavaType type,
-            BasicBeanDescription beanDesc, BeanProperty property,
-            boolean staticTyping)
-    {
-        // if there's generic type, it'll be the first contained type
-        JavaType valueType = type.containedType(0);
-        if (valueType == null) {
-            valueType = TypeFactory.unknownType();
-        }
-        TypeSerializer vts = createTypeSerializer(config, valueType, property);
-        return StdContainerSerializers.iteratorSerializer(valueType,
-                usesStaticTyping(config, beanDesc, vts, property), vts, property);
-    }
-    
-    protected JsonSerializer<?> buildIterableSerializer(SerializationConfig config, JavaType type,
-            BasicBeanDescription beanDesc, BeanProperty property,
-            boolean staticTyping)
-    {
-        // if there's generic type, it'll be the first contained type
-        JavaType valueType = type.containedType(0);
-        if (valueType == null) {
-            valueType = TypeFactory.unknownType();
-        }
-        TypeSerializer vts = createTypeSerializer(config, valueType, property);
-        return StdContainerSerializers.iterableSerializer(valueType,
-                usesStaticTyping(config, beanDesc, vts, property), vts, property);
-    }
-    
-    /*
-    /**********************************************************
-    /* Other helper methods
-    /**********************************************************
-     */
-    
-    /**
-     * Helper method used to encapsulate details of annotation-based type
-     * coercion
-     * 
-     * @since 1.8
-     */
-    @SuppressWarnings("unchecked")
-    protected <T extends JavaType> T modifyTypeByAnnotation(SerializationConfig config, Annotated a, T type)
-    {
-        // first: let's check class for the instance itself:
-        Class<?> superclass = config.getAnnotationIntrospector().findSerializationType(a);
-        if (superclass != null) {
-            try {
-                type = (T) type.widenBy(superclass);
-            } catch (IllegalArgumentException iae) {
-                throw new IllegalArgumentException("Failed to widen type "+type+" with concrete-type annotation (value "+superclass.getName()+"), method '"+a.getName()+"': "+iae.getMessage());
-            }
-        }
-        return modifySecondaryTypesByAnnotation(config, a, type);
-    }
-
-    /**
-     * @since 1.8
-     */
-    @SuppressWarnings("unchecked")
-    protected static <T extends JavaType> T modifySecondaryTypesByAnnotation(SerializationConfig config, Annotated a, T type)
-    {
-        AnnotationIntrospector intr = config.getAnnotationIntrospector();
-        // then key class
-        if (type.isContainerType()) {
-            Class<?> keyClass = intr.findSerializationKeyType(a, type.getKeyType());
-            if (keyClass != null) {
-                // illegal to use on non-Maps
-                if (!(type instanceof MapType)) {
-                    throw new IllegalArgumentException("Illegal key-type annotation: type "+type+" is not a Map type");
-                }
-                try {
-                    type = (T) ((MapType) type).widenKey(keyClass);
-                } catch (IllegalArgumentException iae) {
-                    throw new IllegalArgumentException("Failed to narrow key type "+type+" with key-type annotation ("+keyClass.getName()+"): "+iae.getMessage());
-                }
-            }
-            
-            // and finally content class; only applicable to structured types
-            Class<?> cc = intr.findSerializationContentType(a, type.getContentType());
-            if (cc != null) {
-                try {
-                    type = (T) type.widenContentsBy(cc);
-                } catch (IllegalArgumentException iae) {
-                    throw new IllegalArgumentException("Failed to narrow content type "+type+" with content-type annotation ("+cc.getName()+"): "+iae.getMessage());
-                }
-            }
-        }
-        return type;
-    }
-
-    protected static JsonSerializer<Object> findKeySerializer(SerializationConfig config,
-            Annotated a, BeanProperty property)
-    {
-        AnnotationIntrospector intr = config.getAnnotationIntrospector();
-        Class<? extends JsonSerializer<?>> serClass = intr.findKeySerializer(a);
-        if (serClass == null || serClass == JsonSerializer.None.class) {
-            if (property != null) {
-                serClass = intr.findKeySerializer(property.getMember());
-            }
-        }
-        if (serClass != null && serClass != JsonSerializer.None.class) {
-            return config.serializerInstance(a, serClass);
-        }
-        return null;
-    }
-
-    protected static JsonSerializer<Object> findContentSerializer(SerializationConfig config,
-            Annotated a, BeanProperty property)
-    {
-        AnnotationIntrospector intr = config.getAnnotationIntrospector();
-        Class<? extends JsonSerializer<?>> serClass = intr.findContentSerializer(a);
-        if (serClass == null || serClass == JsonSerializer.None.class) {
-            if (property != null) {
-                serClass = intr.findContentSerializer(property.getMember());
-            }
-        }
-        if (serClass != null && serClass != JsonSerializer.None.class) {
-            return config.serializerInstance(a, serClass);
-        }
-        return null;
-    }
-    
-    /**
-     * Helper method to check whether global settings and/or class
-     * annotations for the bean class indicate that static typing
-     * (declared types)  should be used for properties.
-     * (instead of dynamic runtime types).
-     */
-    protected boolean usesStaticTyping(SerializationConfig config, BasicBeanDescription beanDesc,
-            TypeSerializer typeSer, BeanProperty property)
-    {
-        /* 16-Aug-2010, tatu: If there is a (value) type serializer, we can not force
-         *    static typing; that would make it impossible to handle expected subtypes
-         */
-        if (typeSer != null) {
-            return false;
-        }
-        AnnotationIntrospector intr = config.getAnnotationIntrospector();
-        JsonSerialize.Typing t = intr.findSerializationTyping(beanDesc.getClassInfo());
-        if (t != null) {
-            if (t == JsonSerialize.Typing.STATIC) {
-                return true;
-            }
-        } else {
-            if (config.isEnabled(SerializationConfig.Feature.USE_STATIC_TYPING)) {
-                return true;
-            }
-        }
-        /* 11-Mar-2011, tatu: Ok. This is bit hacky, but we really need to be able to find cases
-         *    where key and/or value serializers were specified, to force use of static typing
-         */
-        if (property != null) {
-            JavaType type = property.getType();
-            if (type.isContainerType()) {
-                if (intr.findSerializationContentType(property.getMember(), property.getType()) != null) {
-                    return true;
-                }
-                if (type instanceof MapType) {
-                    if (intr.findSerializationKeyType(property.getMember(), property.getType()) != null) {
-                        return true;
-                    }
-                }
-            }
-        }
-        return false;
-    }
-}