calabash-android 0.5.2 → 0.5.3

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

@@ -1,34 +0,0 @@
-package sh.calaba.org.codehaus.jackson.map;
-
-import java.io.IOException;
-
-import sh.calaba.org.codehaus.jackson.JsonGenerator;
-import sh.calaba.org.codehaus.jackson.JsonProcessingException;
-
-/**
- * Interface that can be implemented by objects that know how to
- * serialize themselves to JSON, using {@link JsonGenerator}
- * (and {@link SerializerProvider} if necessary).
- *<p>
- * Note that implementing this interface binds implementing object
- * closely to Jackson API, and that it is often not necessary to do
- * so -- if class is a bean, it can be serialized without
- * implementing this interface.
- *<p>
- * NOTE: as of version 1.5, this interface is missing one crucial
- * aspect, that of dealing with type information embedding.
- * Because of this, this interface is deprecated, although will be
- * fully supported for all 1.x releases, and will work except for
- * cases where polymorphic type information handling is needed for
- * type (in which case implementing if {@link JsonSerializableWithType} is crucial).
- *
- * @see sh.calaba.org.codehaus.jackson.map.JsonSerializableWithType
- *
- * @since 1.5
- */
-@Deprecated
-public interface JsonSerializable
-{
-    public void serialize(JsonGenerator jgen, SerializerProvider provider)
-        throws IOException, JsonProcessingException;
-}

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

@@ -1,22 +0,0 @@
-package sh.calaba.org.codehaus.jackson.map;
-
-import java.io.IOException;
-
-import sh.calaba.org.codehaus.jackson.JsonGenerator;
-import sh.calaba.org.codehaus.jackson.JsonProcessingException;
-
-/**
- * Interface that is to replace {@link JsonSerializable} to
- * allow for dynamic type information embedding.
- * 
- * @since 1.5
- * @author tatu
- */
-@SuppressWarnings("deprecation")
-public interface JsonSerializableWithType
-    extends JsonSerializable
-{
-    public void serializeWithType(JsonGenerator jgen, SerializerProvider provider,
-            TypeSerializer typeSer)
-        throws IOException, JsonProcessingException;
-}

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

@@ -1,138 +0,0 @@
-package sh.calaba.org.codehaus.jackson.map;
-
-import java.io.IOException;
-
-import sh.calaba.org.codehaus.jackson.JsonGenerator;
-import sh.calaba.org.codehaus.jackson.JsonProcessingException;
-
-/**
- * Abstract class that defines API used by {@link ObjectMapper} (and
- * other chained {@link JsonSerializer}s too) to serialize Objects of
- * arbitrary types into JSON, using provided {@link JsonGenerator}.
- *<p>
- * NOTE: it is recommended that custom serializers extend
- * {@link sh.calaba.org.codehaus.jackson.map.ser.std.SerializerBase} instead
- * of this class, since it will implement many of optional
- * methods of this class.
- */
-public abstract class JsonSerializer<T>
-{
-    /*
-    /**********************************************************
-    /* Fluent factory methods for constructing decorated versions
-    /**********************************************************
-     */
-
-    /**
-     * Method that will return serializer instance that produces
-     * "unwrapped" serialization, if applicable for type being
-     * serialized (which is the case for some serializers
-     * that produce JSON Objects as output).
-     * If no unwrapped serializer can be constructed, will simply
-     * return serializer as-is.
-     *<p>
-     * Default implementation just returns serializer as-is,
-     * indicating that no unwrapped variant exists
-     * 
-     * @since 1.9
-     */
-    public JsonSerializer<T> unwrappingSerializer() {
-        return this;
-    }
-
-    /**
-     * Accessor for checking whether this serializer is an
-     * "unwrapping" serializer; this is necessary to know since
-     * it may also require caller to suppress writing of the
-     * leading property name.
-     * 
-     * @since 1.9
-     */
-    public boolean isUnwrappingSerializer() {
-        return false;
-    }
-    
-    /*
-    /**********************************************************
-    /* Serialization methods
-    /**********************************************************
-     */
-
-    /**
-     * Method that can be called to ask implementation to serialize
-     * values of type this serializer handles.
-     *
-     * @param value Value to serialize; can <b>not</b> be null.
-     * @param jgen Generator used to output resulting Json content
-     * @param provider Provider that can be used to get serializers for
-     *   serializing Objects value contains, if any.
-     */
-    public abstract void serialize(T value, JsonGenerator jgen, SerializerProvider provider)
-        throws IOException, JsonProcessingException;
-
-    /**
-     * Method that can be called to ask implementation to serialize
-     * values of type this serializer handles, using specified type serializer
-     * for embedding necessary type information.
-     *<p>
-     * Default implementation will ignore serialization of type information,
-     * and just calls {@link #serialize}: serializers that can embed
-     * type information should override this to implement actual handling.
-     * Most common such handling is done by something like:
-     *<pre>
-     *  // note: method to call depends on whether this type is serialized as JSON scalar, object or Array!
-     *  typeSer.writeTypePrefixForScalar(value, jgen);
-     *  serialize(value, jgen, provider);
-     *  typeSer.writeTypeSuffixForScalar(value, jgen);
-     *</pre>
-     *
-     * @param value Value to serialize; can <b>not</b> be null.
-     * @param jgen Generator used to output resulting Json content
-     * @param provider Provider that can be used to get serializers for
-     *   serializing Objects value contains, if any.
-     * @param typeSer Type serializer to use for including type information
-     *
-     * @since 1.5
-     */
-    public void serializeWithType(T value, JsonGenerator jgen, SerializerProvider provider,
-            TypeSerializer typeSer)
-        throws IOException, JsonProcessingException
-    {
-        serialize(value, jgen, provider);
-    }
-    
-    /*
-    /**********************************************************
-    /* Introspection methods needed for type handling 
-    /**********************************************************
-     */
-    
-    /**
-     * Method for accessing type of Objects this serializer can handle.
-     * Note that this information is not guaranteed to be exact -- it
-     * may be a more generic (super-type) -- but it should not be
-     * incorrect (return a non-related type).
-     *<p>
-     * Default implementation will return null, which essentially means
-     * same as returning <code>Object.class</code> would; that is, that
-     * nothing is known about handled type.
-     *<p>
-     */
-    public Class<T> handledType() { return null; }
-    
-    /*
-    /**********************************************************
-    /* Helper class(es)
-    /**********************************************************
-     */
-
-    /**
-     * This marker class is only to be used with annotations, to
-     * indicate that <b>no serializer is configured</b>.
-     *<p>
-     * Specifically, this class is to be used as the marker for
-     * annotation {@link sh.calaba.org.codehaus.jackson.map.annotate.JsonSerialize}.
-     */
-    public abstract static class None
-        extends JsonSerializer<Object> { }
-}

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

