calabash-android 0.0.1

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

@@ -0,0 +1,258 @@
+package sh.calaba.org.codehaus.jackson.map;
+
+import sh.calaba.org.codehaus.jackson.map.introspect.AnnotatedField;
+import sh.calaba.org.codehaus.jackson.map.introspect.AnnotatedMethod;
+import sh.calaba.org.codehaus.jackson.map.introspect.AnnotatedParameter;
+
+/**
+ * Class that defines how names of JSON properties ("external names")
+ * are derived from names of POJO methods and fields ("internal names"),
+ * in cases where they are not
+ * auto-detected and no explicit annotations exist for naming.
+ * Methods are passed information about POJO member for which name is needed,
+ * as well as default name that would be used if no custom strategy was used.
+ *<p>
+ * Default implementation returns suggested ("default") name unmodified.
+ *<p>
+ * Note that the strategy is guaranteed to be called once per logical property
+ * (which may be represented by multiple members; such as pair of a getter and
+ * a setter), but may be called for each: implementations should not count on
+ * exact number of times, and should work for any member that represent a
+ * property.
+ *<p>
+ * In absence of a registered custom strategy, default Java property naming strategy
+ * is used, which leaves field names as is, and removes set/get/is prefix
+ * from methods (as well as lower-cases initial sequence of capitalized
+ * characters).
+ * 
+ * @since 1.8
+ */
+public abstract class PropertyNamingStrategy
+{
+    /*
+    /**********************************************************
+    /* API
+    /**********************************************************
+     */
+
+    /**
+     * Method called to find external name (name used in JSON) for given logical
+     * POJO property,
+     * as defined by given field.
+     * 
+     * @param config Configuration in used: either <code>SerializationConfig</code>
+     *   or <code>DeserializationConfig</code>, depending on whether method is called
+     *   during serialization or deserialization
+     * @param field Field used to access property
+     * @param defaultName Default name that would be used for property in absence of custom strategy
+     * 
+     * @return Logical name to use for property that the field represents
+     */
+    public String nameForField(MapperConfig<?> config, AnnotatedField field,
+            String defaultName)
+    {
+        return defaultName;
+    }
+
+    /**
+     * Method called to find external name (name used in JSON) for given logical
+     * POJO property,
+     * as defined by given getter method; typically called when building a serializer.
+     * (but not always -- when using "getter-as-setter", may be called during
+     * deserialization)
+     * 
+     * @param config Configuration in used: either <code>SerializationConfig</code>
+     *   or <code>DeserializationConfig</code>, depending on whether method is called
+     *   during serialization or deserialization
+     * @param method Method used to access property.
+     * @param defaultName Default name that would be used for property in absence of custom strategy
+     * 
+     * @return Logical name to use for property that the method represents
+     */
+    public String nameForGetterMethod(MapperConfig<?> config, AnnotatedMethod method,
+            String defaultName)
+    {
+        return defaultName;
+    }
+
+    /**
+     * Method called to find external name (name used in JSON) for given logical
+     * POJO property,
+     * as defined by given setter method; typically called when building a deserializer
+     * (but not necessarily only then).
+     * 
+     * @param config Configuration in used: either <code>SerializationConfig</code>
+     *   or <code>DeserializationConfig</code>, depending on whether method is called
+     *   during serialization or deserialization
+     * @param method Method used to access property.
+     * @param defaultName Default name that would be used for property in absence of custom strategy
+     * 
+     * @return Logical name to use for property that the method represents
+     */
+    public String nameForSetterMethod(MapperConfig<?> config, AnnotatedMethod method,
+            String defaultName)
+    {
+        return defaultName;
+    }
+
+    /**
+     * Method called to find external name (name used in JSON) for given logical
+     * POJO property,
+     * as defined by given constructor parameter; typically called when building a deserializer
+     * (but not necessarily only then).
+     * 
+     * @param config Configuration in used: either <code>SerializationConfig</code>
+     *   or <code>DeserializationConfig</code>, depending on whether method is called
+     *   during serialization or deserialization
+     * @param ctorParam Constructor parameter used to pass property.
+     * @param defaultName Default name that would be used for property in absence of custom strategy
+     * @since 1.9
+     */
+    public String nameForConstructorParameter(MapperConfig<?> config, AnnotatedParameter ctorParam,
+            String defaultName)
+    {
+        return defaultName;
+    }
+
+    /*
+    /**********************************************************
+    /* Standard implementations 
+    /**********************************************************
+     */
+    
+    /**
+     * @since 1.9
+     */
+    public static abstract class PropertyNamingStrategyBase extends PropertyNamingStrategy
+    {
+        @Override
+        public String nameForField(MapperConfig<?> config, AnnotatedField field, String defaultName)
+        {
+            return translate(defaultName);
+        }
+
+        @Override
+        public String nameForGetterMethod(MapperConfig<?> config, AnnotatedMethod method, String defaultName)
+        {
+            return translate(defaultName);
+        }
+
+        @Override
+        public String nameForSetterMethod(MapperConfig<?> config, AnnotatedMethod method, String defaultName)
+        {
+            return translate(defaultName);
+        }
+
+        @Override
+        public String nameForConstructorParameter(MapperConfig<?> config, AnnotatedParameter ctorParam,
+                String defaultName)
+        {
+            return translate(defaultName);
+        }
+        
+        public abstract String translate(String propertyName);
+    }
+        
+    
+    /*
+    /**********************************************************
+    /* Standard implementations 
+    /**********************************************************
+     */
+
+    /**
+     * See {@link LowerCaseWithUnderscoresStrategy} for details.
+     * 
+     * @since 1.9
+     */
+    public static final PropertyNamingStrategy CAMEL_CASE_TO_LOWER_CASE_WITH_UNDERSCORES =
+        new LowerCaseWithUnderscoresStrategy();
+    
+    /**
+     * A {@link PropertyNamingStrategy} that translates typical camel case Java 
+     * property names to lower case JSON element names, separated by 
+     * underscores.  This implementation is somewhat lenient, in that it 
+     * provides some additional translations beyond strictly translating from 
+     * camel case only.  In particular, the following translations are applied 
+     * by this PropertyNamingStrategy.
+     * 
+     * <ul><li>Every upper case letter in the Java property name is translated 
+     * into two characters, an underscore and the lower case equivalent of the 
+     * target character, with three exceptions.
+     * <ol><li>For contiguous sequences of upper case letters, characters after
+     * the first character are replaced only by their lower case equivalent, 
+     * and are not preceded by an underscore.
+     * <ul><li>This provides for reasonable translations of upper case acronyms, 
+     * e.g., &quot;theWWW&quot; is translated to &quot;the_www&quot;.</li></ul></li>
+     * <li>An upper case character in the first position of the Java property 
+     * name is not preceded by an underscore character, and is translated only 
+     * to its lower case equivalent.
+     * <ul><li>For example, &quot;Results&quot; is translated to &quot;results&quot;, 
+     * and not to &quot;_results&quot;.</li></ul></li>
+     * <li>An upper case character in the Java property name that is already 
+     * preceded by an underscore character is translated only to its lower case 
+     * equivalent, and is not preceded by an additional underscore.
+     * <ul><li>For example, &quot;user_Name&quot; is translated to 
+     * &quot;user_name&quot;, and not to &quot;user__name&quot; (with two 
+     * underscore characters).</li></ul></li></ol></li>
+     * <li>If the Java property name starts with an underscore, then that 
+     * underscore is not included in the translated name, unless the Java 
+     * property name is just one character in length, i.e., it is the 
+     * underscore character.  This applies only to the first character of the 
+     * Java property name.</li></ul>
+     * 
+     * These rules result in the following additional example translations from 
+     * Java property names to JSON element names.
+     * <ul><li>&quot;userName&quot; is translated to &quot;user_name&quot;</li>
+     * <li>&quot;UserName&quot; is translated to &quot;user_name&quot;</li>
+     * <li>&quot;USER_NAME&quot; is translated to &quot;user_name&quot;</li>
+     * <li>&quot;user_name&quot; is translated to &quot;user_name&quot; (unchanged)</li>
+     * <li>&quot;user&quot; is translated to &quot;user&quot; (unchanged)</li>
+     * <li>&quot;User&quot; is translated to &quot;user&quot;</li>
+     * <li>&quot;USER&quot; is translated to &quot;user&quot;</li>
+     * <li>&quot;_user&quot; is translated to &quot;user&quot;</li>
+     * <li>&quot;_User&quot; is translated to &quot;user&quot;</li>
+     * <li>&quot;__user&quot; is translated to &quot;_user&quot; 
+     * (the first of two underscores was removed)</li>
+     * <li>&quot;user__name&quot; is translated to &quot;user__name&quot;
+     * (unchanged, with two underscores)</li></ul>
+     * 
+     * @since 1.9
+     */
+    public static class LowerCaseWithUnderscoresStrategy extends PropertyNamingStrategyBase
+    {
+        @Override
+        public String translate(String input)
+        {
+            if (input == null) return input; // garbage in, garbage out
+            int length = input.length();
+            StringBuilder result = new StringBuilder(length * 2);
+            int resultLength = 0;
+            boolean wasPrevTranslated = false;
+            for (int i = 0; i < length; i++)
+            {
+                char c = input.charAt(i);
+                if (i > 0 || c != '_') // skip first starting underscore
+                {
+                    if (Character.isUpperCase(c))
+                    {
+                        if (!wasPrevTranslated && resultLength > 0 && result.charAt(resultLength - 1) != '_')
+                        {
+                            result.append('_');
+                            resultLength++;
+                        }
+                        c = Character.toLowerCase(c);
+                        wasPrevTranslated = true;
+                    }
+                    else
+                    {
+                        wasPrevTranslated = false;
+                    }
+                    result.append(c);
+                    resultLength++;
+                }
+            }
+            return resultLength > 0 ? result.toString() : input;
+        }
+    }
+}

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

