calabash-android 0.0.1

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

@@ -0,0 +1,95 @@
+package sh.calaba.org.codehaus.jackson.map.ser;
+
+import java.util.List;
+
+import sh.calaba.org.codehaus.jackson.map.JsonSerializer;
+import sh.calaba.org.codehaus.jackson.map.SerializationConfig;
+import sh.calaba.org.codehaus.jackson.map.introspect.BasicBeanDescription;
+
+/**
+ * Abstract class that defines API for objects that can be registered (for {@link BeanSerializerFactory}
+ * to participate in constructing {@link BeanSerializer} instances.
+ * This is typically done by modules that want alter some aspects of serialization
+ * process; and is preferable to sub-classing of {@link BeanSerializerFactory}.
+ *<p>
+ * Sequence in which callback methods are called is as follows:
+ * <ol>
+ *  <li>After factory has collected tentative set of properties (instances of
+ *     <code>BeanPropertyWriter</code>) is sent for modification via
+ *     {@link #changeProperties}. Changes can include removal, addition and
+ *     replacement of suggested properties.
+ *  <li>Resulting set of properties are ordered (sorted) by factory, as per
+ *     configuration, and then {@link #orderProperties} is called to allow
+ *     modifiers to alter ordering.
+ *  <li>After all bean properties and related information is accumulated,
+ *     {@link #updateBuilder} is called with builder, to allow builder state
+ *     to be modified (including possibly replacing builder itself if necessary)
+ *  <li>Once all bean information has been determined,
+ *     factory creates default {@link BeanSerializer} instance and passes
+ *     it to modifiers using {@link #modifySerializer}, for possible
+ *     modification or replacement (by any {@link sh.calaba.org.codehaus.jackson.map.JsonSerializer} instance)
+ * </ol>
+ *<p>
+ * Default method implementations are "no-op"s, meaning that methods are implemented
+ * but have no effect.
+ * 
+ * @since 1.7
+ */
+public abstract class BeanSerializerModifier
+{
+    /**
+     * Method called by {@link BeanSerializerFactory} with tentative set
+     * of discovered properties.
+     * Implementations can add, remove or replace any of passed properties.
+     *
+     * Properties <code>List</code> passed as argument is modifiable, and returned List must
+     * likewise be modifiable as it may be passed to multiple registered
+     * modifiers.
+     */
+    public List<BeanPropertyWriter> changeProperties(SerializationConfig config,
+            BasicBeanDescription beanDesc, List<BeanPropertyWriter> beanProperties) {
+        return beanProperties;
+    }
+
+    /**
+     * Method called by {@link BeanSerializerFactory} with set of properties
+     * to serialize, in default ordering (based on defaults as well as 
+     * possible type annotations).
+     * Implementations can change ordering any way they like.
+     *
+     * Properties <code>List</code> passed as argument is modifiable, and returned List must
+     * likewise be modifiable as it may be passed to multiple registered
+     * modifiers.
+     */
+    public List<BeanPropertyWriter> orderProperties(SerializationConfig config,
+            BasicBeanDescription beanDesc, List<BeanPropertyWriter> beanProperties) {
+        return beanProperties;
+    }
+
+    /**
+     * Method called by {@link BeanSerializerFactory} after collecting all information
+     * regarding POJO to serialize and updating builder with it, but before constructing
+     * serializer.
+     * Implementations may choose to modify state of builder (to affect serializer being
+     * built), or even completely replace it (if they want to build different kind of
+     * serializer). Typically, however, passed-in builder is returned, possibly with
+     * some modifications.
+     */
+    public BeanSerializerBuilder updateBuilder(SerializationConfig config,
+            BasicBeanDescription beanDesc, BeanSerializerBuilder builder) {
+        return builder;
+    }
+    
+    /**
+     * Method called by {@link BeanSerializerFactory} after constructing default
+     * bean serializer instance with properties collected and ordered earlier.
+     * Implementations can modify or replace given serializer and return serializer
+     * to use. Note that although initial serializer being passed is of type
+     * {@link BeanSerializer}, modifiers may return serializers of other types;
+     * and this is why implementations must check for type before casting.
+     */
+    public JsonSerializer<?> modifySerializer(SerializationConfig config,
+            BasicBeanDescription beanDesc, JsonSerializer<?> serializer) {
+        return serializer;
+    }
+}

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

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

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