@@ -1,31 +0,0 @@
-package sh.calaba.org.codehaus.jackson.map;
-
-import java.io.IOException;
-
-import sh.calaba.org.codehaus.jackson.JsonProcessingException;
-
-/**
- * Abstract class that defines API used for deserializing JSON content
- * field names into Java Map keys. These deserializers are only used
- * if the Map key class is not <code>String</code> or <code>Object</code>.
- */
-public abstract class KeyDeserializer
-{
-    /**
-     * Method called to deserialize a {@link java.util.Map} key from JSON property name.
-     */
-    public abstract Object deserializeKey(String key, DeserializationContext ctxt)
-        throws IOException, JsonProcessingException;
-
-    /**
-     * This marker class is only to be used with annotations, to
-     * indicate that <b>no deserializer is configured</b>.
-     *<p>
-     * Specifically, this class is to be used as the marker for
-     * annotation {@link sh.calaba.org.codehaus.jackson.map.annotate.JsonDeserialize}.
-     *
-     * @since 1.3
-     */
-    public abstract static class None
-        extends KeyDeserializer { }
-}

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

@@ -1,21 +0,0 @@
-package sh.calaba.org.codehaus.jackson.map;
-
-import sh.calaba.org.codehaus.jackson.type.JavaType;
-
-/**
- * Interface that defines API for simple extensions that can provide additional deserializers
- * for deserializer Map keys of various types, from JSON property names.
- * Access is by a single callback method; instance is to either return
- * a configured {@link KeyDeserializer} for specified type, or null to indicate that it
- * does not support handling of the type. In latter case, further calls can be made
- * for other providers; in former case returned key deserializer is used for handling of
- * key instances of specified type.
- * 
- * @since 1.8
- */
-public interface KeyDeserializers
-{
-    public KeyDeserializer findKeyDeserializer(JavaType type, DeserializationConfig config,
-            BeanDescription beanDesc, BeanProperty property)
-        throws JsonMappingException;
-}

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