@@ -0,0 +1,23 @@
+package sh.calaba.org.codehaus.jackson.map;
+
+/**
+ * Interface used to indicate deserializers that want to do post-processing
+ * after construction and being added to {@link DeserializerProvider},
+ * but before being used. This is typically used to resolve references
+ * to other contained types; for example, bean deserializers use this
+ * to eagerly find deserializers for contained field types.
+ */
+public interface ResolvableDeserializer
+{
+    /**
+     * Method called after {@link DeserializerProvider} has registered
+     * the deserializer, but before it has returned it to the caller.
+     * Called object can then resolve its dependencies to other types,
+     * including self-references (direct or indirect).
+     *
+     * @param provider Provider that has constructed deserializer this method
+     *   is called on.
+     */
+    public abstract void resolve(DeserializationConfig config, DeserializerProvider provider)
+        throws JsonMappingException;
+}

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

@@ -0,0 +1,23 @@
+package sh.calaba.org.codehaus.jackson.map;
+
+/**
+ * Interface used to indicate serializers that want to do post-processing
+ * after construction and being added to {@link SerializerProvider},
+ * but before being used. This is typically used to resolve references
+ * to other contained types; for example, bean serializers use this
+ * to eagerly find serializers for contained field types.
+ */
+public interface ResolvableSerializer
+{
+    /**
+     * Method called after {@link SerializerProvider} has registered
+     * the serializer, but before it has returned it to the caller.
+     * Called object can then resolve its dependencies to other types,
+     * including self-references (direct or indirect).
+     *
+     * @param provider Provider that has constructed serializer this method
+     *   is called on.
+     */
+    public abstract void resolve(SerializerProvider provider)
+        throws JsonMappingException;
+}

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

@@ -0,0 +1,21 @@
+package sh.calaba.org.codehaus.jackson.map;
+
+/**
+ * Wrapper used when interface does not allow throwing a checked
+ * {@link JsonMappingException}
+ */
+@SuppressWarnings("serial")
+public class RuntimeJsonMappingException extends RuntimeException
+{
+    public RuntimeJsonMappingException(JsonMappingException cause) {
+        super(cause);
+    }
+
+    public RuntimeJsonMappingException(String message) {
+        super(message);
+    }
+
+    public RuntimeJsonMappingException(String message, JsonMappingException cause) {
+        super(message, cause);
+    }
+}

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

