calabash-android 0.5.2 → 0.5.3

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

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

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

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

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

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

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