@@ -1,1154 +0,0 @@
-package sh.calaba.org.codehaus.jackson.map;
-
-import java.text.DateFormat;
-import java.util.HashMap;
-import java.util.Map;
-
-import sh.calaba.org.codehaus.jackson.annotate.JsonAutoDetect;
-import sh.calaba.org.codehaus.jackson.annotate.JsonMethod;
-import sh.calaba.org.codehaus.jackson.map.introspect.Annotated;
-import sh.calaba.org.codehaus.jackson.map.introspect.VisibilityChecker;
-import sh.calaba.org.codehaus.jackson.map.jsontype.SubtypeResolver;
-import sh.calaba.org.codehaus.jackson.map.jsontype.TypeIdResolver;
-import sh.calaba.org.codehaus.jackson.map.jsontype.TypeResolverBuilder;
-import sh.calaba.org.codehaus.jackson.map.jsontype.impl.StdSubtypeResolver;
-import sh.calaba.org.codehaus.jackson.map.type.ClassKey;
-import sh.calaba.org.codehaus.jackson.map.type.TypeBindings;
-import sh.calaba.org.codehaus.jackson.map.type.TypeFactory;
-import sh.calaba.org.codehaus.jackson.map.util.ClassUtil;
-import sh.calaba.org.codehaus.jackson.map.util.StdDateFormat;
-import sh.calaba.org.codehaus.jackson.type.JavaType;
-import sh.calaba.org.codehaus.jackson.type.TypeReference;
-
-/**
- * Interface that defines functionality accessible through both
- * serialization and deserialization configuration objects;
- * accessors to mode-independent configuration settings
- * and such.
- *<p>
- * As of version 1.9, the goal is to make this class eventually immutable.
- * Because of this, existing methods that allow changing state of this
- * instance are deprecated in favor of methods that create new instances
- * with different configuration ("fluent factories").
- * One major remaining issue is that of handling mix-in annotations, which
- * still represent a bit of mutable state; may need to implement a
- * functional-style immutable map for storing those.
- *
- * @since 1.2 -- major change in 1.8, changed from interface to
- *   abstract class
- */
-public abstract class MapperConfig<T extends MapperConfig<T>>
-    implements ClassIntrospector.MixInResolver
-{
-    /*
-    /**********************************************************
-    /* Constants, default values
-    /**********************************************************
-     */
-
-    /**
-     * This is the default {@link DateFormat} used unless overridden by
-     * custom implementation.
-     */
-    protected final static DateFormat DEFAULT_DATE_FORMAT = StdDateFormat.instance;
-
-    /*
-    /**********************************************************
-    /* Simple immutable basic settings
-    /**********************************************************
-     */
-
-    /**
-     * Immutable container object for simple configuration settings.
-     *<p>
-     * Note: ideally this would be final, but until we can eliminate
-     * mutators, must keep it mutable.
-     */
-    protected Base _base;
-    
-    /*
-    /**********************************************************
-    /* Mix-in annotations
-    /**********************************************************
-     */
-    
-    /**
-     * Mapping that defines how to apply mix-in annotations: key is
-     * the type to received additional annotations, and value is the
-     * type that has annotations to "mix in".
-     *<p>
-     * Annotations associated with the value classes will be used to
-     * override annotations of the key class, associated with the
-     * same field or method. They can be further masked by sub-classes:
-     * you can think of it as injecting annotations between the target
-     * class and its sub-classes (or interfaces)
-     *
-     * @since 1.2
-     */
-    protected HashMap<ClassKey,Class<?>> _mixInAnnotations;
-
-    /**
-     * Flag used to detect when a copy if mix-in annotations is
-     * needed: set when current copy is shared, cleared when a
-     * fresh copy is made
-     *
-     * @since 1.2
-     */
-    protected boolean _mixInAnnotationsShared;
-
-    /*
-    /**********************************************************
-    /* "Late bound" settings
-    /**********************************************************
-     */
-
-    /**
-     * Registered concrete subtypes that can be used instead of (or
-     * in addition to) ones declared using annotations.
-     * Unlike most other settings, it is not configured as early
-     * as it is set, but rather only when a non-shared instance
-     * is constructed by <code>ObjectMapper</code> (or -Reader
-     * or -Writer)
-     *<p>
-     * Note: this is the only property left as non-final, to allow
-     * lazy construction of the instance as necessary.
-     * 
-     * @since 1.6
-     */
-    protected SubtypeResolver _subtypeResolver;
-    
-    /*
-    /**********************************************************
-    /* Life-cycle: constructors
-    /**********************************************************
-     */
-
-    protected MapperConfig(ClassIntrospector<? extends BeanDescription> ci, AnnotationIntrospector ai,
-            VisibilityChecker<?> vc, SubtypeResolver str, PropertyNamingStrategy pns, TypeFactory tf,
-            HandlerInstantiator hi)
-    {
-        _base = new Base(ci, ai, vc, pns, tf, null, DEFAULT_DATE_FORMAT, hi);
-        _subtypeResolver = str;
-        // by default, assumed to be shared; only cleared when explicit copy is made
-        _mixInAnnotationsShared = true;
-    }
-
-    /**
-     * Simple copy constructor
-     * 
-     * @since 1.8
-     */
-    protected MapperConfig(MapperConfig<T> src) {
-        this(src, src._base, src._subtypeResolver);
-    }
-
-    /**
-     * @since 1.8
-     */
-    protected MapperConfig(MapperConfig<T> src, MapperConfig.Base base, SubtypeResolver str)
-    {
-        _base = base;
-        _subtypeResolver = str;
-        // by default, assumed to be shared; only cleared when explicit copy is made
-        _mixInAnnotationsShared = true;
-        _mixInAnnotations = src._mixInAnnotations;
-    }
-    
-    /*
-    /**********************************************************
-    /* Life-cycle: factory methods
-    /**********************************************************
-     */
-    
-    /**
-     * Method that checks class annotations that the argument Object has,
-     * and modifies settings of this configuration object accordingly,
-     * similar to how those annotations would affect actual value classes
-     * annotated with them, but with global scope. Note that not all
-     * annotations have global significance, and thus only subset of
-     * Jackson annotations will have any effect.
-     * 
-     * @deprecated Since 1.9, it is preferably to explicitly configure
-     *   instances; this method also modifies existing instance which is
-     *   against immutable design goals of this class.
-     */
-    @Deprecated
-    public abstract void fromAnnotations(Class<?> cls);
-
-    /**
-     * Method to use for constructing an instance that is not shared
-     * between multiple operations but only used for a single one
-     * (which may be this instance, if it is immutable; if not, a copy
-     * is constructed with same settings)
-     * 
-     * @since 1.8
-     */
-    public abstract T createUnshared(SubtypeResolver subtypeResolver);
-
-    /**
-     * Method for constructing and returning a new instance with different
-     * {@link ClassIntrospector}
-     * to use.
-     *<p>
-     * NOTE: make sure to register new instance with <code>ObjectMapper</code>
-     * if directly calling this method.
-     * 
-     * @since 1.8
-     */
-    public abstract T withClassIntrospector(ClassIntrospector<? extends BeanDescription> ci);
-
-    /**
-     * Method for constructing and returning a new instance with different
-     * {@link AnnotationIntrospector} to use (replacing old one).
-     *<p>
-     * NOTE: make sure to register new instance with <code>ObjectMapper</code>
-     * if directly calling this method.
-     * 
-     * @since 1.8
-     */
-    public abstract T withAnnotationIntrospector(AnnotationIntrospector ai);
-    
-    /**
-     * Method for constructing and returning a new instance with different
-     * {@link VisibilityChecker}
-     * to use.
-     *<p>
-     * NOTE: make sure to register new instance with <code>ObjectMapper</code>
-     * if directly calling this method.
-     * 
-     * @since 1.8
-     */
-    public abstract T withVisibilityChecker(VisibilityChecker<?> vc);
-
-    /**
-     * Method for constructing and returning a new instance with different
-     * minimal visibility level for specified property type
-     *<p>
-     * NOTE: make sure to register new instance with <code>ObjectMapper</code>
-     * if directly calling this method.
-     * 
-     * @since 1.9
-     */
-    public abstract T withVisibility(JsonMethod forMethod, JsonAutoDetect.Visibility visibility);
-    
-    /**
-     * Method for constructing and returning a new instance with different
-     * {@link TypeResolverBuilder}
-     * to use.
-     *<p>
-     * NOTE: make sure to register new instance with <code>ObjectMapper</code>
-     * if directly calling this method.
-     * 
-     * @since 1.8
-     */
-    public abstract T withTypeResolverBuilder(TypeResolverBuilder<?> trb);
-    
-    /**
-     * Method for constructing and returning a new instance with different
-     * {@link SubtypeResolver}
-     * to use.
-     *<p>
-     * NOTE: make sure to register new instance with <code>ObjectMapper</code>
-     * if directly calling this method.
-     * 
-     * @since 1.8
-     */
-    public abstract T withSubtypeResolver(SubtypeResolver str);
-    
-    /**
-     * Method for constructing and returning a new instance with different
-     * {@link PropertyNamingStrategy}
-     * to use.
-     *<p>
-     * NOTE: make sure to register new instance with <code>ObjectMapper</code>
-     * if directly calling this method.
-     * 
-     * @since 1.8
-     */
-    public abstract T withPropertyNamingStrategy(PropertyNamingStrategy strategy);
-    
-    /**
-     * Method for constructing and returning a new instance with different
-     * {@link TypeFactory}
-     * to use.
-     *<p>
-     * NOTE: make sure to register new instance with <code>ObjectMapper</code>
-     * if directly calling this method.
-     * 
-     * @since 1.8
-     */
-    public abstract T withTypeFactory(TypeFactory typeFactory);
-    
-    /**
-     * Method for constructing and returning a new instance with different
-     * {@link DateFormat}
-     * to use.
-     *<p>
-     * NOTE: make sure to register new instance with <code>ObjectMapper</code>
-     * if directly calling this method.
-     * 
-     * @since 1.8
-     */
-    public abstract T withDateFormat(DateFormat df);
-
-    /**
-     * Method for constructing and returning a new instance with different
-     * {@link HandlerInstantiator}
-     * to use.
-     *<p>
-     * NOTE: make sure to register new instance with <code>ObjectMapper</code>
-     * if directly calling this method.
-     * 
-     * @since 1.8
-     */
-    public abstract T withHandlerInstantiator(HandlerInstantiator hi);
-
-    /**
-     * Method for constructing and returning a new instance with additional
-     * {@link AnnotationIntrospector} inserted (as the highest priority one)
-     * 
-     * @since 1.9
-     */
-    public abstract T withInsertedAnnotationIntrospector(AnnotationIntrospector introspector);
-
-    /**
-     * Method for constructing and returning a new instance with additional
-     * {@link AnnotationIntrospector} appended (as the lowest priority one)
-     * 
-     * @since 1.9
-     */
-    public abstract T withAppendedAnnotationIntrospector(AnnotationIntrospector introspector);
-    
-    /*
-    /**********************************************************
-    /* Configuration: simple features
-    /**********************************************************
-     */
-
-    /**
-     * Method for checking whether given feature is enabled or not
-     */
-    public abstract boolean isEnabled(ConfigFeature f);
-    
-    /**
-     * Method for determining whether annotation processing is enabled or not
-     * (default settings are typically that it is enabled; must explicitly disable).
-     * 
-     * @return True if annotation processing is enabled; false if not
-     * 
-     * @since 1.8
-     */
-    public abstract boolean isAnnotationProcessingEnabled();
-
-    /**
-     * Accessor for determining whether it is ok to try to force override of access
-     * modifiers to be able to get or set values of non-public Methods, Fields;
-     * to invoke non-public Constructors, Methods; or to instantiate non-public
-     * Classes. By default this is enabled, but on some platforms it needs to be
-     * prevented since if this would violate security constraints and cause failures.
-     * 
-     * @return True if access modifier overriding is allowed (and may be done for
-     *   any Field, Method, Constructor or Class); false to prevent any attempts
-     *   to override.
-     * 
-     * @since 1.8
-     */
-    public abstract boolean canOverrideAccessModifiers();
-
-    /**
-     * Accessor for checking whether default settings for property handling
-     * indicate that properties should be alphabetically ordered or not.
-     * 
-     * @since 1.9
-     */
-    public abstract boolean shouldSortPropertiesAlphabetically();
-    
-    /*
-    /**********************************************************
-    /* Configuration: introspectors, mix-ins
-    /**********************************************************
-     */
-    
-    public ClassIntrospector<? extends BeanDescription> getClassIntrospector() {
-        return _base.getClassIntrospector();
-    }
-
-    /**
-     * Method for getting {@link AnnotationIntrospector} configured
-     * to introspect annotation values used for configuration.
-     *<p>
-     * Non-final since it is actually overridden by sub-classes (for now?)
-     */
-    public AnnotationIntrospector getAnnotationIntrospector() {
-        return _base.getAnnotationIntrospector();
-    }
-
-    /**
-     * Method for registering specified {@link AnnotationIntrospector} as the highest
-     * priority introspector (will be chained with existing introspector(s) which
-     * will be used as fallbacks for cases this introspector does not handle)
-     * 
-     * @param introspector Annotation introspector to register.
-     * 
-     * @since 1.7
-     * 
-     * @deprecated Since 1.9 use {@link #withInsertedAnnotationIntrospector(AnnotationIntrospector)} instead;
-     *   this method is deprecated as it changes state, preventing immutability of instances
-     */
-    @Deprecated
-    public final void insertAnnotationIntrospector(AnnotationIntrospector introspector) {
-        _base = _base.withAnnotationIntrospector(AnnotationIntrospector.Pair.create(introspector,
-                getAnnotationIntrospector()));
-    }
-
-    /**
-     * Method for registering specified {@link AnnotationIntrospector} as the lowest
-     * priority introspector, chained with existing introspector(s) and called
-     * as fallback for cases not otherwise handled.
-     * 
-     * @param introspector Annotation introspector to register.
-     * 
-     * @since 1.7
-     * 
-     * @deprecated Since 1.9 use {@link #withAppendedAnnotationIntrospector(AnnotationIntrospector)} instead;
-     *   this method is deprecated as it changes state, preventing immutability of instances
-     */
-    @Deprecated
-    public final void appendAnnotationIntrospector(AnnotationIntrospector introspector) {
-        _base = _base.withAnnotationIntrospector(AnnotationIntrospector.Pair.create(getAnnotationIntrospector(),
-                introspector));
-    }
-
-    /**
-     * Accessor for object used for determining whether specific property elements
-     * (method, constructors, fields) can be auto-detected based on
-     * their visibility (access modifiers). Can be changed to allow
-     * different minimum visibility levels for auto-detection. Note
-     * that this is the global handler; individual types (classes)
-     * can further override active checker used (using
-     * {@link JsonAutoDetect} annotation)
-     * 
-     * @since 1.5
-     */
-    public VisibilityChecker<?> getDefaultVisibilityChecker() {
-        return _base.getVisibilityChecker();
-    }
-    
-    /**
-     * @since 1.8
-     */
-    public final PropertyNamingStrategy getPropertyNamingStrategy() {
-        return _base.getPropertyNamingStrategy();
-    }
-
-    /**
-     * @since 1.8
-     */
-    public final HandlerInstantiator getHandlerInstantiator() {
-        return _base.getHandlerInstantiator();
-    }
-    
-    /*
-    /**********************************************************
-    /* Configuration: mix-in annotations
-    /**********************************************************
-     */
-    
-    /**
-     * Method to use for defining mix-in annotations to use for augmenting
-     * annotations that processable (serializable / deserializable)
-     * classes have.
-     * Mixing in is done when introspecting class annotations and properties.
-     * Map passed contains keys that are target classes (ones to augment
-     * with new annotation overrides), and values that are source classes
-     * (have annotations to use for augmentation).
-     * Annotations from source classes (and their supertypes)
-     * will <b>override</b>
-     * annotations that target classes (and their super-types) have.
-     *
-     * @since 1.2
-     */
-    public final void setMixInAnnotations(Map<Class<?>, Class<?>> sourceMixins)
-    {
-        HashMap<ClassKey,Class<?>> mixins = null;
-        if (sourceMixins != null && sourceMixins.size() > 0) {
-            mixins = new HashMap<ClassKey,Class<?>>(sourceMixins.size());
-            for (Map.Entry<Class<?>,Class<?>> en : sourceMixins.entrySet()) {
-                mixins.put(new ClassKey(en.getKey()), en.getValue());
-            }
-        }
-        _mixInAnnotationsShared = false;
-        _mixInAnnotations = mixins;
-    }
-
-    /**
-     * Method to use for adding mix-in annotations to use for augmenting
-     * specified class or interface. All annotations from
-     * <code>mixinSource</code> are taken to override annotations
-     * that <code>target</code> (or its supertypes) has.
-     *
-     * @since 1.2
-     *
-     * @param target Class (or interface) whose annotations to effectively override
-     * @param mixinSource Class (or interface) whose annotations are to
-     *   be "added" to target's annotations, overriding as necessary
-     */
-    public final void addMixInAnnotations(Class<?> target, Class<?> mixinSource)
-    {
-        if (_mixInAnnotations == null) {
-            _mixInAnnotationsShared = false;
-            _mixInAnnotations = new HashMap<ClassKey,Class<?>>();
-        } else if (_mixInAnnotationsShared) {
-            _mixInAnnotationsShared = false;
-            _mixInAnnotations = new HashMap<ClassKey,Class<?>>(_mixInAnnotations);
-        }
-        _mixInAnnotations.put(new ClassKey(target), mixinSource);
-    }
-
-    // ClassIntrospector.MixInResolver impl:
-
-    /**
-     * Method that will check if there are "mix-in" classes (with mix-in
-     * annotations) for given class
-     * 
-     * @since 1.2
-     */
-    @Override
-    public final Class<?> findMixInClassFor(Class<?> cls) {
-        return (_mixInAnnotations == null) ? null : _mixInAnnotations.get(new ClassKey(cls));
-    }
-
-    /**
-     * @since 1.8.1
-     */
-    public final int mixInCount() {
-        return (_mixInAnnotations == null) ? 0 : _mixInAnnotations.size();
-    }
-    
-    /*
-    /**********************************************************
-    /* Configuration: type and subtype handling
-    /**********************************************************
-     */
-
-    /**
-     * Method called to locate a type info handler for types that do not have
-     * one explicitly declared via annotations (or other configuration).
-     * If such default handler is configured, it is returned; otherwise
-     * null is returned.
-     * 
-     * @since 1.5
-     */
-    public final TypeResolverBuilder<?> getDefaultTyper(JavaType baseType) {
-        return _base.getTypeResolverBuilder();
-    }
-    
-    /**
-     * Accessor for object used for finding out all reachable subtypes
-     * for supertypes; needed when a logical type name is used instead
-     * of class name (or custom scheme).
-     * 
-     * @since 1.6
-     */
-    public final SubtypeResolver getSubtypeResolver() {
-        if (_subtypeResolver == null) {
-            _subtypeResolver = new StdSubtypeResolver();
-        }
-        return _subtypeResolver;
-    }
-
-    /**
-     * @since 1.8
-     */
-    public final TypeFactory getTypeFactory() {
-        return _base.getTypeFactory();
-    }
-
-    /**
-     * Helper method that will construct {@link JavaType} for given
-     * raw class.
-     * This is a simple short-cut for:
-     *<pre>
-     *    getTypeFactory().constructType(cls);
-     *</pre>
-     * 
-     * @since 1.8
-     */
-    public final JavaType constructType(Class<?> cls) {
-        return getTypeFactory().constructType(cls, (TypeBindings) null);
-    }
-
-    /**
-     * Helper method that will construct {@link JavaType} for given
-     * type reference
-     * This is a simple short-cut for:
-     *<pre>
-     *    getTypeFactory().constructType(valueTypeRef);
-     *</pre>
-     * 
-     * @since 1.9
-     */
-    public final JavaType constructType(TypeReference<?> valueTypeRef) {
-        return getTypeFactory().constructType(valueTypeRef.getType(), (TypeBindings) null);
-    }
-
-    /**
-     * @since 1.9.1
-     */
-    public JavaType constructSpecializedType(JavaType baseType, Class<?> subclass) {
-        return getTypeFactory().constructSpecializedType(baseType, subclass);
-    }
-    
-    /*
-    /**********************************************************
-    /* Configuration: other
-    /**********************************************************
-     */
-    
-    /**
-     * Method for accessing currently configured (textual) date format
-     * that will be used for reading or writing date values (in case
-     * of writing, only if textual output is configured; not if dates
-     * are to be serialized as time stamps).
-     *<p>
-     * Note that typically {@link DateFormat} instances are <b>not thread-safe</b>
-     * (at least ones provided by JDK):
-     * this means that calling code should clone format instance before
-     * using it.
-     *<p>
-     * This method is usually only called by framework itself, since there
-     * are convenience methods available via
-     * {@link DeserializationContext} and {@link SerializerProvider} that
-     * take care of cloning and thread-safe reuse.
-     */
-    public final DateFormat getDateFormat() { return _base.getDateFormat(); }
-
-    /**
-     * Accessor for getting bean description that only contains class
-     * annotations: useful if no getter/setter/creator information is needed.
-     * 
-     * @since 1.7
-     */
-    @SuppressWarnings("unchecked")
-    public <DESC extends BeanDescription> DESC introspectClassAnnotations(Class<?> cls) {
-        return (DESC) introspectClassAnnotations(constructType(cls));
-    }
-    
-    /**
-     * Accessor for getting bean description that only contains class
-     * annotations: useful if no getter/setter/creator information is needed.
-     * 
-     * @since 1.9
-     */
-    public abstract <DESC extends BeanDescription> DESC introspectClassAnnotations(JavaType type);
-
-    /**
-     * Accessor for getting bean description that only contains immediate class
-     * annotations: ones from the class, and its direct mix-in, if any, but
-     * not from super types.
-     * 
-     * @since 1.7
-     */
-    @SuppressWarnings("unchecked")
-    public <DESC extends BeanDescription> DESC introspectDirectClassAnnotations(Class<?> cls) {
-        return (DESC) introspectDirectClassAnnotations(constructType(cls));
-    }
-    /**
-     * Accessor for getting bean description that only contains immediate class
-     * annotations: ones from the class, and its direct mix-in, if any, but
-     * not from super types.
-     */
-    public abstract <DESC extends BeanDescription> DESC introspectDirectClassAnnotations(JavaType type);
-        
-    /*
-    /**********************************************************
-    /* Methods for instantiating handlers
-    /**********************************************************
-     */
-
-    /**
-     * Method that can be called to obtain an instance of <code>TypeIdResolver</code> of
-     * specified type.
-     * 
-     * @since 1.8
-     */
-    public TypeResolverBuilder<?> typeResolverBuilderInstance(Annotated annotated,
-            Class<? extends TypeResolverBuilder<?>> builderClass)
-    {
-        HandlerInstantiator hi = getHandlerInstantiator();
-        if (hi != null) {
-            TypeResolverBuilder<?> builder = hi.typeResolverBuilderInstance(this, annotated, builderClass);
-            if (builder != null) {
-                return builder;
-            }
-        }
-        return (TypeResolverBuilder<?>) ClassUtil.createInstance(builderClass, canOverrideAccessModifiers());
-    }
-
-    /**
-     * Method that can be called to obtain an instance of <code>TypeIdResolver</code> of
-     * specified type.
-     * 
-     * @since 1.8
-     */
-    public TypeIdResolver typeIdResolverInstance(Annotated annotated,
-            Class<? extends TypeIdResolver> resolverClass)
-    {
-        HandlerInstantiator hi = getHandlerInstantiator();
-        if (hi != null) {
-            TypeIdResolver builder = hi.typeIdResolverInstance(this, annotated, resolverClass);
-            if (builder != null) {
-                return builder;
-            }
-        }
-        return (TypeIdResolver) ClassUtil.createInstance(resolverClass, canOverrideAccessModifiers());
-    }
-    
-    /*
-    /**********************************************************
-    /* Deprecated methods
-    /**********************************************************
-     */
-
-    /**
-     * Method for replacing existing annotation introspector(s) with specified
-     * introspector.
-     * Since this method modifies state of configuration object directly, its use
-     * is not recommended.
-     * 
-     * @deprecated Since 1.8, use either
-     *  {@link #withAnnotationIntrospector(AnnotationIntrospector)} or
-     *  Module API instead
-     */
-    @Deprecated
-    public final void setAnnotationIntrospector(AnnotationIntrospector ai) {
-        _base = _base.withAnnotationIntrospector(ai);
-    }
-    
-    /**
-     * Method that will define specific date format to use for reading/writing
-     * Date and Calendar values.
-     * If null is passed, will use {@link StdDateFormat}.
-     * Instance is used as is, without creating a clone.
-     * Format object in use can be accessed using {@link #getDateFormat}.
-     * 
-     * @param df Date format to use, if not null; if null, the default format
-     *   will be used
-     * 
-     * @deprecated As of version 1.8, it is preferable to call method in
-     *   {@link ObjectMapper} instead; or construct new instance with
-     *   {@link #withDateFormat(DateFormat)}
-     */
-    @Deprecated
-    public void setDateFormat(DateFormat df) {
-        if (df == null) {
-            df = DEFAULT_DATE_FORMAT;
-        }
-        _base = _base.withDateFormat(df);
-    }
-
-    /*
-    /**********************************************************
-    /* Helper interface used with simple on/off features
-    /**********************************************************
-     */
-    
-    /**
-     * Interface that actual Feature enumerations used by
-     * {@link MapperConfig} implementations must implement.
-     * Necessary since enums can not be extended using normal
-     * inheritance, but can implement interfaces
-     * 
-     * @since 1.9
-     */
-    public interface ConfigFeature
-    {
-        /**
-         * Accessor for checking whether this feature is enabled by default.
-         */
-        public boolean enabledByDefault();
-
-        /**
-         * Returns bit mask for this feature instance
-         */
-        public int getMask();
-    }
-    
-    /*
-    /**********************************************************
-    /* Helper class to contain basic state needed to implement
-    /* MapperConfig.
-    /**********************************************************
-     */
-    
-    /**
-     * Immutable container class used to store simple configuration
-     * settings. Since instances are fully immutable, instances can
-     * be freely shared and used without synchronization.
-     */
-    public static class Base
-    {
-        /*
-        /**********************************************************
-        /* Configuration settings; introspection, related
-        /**********************************************************
-         */
-        
-        /**
-         * Introspector used to figure out Bean properties needed for bean serialization
-         * and deserialization. Overridable so that it is possible to change low-level
-         * details of introspection, like adding new annotation types.
-         */
-        protected final ClassIntrospector<? extends BeanDescription> _classIntrospector;
-
-        /**
-         * Introspector used for accessing annotation value based configuration.
-         */
-        protected final AnnotationIntrospector _annotationIntrospector;
-
-        /**
-         * Object used for determining whether specific property elements
-         * (method, constructors, fields) can be auto-detected based on
-         * their visibility (access modifiers). Can be changed to allow
-         * different minimum visibility levels for auto-detection. Note
-         * that this is the global handler; individual types (classes)
-         * can further override active checker used (using
-         * {@link JsonAutoDetect} annotation)
-         * 
-         * @since 1.5
-         */
-        protected final VisibilityChecker<?> _visibilityChecker;
-
-        /**
-         * Custom property naming strategy in use, if any.
-         * 
-         * @since 1.8
-         */
-        protected final PropertyNamingStrategy _propertyNamingStrategy;
-
-        /**
-         * Specific factory used for creating {@link JavaType} instances;
-         * needed to allow modules to add more custom type handling
-         * (mostly to support types of non-Java JVM languages)
-         */
-        protected final TypeFactory _typeFactory;
-
-        /*
-        /**********************************************************
-        /* Configuration settings; type resolution
-        /**********************************************************
-         */
-
-        /**
-         * Type information handler used for "untyped" values (ones declared
-         * to have type <code>Object.class</code>)
-         * 
-         * @since 1.5
-         */
-        protected final TypeResolverBuilder<?> _typeResolverBuilder;
-        
-        /*
-        /**********************************************************
-        /* Configuration settings; other
-        /**********************************************************
-         */
-        
-        /**
-         * Custom date format to use for de-serialization. If specified, will be
-         * used instead of {@link sh.calaba.org.codehaus.jackson.map.util.StdDateFormat}.
-         *<p>
-         * Note that the configured format object will be cloned once per
-         * deserialization process (first time it is needed)
-         */
-        protected final DateFormat _dateFormat;
-
-        /**
-         * Object used for creating instances of handlers (serializers, deserializers,
-         * type and type id resolvers), given class to instantiate. This is typically
-         * used to do additional configuration (with dependency injection, for example)
-         * beyond simply construction of instances; or to use alternative constructors.
-         */
-        protected final HandlerInstantiator _handlerInstantiator;
-        
-        /*
-        /**********************************************************
-        /* Construction
-        /**********************************************************
-         */
-
-        public Base(ClassIntrospector<? extends BeanDescription> ci, AnnotationIntrospector ai,
-                VisibilityChecker<?> vc, PropertyNamingStrategy pns, TypeFactory tf,
-                TypeResolverBuilder<?> typer, DateFormat dateFormat, HandlerInstantiator hi)
-        {
-            _classIntrospector = ci;
-            _annotationIntrospector = ai;
-            _visibilityChecker = vc;
-            _propertyNamingStrategy = pns;
-            _typeFactory = tf;
-            _typeResolverBuilder = typer;
-            _dateFormat = dateFormat;
-            _handlerInstantiator = hi;
-        }
-
-        /*
-        /**********************************************************
-        /* Factory methods
-        /**********************************************************
-         */
-
-        public Base withClassIntrospector(ClassIntrospector<? extends BeanDescription> ci) {
-            return new Base(ci, _annotationIntrospector, _visibilityChecker, _propertyNamingStrategy, _typeFactory,
-                    _typeResolverBuilder, _dateFormat, _handlerInstantiator);
-        }
-        
-        public Base withAnnotationIntrospector(AnnotationIntrospector ai) {
-            return new Base(_classIntrospector, ai, _visibilityChecker, _propertyNamingStrategy, _typeFactory,
-                    _typeResolverBuilder, _dateFormat, _handlerInstantiator);
-        }
-
-        public Base withInsertedAnnotationIntrospector(AnnotationIntrospector ai) {
-            return withAnnotationIntrospector(AnnotationIntrospector.Pair.create(ai, _annotationIntrospector));
-        }
-
-        public Base withAppendedAnnotationIntrospector(AnnotationIntrospector ai) {
-            return withAnnotationIntrospector(AnnotationIntrospector.Pair.create(_annotationIntrospector, ai));
-        }
-        
-        public Base withVisibilityChecker(VisibilityChecker<?> vc) {
-            return new Base(_classIntrospector, _annotationIntrospector, vc, _propertyNamingStrategy, _typeFactory,
-                    _typeResolverBuilder, _dateFormat, _handlerInstantiator);
-        }
-
-        public Base withVisibility(JsonMethod forMethod, JsonAutoDetect.Visibility visibility) {
-            return new Base(_classIntrospector, _annotationIntrospector,
-                    _visibilityChecker.withVisibility(forMethod, visibility),
-                    _propertyNamingStrategy, _typeFactory,
-                    _typeResolverBuilder, _dateFormat, _handlerInstantiator);
-        }
-        
-        public Base withPropertyNamingStrategy(PropertyNamingStrategy pns) {
-            return new Base(_classIntrospector, _annotationIntrospector, _visibilityChecker, pns, _typeFactory,
-                    _typeResolverBuilder, _dateFormat, _handlerInstantiator);
-        }
-
-        public Base withTypeFactory(TypeFactory tf) {
-            return new Base(_classIntrospector, _annotationIntrospector, _visibilityChecker, _propertyNamingStrategy, tf,
-                    _typeResolverBuilder, _dateFormat, _handlerInstantiator);
-        }
-
-        public Base withTypeResolverBuilder(TypeResolverBuilder<?> typer) {
-            return new Base(_classIntrospector, _annotationIntrospector, _visibilityChecker, _propertyNamingStrategy, _typeFactory,
-                    typer, _dateFormat, _handlerInstantiator);
-        }
-        
-        public Base withDateFormat(DateFormat df) {
-            return new Base(_classIntrospector, _annotationIntrospector, _visibilityChecker, _propertyNamingStrategy, _typeFactory,
-                    _typeResolverBuilder, df, _handlerInstantiator);
-        }
-
-        public Base withHandlerInstantiator(HandlerInstantiator hi) {
-            return new Base(_classIntrospector, _annotationIntrospector, _visibilityChecker, _propertyNamingStrategy, _typeFactory,
-                    _typeResolverBuilder, _dateFormat, hi);
-        }
-        
-        /*
-        /**********************************************************
-        /* API
-        /**********************************************************
-         */
-
-        public ClassIntrospector<? extends BeanDescription> getClassIntrospector() {
-            return _classIntrospector;
-        }
-        
-        public AnnotationIntrospector getAnnotationIntrospector() {
-            return _annotationIntrospector;
-        }
-
-
-        public VisibilityChecker<?> getVisibilityChecker() {
-            return _visibilityChecker;
-        }
-
-        public PropertyNamingStrategy getPropertyNamingStrategy() {
-            return _propertyNamingStrategy;
-        }
-
-        public TypeFactory getTypeFactory() {
-            return _typeFactory;
-        }
-
-        public TypeResolverBuilder<?> getTypeResolverBuilder() {
-            return _typeResolverBuilder;
-        }
-        
-        public DateFormat getDateFormat() {
-            return _dateFormat;
-        }
-
-        public HandlerInstantiator getHandlerInstantiator() {
-            return _handlerInstantiator;
-        }
-    }
-
-    /*
-    /**********************************************************
-    /* Basic extension; added to avoid having to change generic
-    /* signature of MapperConfig
-    /* 
-    /* NOTE: May be merge in MapperConfig for 2.0, depending
-    /* on how much we value backwards compatibility
-    /**********************************************************
-     */
-
-    static abstract class Impl<CFG extends MapperConfig.ConfigFeature,
-        T extends Impl<CFG,T>>
-        extends MapperConfig<T>
-    {
-        /**
-         *<p>
-         * Note: moved to base class in 1.9; was stored by sub-class earlier
-         */
-        protected int _featureFlags;
-        
-        /*
-        /**********************************************************
-        /* Construction
-        /**********************************************************
-         */
-        
-        protected Impl(ClassIntrospector<? extends BeanDescription> ci, AnnotationIntrospector ai,
-                VisibilityChecker<?> vc, SubtypeResolver str, PropertyNamingStrategy pns, TypeFactory tf,
-                HandlerInstantiator hi,
-                int defaultFeatures)
-        {
-            super(ci, ai, vc, str, pns, tf, hi);
-            _featureFlags = defaultFeatures;
-        }
-
-        protected Impl(Impl<CFG,T> src) {
-            super(src);
-            _featureFlags = src._featureFlags;
-        }
-
-        protected Impl(Impl<CFG,T> src, int features) {
-            super(src);
-            _featureFlags = features;
-        }
-        
-        /**
-         * @since 1.8
-         */
-        protected Impl(Impl<CFG,T> src, MapperConfig.Base base, SubtypeResolver str)
-        {
-            super(src, base, str);
-            _featureFlags = src._featureFlags;
-        }
-        
-        /**
-         * Method that calculates bit set (flags) of all features that
-         * are enabled by default.
-         */
-        static <F extends Enum<F> & MapperConfig.ConfigFeature> int collectFeatureDefaults(Class<F> enumClass)
-        {
-            int flags = 0;
-            for (F value : enumClass.getEnumConstants()) {
-                if (value.enabledByDefault()) {
-                    flags |= value.getMask();
-                }
-            }
-            return flags;
-        }
-        
-        /*
-        /**********************************************************
-        /* Additional fluent-factory methods
-        /**********************************************************
-         */
-        
-        /**
-         * Fluent factory method that will construct and return a new configuration
-         * object instance with specified features enabled.
-         * 
-         * @since 1.9
-         */
-        public abstract T with(CFG... features);
-
-        /**
-         * Fluent factory method that will construct and return a new configuration
-         * object instance with specified features disabled.
-         * 
-         * @since 1.9
-         */
-        public abstract T without(CFG... features);
-        
-        /*
-        /**********************************************************
-        /* Configuration: simple features
-        /**********************************************************
-         */
-        
-        /* NOTE: this method was added in 1.9, but should be
-         * removed from 2.0 -- overloads do not work nicely with
-         * enums, so we better not try 
-         *<p>
-         * Also note that we can NOT use type variable CFG here, because
-         * non-generic base class had to use base type.
-         * 
-         * @Deprecated 
-         */
-        @Override
-        public boolean isEnabled(MapperConfig.ConfigFeature f) {
-            return (_featureFlags & f.getMask()) != 0;
-        }
-        
-        /*
-        /**********************************************************
-        /* Configuration: deprecated methods
-        /**********************************************************
-         */
-        
-        /**
-         * Method for enabling specified feature.
-         * 
-         * @deprecated Since 1.9, it is preferable to use {@link #with} instead;
-         *    this method is deprecated as it modifies current instance instead of
-         *    creating a new one (as the goal is to make this class immutable)
-         */
-        @Deprecated
-        public void enable(CFG f) {
-            _featureFlags |= f.getMask();
-        }
-
-        /**
-         * Method for disabling specified feature.
-         * 
-         * @deprecated Since 1.9, it is preferable to use {@link #without} instead;
-         *    this method is deprecated as it modifies current instance instead of
-         *    creating a new one (as the goal is to make this class immutable)
-         */
-        @Deprecated
-        public void disable(CFG f) {
-            _featureFlags &= ~f.getMask();
-        }
-
-        /**
-         * Method for enabling or disabling specified feature.
-         * 
-         * @deprecated Since 1.9, it is preferable to use {@link #with} and
-         * {@link #without} methods instead;
-         *    this method is deprecated as it modifies current instance instead of
-         *    creating a new one (as the goal is to make this class immutable)
-         */
-        @SuppressWarnings("deprecation")
-        @Deprecated
-        public void set(CFG f, boolean state)
-        {
-            if (state) {
-                enable(f);
-            } else {
-                disable(f);
-            }
-        }
-    }
-}