@@ -0,0 +1,293 @@
+package sh.calaba.org.codehaus.jackson.map.ser;
+
+import java.lang.reflect.Modifier;
+import java.util.*;
+
+import sh.calaba.org.codehaus.jackson.map.*;
+import sh.calaba.org.codehaus.jackson.map.type.ClassKey;
+import sh.calaba.org.codehaus.jackson.type.JavaType;
+
+/**
+ * Serializer factory implementation that allows for configuring
+ * mapping between types (classes) and serializers to use, by using
+ * multiple types of overrides. Existing mappings established by
+ * {@link BeanSerializerFactory} (and its super class,
+ * {@link BasicSerializerFactory}) are used if no overrides are
+ * defined.
+ *<p>
+ * Unlike base serializer factories ({@link BasicSerializerFactory},
+ * {@link BeanSerializerFactory}), this factory is stateful because
+ * of configuration settings. It is thread-safe, however, as long as
+ * all configuration as done before using the factory -- a single
+ * instance can be shared between providers and mappers.
+ *<p>
+ * Configurations currently available are:
+ *<ul>
+ * <li>Ability to define explicit mappings between classes and interfaces
+ *  and serializers to use. These can be either specific ones (class must
+ *  match exactly) or generic ones (any sub-class or class implementing
+ *  the interface); specific ones have precedence over generic ones (and
+ *  precedence between generic ones is not defined).
+ *  </li>
+ * <li>Ability to define a single generic base serializer for all Enum
+ *   types (precedence below specific serializer mapping)
+ *  </li>
+ *</ul>
+ *<p>
+ * Note: as of version 1.7, this class is not as useful as it used to
+ * be, due to addition of "modules", which allow simpler addition
+ * of custom serializers and deserializers. In fact, use of module system
+ * is recommended even when not exposing serializers or deserializers
+ * as a pluggable library (just using them locally).
+ */
+public class CustomSerializerFactory
+    extends BeanSerializerFactory
+{
+    /*
+    /**********************************************************
+    /* Configuration, direct/special mappings
+    /**********************************************************
+     */
+
+    /**
+     * Direct mappings that are only used for exact class type
+     * matches, but not for sub-class checks.
+     */
+    protected HashMap<ClassKey,JsonSerializer<?>> _directClassMappings = null;
+
+    /**
+     * And for Enum handling we may specify a single default
+     * serializer to use, regardless of actual enumeration.
+     * Usually used to provide "toString - serializer".
+     */
+    protected JsonSerializer<?> _enumSerializerOverride;
+
+    /*
+    /**********************************************************
+    /* Configuration, generic (interface, super-class) mappings
+    /**********************************************************
+     */
+
+    /**
+     * And then class-based mappings that are used both for exact and
+     * sub-class matches.
+     */
+    protected HashMap<ClassKey,JsonSerializer<?>> _transitiveClassMappings = null;
+
+    /**
+     * And finally interface-based matches.
+     */
+    protected HashMap<ClassKey,JsonSerializer<?>> _interfaceMappings = null;
+
+    /*
+    /**********************************************************
+    /* Life-cycle, constructors
+    /**********************************************************
+     */
+
+    public CustomSerializerFactory() {
+        this(null);
+    }
+
+    public CustomSerializerFactory(Config config) {
+        super(config);
+    }
+    
+    @Override
+    public SerializerFactory withConfig(Config config)
+    {
+        /* 22-Nov-2010, tatu: As with BeanSerializerFactory, must ensure type won't change
+         *   with this method, so:
+         */
+        if (getClass() != CustomSerializerFactory.class) {
+            throw new IllegalStateException("Subtype of CustomSerializerFactory ("+getClass().getName()
+                    +") has not properly overridden method 'withAdditionalSerializers': can not instantiate subtype with "
+                    +"additional serializer definitions");
+        }
+        return new CustomSerializerFactory(config);
+    }
+    
+    /*
+    /**********************************************************
+    /* Configuration: type-to-serializer mappings
+    /**********************************************************
+     */
+
+    /**
+     * Method used to add a generic (transitive) mapping from specified
+     * class or its sub-classes into a serializer.
+     * When resolving a type into a serializer, explicit class is checked
+     * first, then immediate super-class, and so forth along inheritance
+     * chain. But if this fails, implemented interfaces are checked;
+     * ordering is done such that first interfaces implemented by
+     * the exact type are checked (in order returned by
+     * {@link Class#getInterfaces}), then super-type's and so forth.
+     *<p>
+     * Note that adding generic mappings may lead to problems with
+     * sub-classing: if sub-classes add new properties, these may not
+     * get properly serialized.
+     *
+     * @param type Class for which specified serializer is to be
+     *   used. May be more specific type than what serializer indicates,
+     *   but must be compatible (same or sub-class)
+     */
+    public <T> void addGenericMapping(Class<? extends T> type, JsonSerializer<T> ser)
+    {
+        // Interface to match?
+        ClassKey key = new ClassKey(type);
+        if (type.isInterface()) {
+            if (_interfaceMappings == null) {
+                _interfaceMappings = new HashMap<ClassKey,JsonSerializer<?>>();
+            }
+            _interfaceMappings.put(key, ser);
+        } else { // nope, class:
+            if (_transitiveClassMappings == null) {
+                _transitiveClassMappings = new HashMap<ClassKey,JsonSerializer<?>>();
+            }
+            _transitiveClassMappings.put(key, ser);
+        }
+    }
+
+    /**
+     * Method used to add a mapping from specific type -- and only that
+     * type -- to specified serializer. This means that binding is not
+     * used for sub-types. It also means that no such mappings are to
+     * be defined for abstract classes or interfaces: and if an attempt
+     * is made, {@link IllegalArgumentException} will be thrown to
+     * indicate caller error.
+     *
+     * @param forClass Class for which specified serializer is to be
+     *   used. May be more specific type than what serializer indicates,
+     *   but must be compatible (same or sub-class)
+     */
+    public <T> void addSpecificMapping(Class<? extends T> forClass, JsonSerializer<T> ser)
+    {
+        ClassKey key = new ClassKey(forClass);
+
+        /* First, let's ensure it's not an interface or abstract class:
+         * as those can not be instantiated, such mappings would never
+         * get used.
+         */
+        if (forClass.isInterface()) {
+            throw new IllegalArgumentException("Can not add specific mapping for an interface ("+forClass.getName()+")");
+        }
+        if (Modifier.isAbstract(forClass.getModifiers())) {
+            throw new IllegalArgumentException("Can not add specific mapping for an abstract class ("+forClass.getName()+")");
+        }
+
+        if (_directClassMappings == null) {
+            _directClassMappings = new HashMap<ClassKey,JsonSerializer<?>>();
+        }
+        _directClassMappings.put(key, ser);
+    }
+
+    /**
+     * Method that can be used to force specified serializer to be used for
+     * serializing all Enum instances. This is most commonly used to specify
+     * serializers that call either <code>enum.toString()</code>, or modify
+     * value returned by <code>enum.name()</code> (such as upper- or
+     * lower-casing it).
+     *<p>
+     * Note: this serializer has lower precedence than that of specific
+     * types; so if a specific serializer is assigned to an Enum type,
+     * this serializer will NOT be used. It has higher precedence than
+     * generic mappings have however.
+     */
+    public void setEnumSerializer(JsonSerializer<?> enumSer)
+    {
+        _enumSerializerOverride = enumSer;
+    }
+
+    /*
+    /**********************************************************
+    /* JsonSerializerFactory impl
+    /**********************************************************
+     */
+
+    @Override
+    @SuppressWarnings("unchecked")    
+    public JsonSerializer<Object> createSerializer(SerializationConfig config, JavaType type,
+            BeanProperty property)
+        throws JsonMappingException
+    {
+        JsonSerializer<?> ser = findCustomSerializer(type.getRawClass(), config);
+        if (ser != null) {
+            return (JsonSerializer<Object>) ser;
+        }
+        return super.createSerializer(config, type, property);
+    }
+
+    /*
+    /**********************************************************
+    /* Internal methods
+    /**********************************************************
+     */
+    
+    protected JsonSerializer<?> findCustomSerializer(Class<?> type, SerializationConfig config)
+    {
+        JsonSerializer<?> ser = null;
+        ClassKey key = new ClassKey(type);
+
+        // First: exact matches
+        if (_directClassMappings != null) {
+            ser = _directClassMappings.get(key);
+            if (ser != null) {
+                return ser;
+            }
+        }
+
+        // No match? Perhaps we can use the enum serializer?
+        if (type.isEnum()) {
+            if (_enumSerializerOverride != null) {
+                return _enumSerializerOverride;
+            }
+        }
+
+        // Still no match? How about more generic ones?
+        // Mappings for super-classes?
+        if (_transitiveClassMappings != null) {
+            for (Class<?> curr = type; (curr != null); curr = curr.getSuperclass()) {
+                key.reset(curr);
+                ser = _transitiveClassMappings.get(key);
+                if (ser != null) {
+                    return ser;
+                }
+            }
+        }
+
+        // And if still no match, how about interfaces?
+        if (_interfaceMappings != null) {
+            // as per [JACKSON-327], better check actual interface first too...
+            key.reset(type);
+            ser = _interfaceMappings.get(key);
+            if (ser != null) {
+                return ser;
+            }
+            for (Class<?> curr = type; (curr != null); curr = curr.getSuperclass()) {
+                ser = _findInterfaceMapping(curr, key);
+                if (ser != null) {
+                    return ser;
+                }
+            }
+        }
+        return null;
+    }
+
+    protected JsonSerializer<?> _findInterfaceMapping(Class<?> cls, ClassKey key)
+    {
+        for (Class<?> iface : cls.getInterfaces()) {
+            key.reset(iface);
+            JsonSerializer<?> ser = _interfaceMappings.get(key);
+            if (ser != null) {
+                return ser;
+            }
+            // [JACKSON-373] need to also check super-interfaces
+            ser = _findInterfaceMapping(iface, key);
+            if (ser != null) {
+                return ser;
+            }
+        }
+        return null;
+    }
+}
+

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

