calabash-android 0.4.7.pre6 → 0.4.7.pre7

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

@@ -0,0 +1,34 @@
+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

@@ -0,0 +1,22 @@
+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

@@ -0,0 +1,138 @@
+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

@@ -0,0 +1,31 @@
+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

@@ -0,0 +1,21 @@
+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

@@ -0,0 +1,1154 @@
+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);
+            }
+        }
+    }
+}