@@ -0,0 +1,1041 @@
+package sh.calaba.org.codehaus.jackson.map;
+
+import java.text.DateFormat;
+import java.util.HashMap;
+
+import sh.calaba.org.codehaus.jackson.annotate.JsonAutoDetect;
+import sh.calaba.org.codehaus.jackson.annotate.JsonMethod;
+import sh.calaba.org.codehaus.jackson.annotate.JsonWriteNullProperties;
+import sh.calaba.org.codehaus.jackson.annotate.JsonAutoDetect.Visibility;
+import sh.calaba.org.codehaus.jackson.map.annotate.JsonSerialize;
+import sh.calaba.org.codehaus.jackson.map.annotate.JsonSerialize.Inclusion;
+import sh.calaba.org.codehaus.jackson.map.introspect.Annotated;
+import sh.calaba.org.codehaus.jackson.map.introspect.AnnotatedClass;
+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.TypeResolverBuilder;
+import sh.calaba.org.codehaus.jackson.map.ser.FilterProvider;
+import sh.calaba.org.codehaus.jackson.map.type.ClassKey;
+import sh.calaba.org.codehaus.jackson.map.type.TypeFactory;
+import sh.calaba.org.codehaus.jackson.map.util.ClassUtil;
+import sh.calaba.org.codehaus.jackson.type.JavaType;
+
+/**
+ * Object that contains baseline configuration for serialization
+ * process. An instance is owned by {@link ObjectMapper}, which makes
+ * a copy that is passed during serialization process to
+ * {@link SerializerProvider} and {@link SerializerFactory}.
+ *<p>
+ * Note: although configuration settings can be changed at any time
+ * (for factories and instances), they are not guaranteed to have
+ * effect if called after constructing relevant mapper or serializer
+ * instance. This because some objects may be configured, constructed and
+ * cached first time they are needed.
+ *<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")
+ */
+public class SerializationConfig
+    extends MapperConfig.Impl<SerializationConfig.Feature, SerializationConfig>
+{
+    /**
+     * Enumeration that defines togglable features that guide
+     * the serialization feature.
+     */
+    public enum Feature implements MapperConfig.ConfigFeature
+    {
+        /*
+        /******************************************************
+        /*  Introspection features
+        /******************************************************
+         */
+        
+        /**
+         * Feature that determines whether annotation introspection
+         * is used for configuration; if enabled, configured
+         * {@link AnnotationIntrospector} will be used: if disabled,
+         * no annotations are considered.
+         *<P>
+         * Feature is enabled by default.
+         *
+         * @since 1.2
+         */
+        USE_ANNOTATIONS(true),
+
+        /**
+         * Feature that determines whether regualr "getter" methods are
+         * automatically detected based on standard Bean naming convention
+         * or not. If yes, then all public zero-argument methods that
+         * start with prefix "get" 
+         * are considered as getters.
+         * If disabled, only methods explicitly  annotated are considered getters.
+         *<p>
+         * Note that since version 1.3, this does <b>NOT</b> include
+         * "is getters" (see {@link #AUTO_DETECT_IS_GETTERS} for details)
+         *<p>
+         * Note that this feature has lower precedence than per-class
+         * annotations, and is only used if there isn't more granular
+         * configuration available.
+         *<P>
+         * Feature is enabled by default.
+         */
+        AUTO_DETECT_GETTERS(true),
+
+        /**
+         * Feature that determines whether "is getter" methods are
+         * automatically detected based on standard Bean naming convention
+         * or not. If yes, then all public zero-argument methods that
+         * start with prefix "is", and whose return type is boolean
+         * are considered as "is getters".
+         * If disabled, only methods explicitly annotated are considered getters.
+         *<p>
+         * Note that this feature has lower precedence than per-class
+         * annotations, and is only used if there isn't more granular
+         * configuration available.
+         *<P>
+         * Feature is enabled by default.
+         */
+        AUTO_DETECT_IS_GETTERS(true),
+
+        /**
+         * Feature that determines whether non-static fields are recognized as
+         * properties.
+         * If yes, then all public member fields
+         * are considered as properties. If disabled, only fields explicitly
+         * annotated are considered property fields.
+         *<p>
+         * Note that this feature has lower precedence than per-class
+         * annotations, and is only used if there isn't more granular
+         * configuration available.
+         *<p>
+         * Feature is enabled by default.
+         *
+         * @since 1.1
+         */
+         AUTO_DETECT_FIELDS(true),
+
+        /**
+         * Feature that determines whether method and field access
+         * modifier settings can be overridden when accessing
+         * properties. If enabled, method
+         * {@link java.lang.reflect.AccessibleObject#setAccessible}
+         * may be called to enable access to otherwise unaccessible
+         * objects.
+         *<p>
+         * Feature is enabled by default.
+         */
+        CAN_OVERRIDE_ACCESS_MODIFIERS(true),
+
+        /**
+         * Feature that determines whether getters (getter methods)
+         * can be auto-detected if there is no matching mutator (setter,
+         * constructor parameter or field) or not: if set to true,
+         * only getters that match a mutator are auto-discovered; if
+         * false, all auto-detectable getters can be discovered.
+         *<p>
+         * Feature is disabled by default for backwards compatibility
+         * reasons.
+         * 
+         * @since 1.9
+         */
+        REQUIRE_SETTERS_FOR_GETTERS(false),
+        
+        /*
+        /******************************************************
+        /* Generic output features
+        /******************************************************
+         */
+
+        /**
+         * Feature that determines the default settings of whether Bean
+         * properties with null values are to be written out.
+         *<p>
+         * Feature is enabled by default (null properties written).
+         *<p>
+         * Note too that there is annotation
+         * {@link sh.calaba.org.codehaus.jackson.annotate.JsonWriteNullProperties}
+         * that can be used for more granular control (annotates bean
+         * classes or individual property access methods).
+         *
+         * @deprecated As of 1.1, use {@link SerializationConfig#setSerializationInclusion}
+         *    instead
+         */
+        @Deprecated
+        WRITE_NULL_PROPERTIES(true),
+
+        /**
+         * Feature that determines whether the type detection for
+         * serialization should be using actual dynamic runtime type,
+         * or declared static type.
+         * Default value is false, to use dynamic runtime type.
+         *<p>
+         * This global default value can be overridden at class, method
+         * or field level by using {@link JsonSerialize#typing} annotation
+         * property
+         */
+        USE_STATIC_TYPING(false),
+
+        /**
+         * Feature that determines whether properties that have no view
+         * annotations are included in JSON serialization views (see
+         * {@link sh.calaba.org.codehaus.jackson.map.annotate.JsonView} for more
+         * details on JSON Views).
+         * If enabled, non-annotated properties will be included;
+         * when disabled, they will be excluded. So this feature
+         * changes between "opt-in" (feature disabled) and
+         * "opt-out" (feature enabled) modes.
+         *<p>
+         * Default value is enabled, meaning that non-annotated
+         * properties are included in all views if there is no
+         * {@link sh.calaba.org.codehaus.jackson.map.annotate.JsonView} annotation.
+         * 
+         * @since 1.5
+         */
+        DEFAULT_VIEW_INCLUSION(true),
+        
+        /**
+         * Feature that can be enabled to make root value (usually JSON
+         * Object but can be any type) wrapped within a single property
+         * JSON object, where key as the "root name", as determined by
+         * annotation introspector (esp. for JAXB that uses
+         * <code>@XmlRootElement.name</code>) or fallback (non-qualified
+         * class name).
+         * Feature is mostly intended for JAXB compatibility.
+         *<p>
+         * Default setting is false, meaning root value is not wrapped.
+         *
+         * @since 1.7
+         */
+        WRAP_ROOT_VALUE(false),
+
+        /**
+         * Feature that allows enabling (or disabling) indentation
+         * for the underlying generator, using the default pretty
+         * printer (see
+         * {@link sh.calaba.org.codehaus.jackson.JsonGenerator#useDefaultPrettyPrinter}
+         * for details).
+         *<p>
+         * Note that this only affects cases where
+         * {@link sh.calaba.org.codehaus.jackson.JsonGenerator}
+         * is constructed implicitly by ObjectMapper: if explicit
+         * generator is passed, its configuration is not changed.
+         *<p>
+         * Also note that if you want to configure details of indentation,
+         * you need to directly configure the generator: there is a
+         * method to use any <code>PrettyPrinter</code> instance.
+         * This feature will only allow using the default implementation.
+         */
+        INDENT_OUTPUT(false),
+
+        /**
+         * Feature that defines default property serialization order used
+         * for POJO fields (note: does <b>not</b> apply to {@link java.util.Map}
+         * serialization!):
+         * if enabled, default ordering is alphabetic (similar to
+         * how {@link sh.calaba.org.codehaus.jackson.annotate.JsonPropertyOrder#alphabetic()}
+         * works); if disabled, order is unspecified (based on what JDK gives
+         * us, which may be declaration order, but not guaranteed).
+         *<p>
+         * Note that this is just the default behavior, and can be overridden by
+         * explicit overrides in classes.
+         *
+         * @since 1.8
+         */
+        SORT_PROPERTIES_ALPHABETICALLY(false),
+        
+        /*
+        /******************************************************
+        /*  Error handling features
+        /******************************************************
+         */
+        
+        /**
+         * Feature that determines what happens when no accessors are
+         * found for a type (and there are no annotations to indicate
+         * it is meant to be serialized). If enabled (default), an
+         * exception is thrown to indicate these as non-serializable
+         * types; if disabled, they are serialized as empty Objects,
+         * i.e. without any properties.
+         *<p>
+         * Note that empty types that this feature has only effect on
+         * those "empty" beans that do not have any recognized annotations
+         * (like <code>@JsonSerialize</code>): ones that do have annotations
+         * do not result in an exception being thrown.
+         *
+         * @since 1.4
+         */
+        FAIL_ON_EMPTY_BEANS(true),
+
+        /**
+         * Feature that determines whether Jackson code should catch
+         * and wrap {@link Exception}s (but never {@link Error}s!)
+         * to add additional information about
+         * location (within input) of problem or not. If enabled,
+         * most exceptions will be caught and re-thrown (exception
+         * specifically being that {@link java.io.IOException}s may be passed
+         * as is, since they are declared as throwable); this can be
+         * convenient both in that all exceptions will be checked and
+         * declared, and so there is more contextual information.
+         * However, sometimes calling application may just want "raw"
+         * unchecked exceptions passed as is.
+         *<p>
+         * Feature is enabled by default, and is similar in behavior
+         * to default prior to 1.7.
+         * 
+         * @since 1.7
+         */
+        WRAP_EXCEPTIONS(true),
+
+        /*
+        /******************************************************
+        /* Output life cycle features
+        /******************************************************
+         */
+        
+         /**
+          * Feature that determines whether <code>close</code> method of
+          * serialized <b>root level</b> objects (ones for which <code>ObjectMapper</code>'s
+          * writeValue() (or equivalent) method is called)
+          * that implement {@link java.io.Closeable} 
+          * is called after serialization or not. If enabled, <b>close()</b> will
+          * be called after serialization completes (whether succesfully, or
+          * due to an error manifested by an exception being thrown). You can
+          * think of this as sort of "finally" processing.
+          *<p>
+          * NOTE: only affects behavior with <b>root</b> objects, and not other
+          * objects reachable from the root object. Put another way, only one
+          * call will be made for each 'writeValue' call.
+          * 
+          * @since 1.6 (see [JACKSON-282 for details])
+          */
+        CLOSE_CLOSEABLE(false),
+
+        /**
+         * Feature that determines whether <code>JsonGenerator.flush()</code> is
+         * called after <code>writeValue()</code> method <b>that takes JsonGenerator
+         * as an argument</b> completes (i.e. does NOT affect methods
+         * that use other destinations); same for methods in {@link ObjectWriter}.
+         * This usually makes sense; but there are cases where flushing
+         * should not be forced: for example when underlying stream is
+         * compressing and flush() causes compression state to be flushed
+         * (which occurs with some compression codecs).
+          * 
+          * @since 1.6 (see [JACKSON-401 for details])
+         */
+        FLUSH_AFTER_WRITE_VALUE(true),
+         
+        /*
+        /******************************************************
+        /* Data type - specific serialization configuration
+        /******************************************************
+         */
+
+        /**
+         * Feature that determines whether {@link java.util.Date} values
+         * (and Date-based things like {@link java.util.Calendar}s) are to be
+         * serialized as numeric timestamps (true; the default),
+         * or as something else (usually textual representation).
+         * If textual representation is used, the actual format is
+         * one returned by a call to {@link #getDateFormat}.
+         *<p>
+         * Note: whether this feature affects handling of other date-related
+         * types depend on handlers of those types, although ideally they
+         * should use this feature
+         *<p>
+         * Note: whether {@link java.util.Map} keys are serialized as Strings
+         * or not is controlled using {@link #WRITE_DATE_KEYS_AS_TIMESTAMPS}.
+         */
+        WRITE_DATES_AS_TIMESTAMPS(true),
+
+        /**
+         * Feature that determines whether {@link java.util.Date}s
+         * (and sub-types) used as {@link java.util.Map} keys are serialized
+         * as timestamps or not (if not, will be serialized as textual
+         * values).
+         *<p>
+         * Default value is 'false', meaning that Date-valued Map keys are serialized
+         * as textual (ISO-8601) values.
+         * 
+         * @since 1.9
+         */
+        WRITE_DATE_KEYS_AS_TIMESTAMPS(false),
+
+        /**
+         * Feature that determines how type <code>char[]</code> is serialized:
+         * when enabled, will be serialized as an explict JSON array (with
+         * single-character Strings as values); when disabled, defaults to
+         * serializing them as Strings (which is more compact).
+         * 
+         * @since 1.6 (see [JACKSON-289 for details])
+         */
+        WRITE_CHAR_ARRAYS_AS_JSON_ARRAYS(false),
+
+        /**
+         * Feature that determines standard serialization mechanism used for
+         * Enum values: if enabled, return value of <code>Enum.toString()</code>
+         * is used; if disabled, return value of <code>Enum.name()</code> is used.
+         * Since pre-1.6 method was to use Enum name, this is the default.
+         *<p>
+         * Note: this feature should usually have same value
+         * as {@link DeserializationConfig.Feature#READ_ENUMS_USING_TO_STRING}.
+         *<p>
+         * For further details, check out [JACKSON-212]
+         * 
+         * @since 1.6
+         */
+        WRITE_ENUMS_USING_TO_STRING(false),
+
+        /**
+         * Feature that determines whethere Java Enum values are serialized
+         * as numbers (true), or textual values (false). If textual values are
+         * used, other settings are also considered.
+         * If this feature is enabled,
+         *  return value of <code>Enum.ordinal()</code>
+         * (an integer) will be used as the serialization.
+         *<p>
+         * Note that this feature has precedence over {@link #WRITE_ENUMS_USING_TO_STRING},
+         * which is only considered if this feature is set to false.
+         * 
+         * @since 1.9
+         */
+        WRITE_ENUMS_USING_INDEX(false),
+        
+        /**
+         * Feature that determines whether Map entries with null values are
+         * to be serialized (true) or not (false).
+         *<p>
+         * For further details, check out [JACKSON-314]
+         * 
+         * @since 1.6
+         */
+        WRITE_NULL_MAP_VALUES(true),
+
+        /**
+         * Feature that determines whether Container properties (POJO properties
+         * with declared value of Collection or array; i.e. things that produce JSON
+         * arrays) that are empty (have no elements)
+         * will be serialized as empty JSON arrays (true), or suppressed from output (false).
+         *<p>
+         * Note that this does not change behavior of {@link java.util.Map}s, or
+         * "Collection-like" types.
+         * 
+         * @since 1.9
+         */
+        WRITE_EMPTY_JSON_ARRAYS(true)
+        
+            ;
+
+        final boolean _defaultState;
+        
+        private Feature(boolean defaultState) {
+            _defaultState = defaultState;
+        }
+
+        @Override
+        public boolean enabledByDefault() { return _defaultState; }
+    
+        @Override
+        public int getMask() { return (1 << ordinal()); }
+    }
+
+    /*
+    /**********************************************************
+    /* Configuration settings
+    /**********************************************************
+     */
+
+    /**
+     * Which Bean/Map properties are to be included in serialization?
+     * Default settings is to include all regardless of value; can be
+     * changed to only include non-null properties, or properties
+     * with non-default values.
+     *<p>
+     * Defaults to null for backwards compatibility; if left as null,
+     * will check
+     * deprecated {@link Feature#WRITE_NULL_PROPERTIES}
+     * to choose between {@link Inclusion#ALWAYS}
+     * and {@link Inclusion#NON_NULL}.
+     */
+    protected JsonSerialize.Inclusion _serializationInclusion = null;
+
+    /**
+     * View to use for filtering out properties to serialize.
+     * Null if none (will also be assigned null if <code>Object.class</code>
+     * is defined), meaning that all properties are to be included.
+     */
+    protected Class<?> _serializationView;
+    
+    /**
+     * Object used for resolving filter ids to filter instances.
+     * Non-null if explicitly defined; null by default.
+     * 
+     * @since 1.7
+     */
+    protected FilterProvider _filterProvider;
+    
+    /*
+    /**********************************************************
+    /* Life-cycle, constructors
+    /**********************************************************
+     */
+
+    /**
+     * Constructor used by ObjectMapper to create default configuration object instance.
+     */
+    public SerializationConfig(ClassIntrospector<? extends BeanDescription> intr,
+            AnnotationIntrospector annIntr, VisibilityChecker<?> vc,
+            SubtypeResolver subtypeResolver, PropertyNamingStrategy propertyNamingStrategy,
+            TypeFactory typeFactory, HandlerInstantiator handlerInstantiator)
+    {
+        super(intr, annIntr, vc, subtypeResolver, propertyNamingStrategy, typeFactory, handlerInstantiator,
+                collectFeatureDefaults(SerializationConfig.Feature.class));
+        _filterProvider = null;
+    }
+    
+    /**
+     * @since 1.8
+     */
+    protected SerializationConfig(SerializationConfig src) {
+        this(src, src._base);
+    }
+
+    /**
+     * Constructor used to make a private copy of specific mix-in definitions.
+     * 
+     * @since 1.8
+     */
+    protected SerializationConfig(SerializationConfig src,
+            HashMap<ClassKey,Class<?>> mixins, SubtypeResolver str)
+    {
+        this(src, src._base);
+        _mixInAnnotations = mixins;
+        _subtypeResolver = str;
+    }
+    
+    /**
+     * @since 1.8
+     */
+    protected SerializationConfig(SerializationConfig src, MapperConfig.Base base)
+    {
+        super(src, base, src._subtypeResolver);
+        _serializationInclusion = src._serializationInclusion;
+        _serializationView = src._serializationView;
+        _filterProvider = src._filterProvider;
+    }
+
+    /**
+     * @since 1.8
+     */
+    protected SerializationConfig(SerializationConfig src, FilterProvider filters)
+    {
+        super(src);
+        _serializationInclusion = src._serializationInclusion;
+        _serializationView = src._serializationView;
+        _filterProvider = filters;
+    }
+
+    /**
+     * @since 1.8
+     */
+    protected SerializationConfig(SerializationConfig src, Class<?> view)
+    {
+        super(src);
+        _serializationInclusion = src._serializationInclusion;
+        _serializationView = view;
+        _filterProvider = src._filterProvider;
+    }
+
+    /**
+     * @since 1.9
+     */
+    protected SerializationConfig(SerializationConfig src, JsonSerialize.Inclusion incl)
+    {
+        super(src);
+        _serializationInclusion = incl;
+        // And for some level of backwards compatibility, also...
+        if (incl == JsonSerialize.Inclusion.NON_NULL) {
+            _featureFlags &= ~Feature.WRITE_NULL_PROPERTIES.getMask();
+        } else {
+            _featureFlags |= Feature.WRITE_NULL_PROPERTIES.getMask();
+        }
+        _serializationView = src._serializationView;
+        _filterProvider = src._filterProvider;
+    }
+
+    /**
+     * @since 1.9
+     */
+    protected SerializationConfig(SerializationConfig src, int features)
+    {
+        super(src, features);
+        _serializationInclusion = src._serializationInclusion;
+        _serializationView = src._serializationView;
+        _filterProvider = src._filterProvider;
+    }
+    
+    /*
+    /**********************************************************
+    /* Life-cycle, factory methods from MapperConfig
+    /**********************************************************
+     */
+
+    @Override
+    public SerializationConfig withClassIntrospector(ClassIntrospector<? extends BeanDescription> ci) {
+        return new SerializationConfig(this, _base.withClassIntrospector(ci));
+    }
+
+    @Override
+    public SerializationConfig withAnnotationIntrospector(AnnotationIntrospector ai) {
+        return new SerializationConfig(this, _base.withAnnotationIntrospector(ai));
+    }
+
+    @Override
+    public SerializationConfig withInsertedAnnotationIntrospector(AnnotationIntrospector ai) {
+        return new SerializationConfig(this, _base.withInsertedAnnotationIntrospector(ai));
+    }
+
+    @Override
+    public SerializationConfig withAppendedAnnotationIntrospector(AnnotationIntrospector ai) {
+        return new SerializationConfig(this, _base.withAppendedAnnotationIntrospector(ai));
+    }
+    
+    @Override
+    public SerializationConfig withVisibilityChecker(VisibilityChecker<?> vc) {
+        return new SerializationConfig(this, _base.withVisibilityChecker(vc));
+    }
+
+    @Override
+    public SerializationConfig withVisibility(JsonMethod forMethod, JsonAutoDetect.Visibility visibility) {
+        return new SerializationConfig(this, _base.withVisibility(forMethod, visibility));
+    }
+    
+    @Override
+    public SerializationConfig withTypeResolverBuilder(TypeResolverBuilder<?> trb) {
+        return new SerializationConfig(this, _base.withTypeResolverBuilder(trb));
+    }
+
+    @Override
+    public SerializationConfig withSubtypeResolver(SubtypeResolver str) {
+        SerializationConfig cfg =  new SerializationConfig(this);
+        cfg._subtypeResolver = str;
+        return cfg;
+    }
+    
+    @Override
+    public SerializationConfig withPropertyNamingStrategy(PropertyNamingStrategy pns) {
+        return new SerializationConfig(this, _base.withPropertyNamingStrategy(pns));
+    }
+    
+    @Override
+    public SerializationConfig withTypeFactory(TypeFactory tf) {
+        return new SerializationConfig(this, _base.withTypeFactory(tf));
+    }
+
+    /**
+     * In addition to constructing instance with specified date format,
+     * will enable or disable <code>Feature.WRITE_DATES_AS_TIMESTAMPS</code>
+     * (enable if format set as null; disable if non-null)
+     */
+    @Override
+    public SerializationConfig withDateFormat(DateFormat df) {
+        SerializationConfig cfg =  new SerializationConfig(this, _base.withDateFormat(df));
+        // Also need to toggle this feature based on existence of date format:
+        if (df == null) {
+            cfg = cfg.with(Feature.WRITE_DATES_AS_TIMESTAMPS);
+        } else {
+            cfg = cfg.without(Feature.WRITE_DATES_AS_TIMESTAMPS);
+        }
+        return cfg;
+    }
+    
+    @Override
+    public SerializationConfig withHandlerInstantiator(HandlerInstantiator hi) {
+        return new SerializationConfig(this, _base.withHandlerInstantiator(hi));
+    }
+        
+    /*
+    /**********************************************************
+    /* Life-cycle, SerializationConfig specific factory methods
+    /**********************************************************
+     */
+    
+    /**
+     * @since 1.7
+     */
+    public SerializationConfig withFilters(FilterProvider filterProvider) {
+        return new SerializationConfig(this, filterProvider);
+    }
+
+    /**
+     * @since 1.8
+     */
+    public SerializationConfig withView(Class<?> view) {
+        return new SerializationConfig(this, view);
+    }
+
+    /**
+     * @since 1.9
+     */
+    public SerializationConfig withSerializationInclusion(JsonSerialize.Inclusion incl) {
+        return new SerializationConfig(this, incl);
+    }
+
+    /**
+     * Fluent factory method that will construct and return a new configuration
+     * object instance with specified features enabled.
+     * 
+     * @since 1.9
+     */
+    @Override
+    public SerializationConfig with(Feature... features)
+    {
+        int flags = _featureFlags;
+        for (Feature f : features) {
+            flags |= f.getMask();
+        }
+        return new SerializationConfig(this, flags);
+    }
+
+    /**
+     * Fluent factory method that will construct and return a new configuration
+     * object instance with specified features disabled.
+     * 
+     * @since 1.9
+     */
+    @Override
+    public SerializationConfig without(Feature... features)
+    {
+        int flags = _featureFlags;
+        for (Feature f : features) {
+            flags &= ~f.getMask();
+        }
+        return new SerializationConfig(this, flags);
+    }
+    
+    /*
+    /**********************************************************
+    /* MapperConfig implementation/overrides
+    /**********************************************************
+     */
+    
+    /**
+     * 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.
+     *<p>
+     * Serialization annotations that are known to have effect are:
+     *<ul>
+     * <li>{@link JsonWriteNullProperties}</li>
+     * <li>{@link JsonAutoDetect}</li>
+     * <li>{@link JsonSerialize#typing}</li>
+     *</ul>
+     * 
+     * @param cls Class of which class annotations to use
+     *   for changing configuration settings
+     *   
+     * @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.
+     */
+    @SuppressWarnings("deprecation")
+    @Deprecated
+    @Override
+    public void fromAnnotations(Class<?> cls)
+    {
+        /* 10-Jul-2009, tatu: Should be able to just pass null as
+         *    'MixInResolver'; no mix-ins set at this point
+         * 29-Jul-2009, tatu: Also, we do NOT ignore annotations here, even
+         *    if Feature.USE_ANNOTATIONS was disabled, since caller
+         *    specifically requested annotations to be added with this call
+         */
+        AnnotationIntrospector ai = getAnnotationIntrospector();
+        AnnotatedClass ac = AnnotatedClass.construct(cls, ai, null);
+        _base = _base.withVisibilityChecker(ai.findAutoDetectVisibility(ac,
+                getDefaultVisibilityChecker()));
+
+        // How about writing null property values?
+        JsonSerialize.Inclusion incl = ai.findSerializationInclusion(ac, null);
+        if (incl != _serializationInclusion) {
+            setSerializationInclusion(incl);
+    	}
+
+        JsonSerialize.Typing typing = ai.findSerializationTyping(ac);
+        if (typing != null) {
+            set(Feature.USE_STATIC_TYPING, (typing == JsonSerialize.Typing.STATIC));
+        }
+    }
+
+    @Override
+    public SerializationConfig createUnshared(SubtypeResolver subtypeResolver)
+    {
+        HashMap<ClassKey,Class<?>> mixins = _mixInAnnotations;
+        _mixInAnnotationsShared = true;
+        return new SerializationConfig(this, mixins, subtypeResolver);
+    }
+    
+    @Override
+    public AnnotationIntrospector getAnnotationIntrospector()
+    {
+        /* 29-Jul-2009, tatu: it's now possible to disable use of
+         *   annotations; can be done using "no-op" introspector
+         */
+        if (isEnabled(Feature.USE_ANNOTATIONS)) {
+            return super.getAnnotationIntrospector();
+        }
+        return AnnotationIntrospector.nopInstance();
+    }
+
+    /**
+     * Accessor for getting bean description that only contains class
+     * annotations: useful if no getter/setter/creator information is needed.
+     *<p>
+     * Note: part of {@link MapperConfig} since 1.7
+     */
+    @SuppressWarnings("unchecked")
+    @Override
+    public <T extends BeanDescription> T introspectClassAnnotations(JavaType type) {
+        return (T) getClassIntrospector().forClassAnnotations(this, type, this);
+    }
+
+    /**
+     * 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.
+     *<p>
+     * Note: part of {@link MapperConfig} since 1.7
+     */
+    @SuppressWarnings("unchecked")
+    @Override
+    public <T extends BeanDescription> T introspectDirectClassAnnotations(JavaType type) {
+        return (T) getClassIntrospector().forDirectClassAnnotations(this, type, this);
+    }
+
+    @Override
+    public boolean isAnnotationProcessingEnabled() {
+        return isEnabled(SerializationConfig.Feature.USE_ANNOTATIONS);
+    }
+    
+    @Override
+    public boolean canOverrideAccessModifiers() {
+        return isEnabled(Feature.CAN_OVERRIDE_ACCESS_MODIFIERS);
+    }
+
+    @Override
+    public boolean shouldSortPropertiesAlphabetically() {
+        return isEnabled(Feature.SORT_PROPERTIES_ALPHABETICALLY);
+    }
+    
+    @Override
+    public VisibilityChecker<?> getDefaultVisibilityChecker()
+    {
+        VisibilityChecker<?> vchecker = super.getDefaultVisibilityChecker();
+        if (!isEnabled(SerializationConfig.Feature.AUTO_DETECT_GETTERS)) {
+            vchecker = vchecker.withGetterVisibility(Visibility.NONE);
+        }
+        // then global overrides (disabling)
+        if (!isEnabled(SerializationConfig.Feature.AUTO_DETECT_IS_GETTERS)) {
+            vchecker = vchecker.withIsGetterVisibility(Visibility.NONE);
+        }
+        if (!isEnabled(SerializationConfig.Feature.AUTO_DETECT_FIELDS)) {
+            vchecker = vchecker.withFieldVisibility(Visibility.NONE);
+        }
+        return vchecker;
+    }
+
+    /*
+    /**********************************************************
+    /* MapperConfig overrides for 1.8 backwards compatibility
+    /**********************************************************
+     */
+
+    /* NOTE: these are overloads we MUST have, but that were missing
+     * from 1.9.0 and 1.9.1. Type erasure can bite in the ass...
+     *<p>
+     * NOTE: will remove either these variants, or base class one, in 2.0.
+     */
+    
+    /** 
+     * Alias for {@link MapperConfig#isEnabled(sh.calaba.org.codehaus.jackson.map.MapperConfig.ConfigFeature)}.
+     * 
+     * @since 1.0 However, note that version 1.9.0 and 1.9.1 accidentally missed
+     *    this overloaded variant
+     */
+    public boolean isEnabled(SerializationConfig.Feature f) {
+        return (_featureFlags & f.getMask()) != 0;
+    }
+    
+    /**
+     * @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
+    @Override
+    public void enable(SerializationConfig.Feature f) {
+        super.enable(f);
+    }
+
+    /** 
+     * @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
+    @Override
+    public void disable(SerializationConfig.Feature f) {
+        super.disable(f);
+    }
+
+    /** 
+     * @deprecated Since 1.9, it is preferable to use {@link #without} and {@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
+    @Override
+    public void set(SerializationConfig.Feature f, boolean state) {
+        super.set(f, state);
+    }
+    
+    /*
+    /**********************************************************
+    /* Configuration: other
+    /**********************************************************
+     */
+
+    /**
+     * Method for checking which serialization view is being used,
+     * if any; null if none.
+     *
+     * @since 1.4
+     */
+    public Class<?> getSerializationView() { return _serializationView; }
+
+    public JsonSerialize.Inclusion getSerializationInclusion()
+    {
+        if (_serializationInclusion != null) {
+            return _serializationInclusion;
+        }
+        return isEnabled(Feature.WRITE_NULL_PROPERTIES) ?
+            JsonSerialize.Inclusion.ALWAYS : JsonSerialize.Inclusion.NON_NULL;
+    }
+    
+    /**
+     * Method that will define global setting of which
+     * bean/map properties are to be included in serialization.
+     * Can be overridden by class annotations (overriding
+     * settings to use for instances of that class) and
+     * method/field annotations (overriding settings for the value
+     * bean for that getter method or field)
+     * 
+     * @deprecated since 1.9 should either use {@link #withSerializationInclusion}
+     *    to construct new instance, or configure through {@link ObjectMapper}
+     */
+    @Deprecated
+    public void setSerializationInclusion(JsonSerialize.Inclusion props)
+    {
+        _serializationInclusion = props;
+        // And for some level of backwards compatibility, also...
+        if (props == JsonSerialize.Inclusion.NON_NULL) {
+            disable(Feature.WRITE_NULL_PROPERTIES);
+        } else {
+            enable(Feature.WRITE_NULL_PROPERTIES);
+        }
+    }
+    
+    /**
+     * Method for getting provider used for locating filters given
+     * id (which is usually provided with filter annotations).
+     * Will be null if no provided was set for {@link ObjectWriter}
+     * (or if serialization directly called from {@link ObjectMapper})
+     * 
+     * @since 1.7
+     */
+    public FilterProvider getFilterProvider() {
+        return _filterProvider;
+    }
+
+    /*
+    /**********************************************************
+    /* Introspection methods
+    /**********************************************************
+     */
+
+    /**
+     * Method that will introspect full bean properties for the purpose
+     * of building a bean serializer
+     */
+    @SuppressWarnings("unchecked")
+    public <T extends BeanDescription> T introspect(JavaType type) {
+        return (T) getClassIntrospector().forSerialization(this, type, this);
+    }
+
+    /*
+    /**********************************************************
+    /* Extended API: serializer instantiation
+    /**********************************************************
+     */
+
+    @SuppressWarnings("unchecked")
+    public JsonSerializer<Object> serializerInstance(Annotated annotated, Class<? extends JsonSerializer<?>> serClass)
+    {
+        HandlerInstantiator hi = getHandlerInstantiator();
+        if (hi != null) {
+            JsonSerializer<?> ser = hi.serializerInstance(this, annotated, serClass);
+            if (ser != null) {
+                return (JsonSerializer<Object>) ser;
+            }
+        }
+        return (JsonSerializer<Object>) ClassUtil.createInstance(serClass, canOverrideAccessModifiers());
+    }
+    
+    /*
+    /**********************************************************
+    /* Deprecated methods
+    /**********************************************************
+     */
+    
+    /**
+     * One thing to note is that this will set {@link Feature#WRITE_DATES_AS_TIMESTAMPS}
+     * to false (if null format set), or true (if non-null format)
+     * 
+     * @deprecated Since 1.8, use {@link #withDateFormat} instead.
+     */
+    @SuppressWarnings("deprecation")
+    @Override
+    @Deprecated
+    public final void setDateFormat(DateFormat df) {
+        super.setDateFormat(df);
+        set(Feature.WRITE_DATES_AS_TIMESTAMPS, (df == null));
+    }
+    
+    /**
+     * Method for checking which serialization view is being used,
+     * if any; null if none.
+     *
+     * @since 1.4
+     * 
+     * @deprecated Since 1.8, use {@link #withView} instead
+     */
+    @Deprecated
+    public void setSerializationView(Class<?> view)
+    {
+        _serializationView = view;
+    }
+    
+    /*
+    /**********************************************************
+    /* Debug support
+    /**********************************************************
+     */
+    
+    @Override public String toString()
+    {
+        return "[SerializationConfig: flags=0x"+Integer.toHexString(_featureFlags)+"]";
+    }
+}