@@ -0,0 +1,17 @@
+package sh.calaba.org.codehaus.jackson.map.ser;
+
+import sh.calaba.org.codehaus.jackson.map.annotate.JacksonStdImpl;
+import sh.calaba.org.codehaus.jackson.map.util.EnumValues;
+
+/**
+ * @deprecated Since 1.9 use {@link sh.calaba.org.codehaus.jackson.map.ser.std.EnumSerializer}
+ */
+@Deprecated
+@JacksonStdImpl
+public class EnumSerializer
+    extends sh.calaba.org.codehaus.jackson.map.ser.std.EnumSerializer
+{
+    public EnumSerializer(EnumValues v) {
+        super(v);
+    }
+}

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

@@ -0,0 +1,23 @@
+package sh.calaba.org.codehaus.jackson.map.ser;
+
+/**
+ * Interface for objects that providers instances of {@link BeanPropertyFilter}
+ * that match given ids. A provider is configured to be used during serialization,
+ * to find filter to used based on id specified by {@link sh.calaba.org.codehaus.jackson.map.annotate.JsonFilter}
+ * annotation on bean class.
+ * 
+ * @since 1.7
+ */
+public abstract class FilterProvider
+{
+    /**
+     * Lookup method used to find {@link BeanPropertyFilter} that has specified id.
+     * Note that id is typically a {@link java.lang.String}, but is not necessarily
+     * limited to that; that is, while standard components use String, custom
+     * implementation can choose other kinds of keys.
+     * 
+     * @return Filter registered with specified id, if one defined; null if
+     *   none found.
+     */
+    public abstract BeanPropertyFilter findFilter(Object filterId);
+}

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

@@ -0,0 +1,96 @@
+package sh.calaba.org.codehaus.jackson.map.ser;
+
+import sh.calaba.org.codehaus.jackson.JsonGenerator;
+import sh.calaba.org.codehaus.jackson.map.JsonSerializer;
+import sh.calaba.org.codehaus.jackson.map.SerializerProvider;
+
+/**
+ * Decorated {@link BeanPropertyWriter} that will filter out
+ * properties that are not to be included in currently active
+ * JsonView.
+ *
+ * @since 1.4
+ */
+public abstract class FilteredBeanPropertyWriter
+{    
+    public static BeanPropertyWriter constructViewBased(BeanPropertyWriter base, Class<?>[] viewsToIncludeIn)
+    {
+        if (viewsToIncludeIn.length == 1) {
+            return new SingleView(base, viewsToIncludeIn[0]);
+        }
+        return new MultiView(base, viewsToIncludeIn);
+    }
+
+    /*
+    /**********************************************************
+    /* Concrete sub-classes
+    /**********************************************************
+     */
+
+    private final static class SingleView
+        extends BeanPropertyWriter
+    {
+        protected final BeanPropertyWriter _delegate;
+
+        protected final Class<?> _view;
+        
+        protected SingleView(BeanPropertyWriter delegate, Class<?> view)
+        {
+            super(delegate);
+            _delegate = delegate;
+            _view = view;
+        }
+        
+        @Override
+        public BeanPropertyWriter withSerializer(JsonSerializer<Object> ser) {
+            return new SingleView(_delegate.withSerializer(ser), _view);
+        }
+        
+        @Override
+        public void serializeAsField(Object bean, JsonGenerator jgen, SerializerProvider prov)
+            throws Exception
+        {
+            Class<?> activeView = prov.getSerializationView();
+            if (activeView == null || _view.isAssignableFrom(activeView)) {
+                _delegate.serializeAsField(bean, jgen, prov);
+            }
+        }
+    }
+
+    private final static class MultiView
+        extends BeanPropertyWriter
+    {
+        protected final BeanPropertyWriter _delegate;
+
+        protected final Class<?>[] _views;
+        
+        protected MultiView(BeanPropertyWriter delegate, Class<?>[] views) {
+            super(delegate);
+            _delegate = delegate;
+            _views = views;
+        }
+        
+        @Override
+        public BeanPropertyWriter withSerializer(JsonSerializer<Object> ser) {
+            return new MultiView(_delegate.withSerializer(ser), _views);
+        }
+        
+        @Override
+        public void serializeAsField(Object bean, JsonGenerator jgen, SerializerProvider prov)
+            throws Exception
+        {
+            final Class<?> activeView = prov.getSerializationView();
+            if (activeView != null) {
+                int i = 0, len = _views.length;
+                for (; i < len; ++i) {
+                    if (_views[i].isAssignableFrom(activeView)) break;
+                }
+                // not included, bail out:
+                if (i == len) {
+                    return;
+                }
+            }
+            _delegate.serializeAsField(bean, jgen, prov);
+        }
+    }
+}