calabash-android 0.4.7.pre6 → 0.4.7.pre7

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

@@ -0,0 +1,422 @@
+package sh.calaba.org.codehaus.jackson.map.ser.std;
+
+import java.io.IOException;
+import java.lang.reflect.Type;
+import java.util.*;
+
+import sh.calaba.org.codehaus.jackson.JsonGenerationException;
+import sh.calaba.org.codehaus.jackson.JsonGenerator;
+import sh.calaba.org.codehaus.jackson.JsonNode;
+import sh.calaba.org.codehaus.jackson.map.*;
+import sh.calaba.org.codehaus.jackson.map.annotate.JacksonStdImpl;
+import sh.calaba.org.codehaus.jackson.map.ser.impl.PropertySerializerMap;
+import sh.calaba.org.codehaus.jackson.map.type.TypeFactory;
+import sh.calaba.org.codehaus.jackson.node.ObjectNode;
+import sh.calaba.org.codehaus.jackson.type.JavaType;
+
+/**
+ * Standard serializer implementation for serializing {link java.util.Map} types.
+ *<p>
+ * Note: about the only configurable setting currently is ability to filter out
+ * entries with specified names.
+ */
+@JacksonStdImpl
+public class MapSerializer
+    extends ContainerSerializerBase<Map<?,?>>
+    implements ResolvableSerializer
+{
+    protected final static JavaType UNSPECIFIED_TYPE = TypeFactory.unknownType();
+    
+    /**
+     * Map-valued property being serialized with this instance
+     * 
+     * @since 1.7
+     */
+    protected final BeanProperty _property;
+    
+    /**
+     * Set of entries to omit during serialization, if any
+     */
+    protected final HashSet<String> _ignoredEntries;
+
+    /**
+     * Whether static types should be used for serialization of values
+     * or not (if not, dynamic runtime type is used)
+     */
+    protected final boolean _valueTypeIsStatic;
+
+    /**
+     * Declared type of keys
+     * 
+     * @since 1.7
+     */
+    protected final JavaType _keyType;
+
+    /**
+     * Declared type of contained values
+     */
+    protected final JavaType _valueType;
+
+    /**
+     * Key serializer to use, if it can be statically determined
+     * 
+     * @since 1.7
+     */
+    protected JsonSerializer<Object> _keySerializer;
+
+    /**
+     * Value serializer to use, if it can be statically determined
+     * 
+     * @since 1.5
+     */
+    protected JsonSerializer<Object> _valueSerializer;
+
+    /**
+     * Type identifier serializer used for values, if any.
+     */
+    protected final TypeSerializer _valueTypeSerializer;
+
+    /**
+     * If value type can not be statically determined, mapping from
+     * runtime value types to serializers are stored in this object.
+     * 
+     * @since 1.8
+     */
+    protected PropertySerializerMap _dynamicValueSerializers;
+    
+    protected MapSerializer() {
+        this((HashSet<String>)null, null, null, false, null, null, null, null);
+    }
+    
+    protected MapSerializer(HashSet<String> ignoredEntries,
+            JavaType keyType, JavaType valueType, boolean valueTypeIsStatic,
+            TypeSerializer vts,
+            JsonSerializer<Object> keySerializer, JsonSerializer<Object> valueSerializer, 
+            BeanProperty property)
+    {
+        super(Map.class, false);
+        _property = property;
+        _ignoredEntries = ignoredEntries;
+        _keyType = keyType;
+        _valueType = valueType;
+        _valueTypeIsStatic = valueTypeIsStatic;
+        _valueTypeSerializer = vts;
+        _keySerializer = keySerializer;
+        _valueSerializer = valueSerializer;
+        _dynamicValueSerializers = PropertySerializerMap.emptyMap();
+    }
+    
+    @Override
+    public ContainerSerializerBase<?> _withValueTypeSerializer(TypeSerializer vts)
+    {
+        MapSerializer ms = new MapSerializer(_ignoredEntries, _keyType, _valueType, _valueTypeIsStatic, vts,
+                _keySerializer, _valueSerializer, _property);
+        if (_valueSerializer != null) {
+            ms._valueSerializer = _valueSerializer;
+        }
+        return ms;
+    }
+    
+    /**
+     * Factory method used to construct Map serializers.
+     * 
+     * @param ignoredList Array of entry names that are to be filtered on
+     *    serialization; null if none
+     * @param mapType Declared type information (needed for static typing)
+     * @param staticValueType Whether static typing should be used for the
+     *    Map (which includes its contents)
+     * @param vts Type serializer to use for map entry values, if any
+     * 
+     * @deprecated As of 1.8; use the variant with more arguments
+     */
+    @Deprecated
+    public static MapSerializer construct(String[] ignoredList, JavaType mapType,
+            boolean staticValueType, TypeSerializer vts, BeanProperty property)
+    {
+        return construct(ignoredList, mapType, staticValueType, vts, property, null, null);
+    }
+
+    public static MapSerializer construct(String[] ignoredList, JavaType mapType,
+            boolean staticValueType, TypeSerializer vts, BeanProperty property,
+            JsonSerializer<Object> keySerializer, JsonSerializer<Object> valueSerializer)
+    {
+        HashSet<String> ignoredEntries = toSet(ignoredList);
+        JavaType keyType, valueType;
+        
+        if (mapType == null) {
+            keyType = valueType = UNSPECIFIED_TYPE;
+        } else { 
+            keyType = mapType.getKeyType();
+            valueType = mapType.getContentType();
+        }
+        // If value type is final, it's same as forcing static value typing:
+        if (!staticValueType) {
+            staticValueType = (valueType != null && valueType.isFinal());
+        }
+        return new MapSerializer(ignoredEntries, keyType, valueType, staticValueType, vts,
+                keySerializer, valueSerializer, property);
+    }
+
+    private static HashSet<String> toSet(String[] ignoredEntries) {
+        if (ignoredEntries == null || ignoredEntries.length == 0) {
+            return null;
+        }
+        HashSet<String> result = new HashSet<String>(ignoredEntries.length);
+        for (String prop : ignoredEntries) {
+            result.add(prop);
+        }
+        return result;
+    }
+    
+    /*
+    /**********************************************************
+    /* JsonSerializer implementation
+    /**********************************************************
+     */
+
+    @Override
+    public void serialize(Map<?,?> value, JsonGenerator jgen, SerializerProvider provider)
+        throws IOException, JsonGenerationException
+    {
+        jgen.writeStartObject();
+        if (!value.isEmpty()) {
+            if (_valueSerializer != null) {
+                serializeFieldsUsing(value, jgen, provider, _valueSerializer);
+            } else {
+                serializeFields(value, jgen, provider);
+            }
+        }        
+        jgen.writeEndObject();
+    }
+
+    @Override
+    public void serializeWithType(Map<?,?> value, JsonGenerator jgen, SerializerProvider provider,
+            TypeSerializer typeSer)
+        throws IOException, JsonGenerationException
+    {
+        typeSer.writeTypePrefixForObject(value, jgen);
+        if (!value.isEmpty()) {
+            if (_valueSerializer != null) {
+                serializeFieldsUsing(value, jgen, provider, _valueSerializer);
+            } else {
+                serializeFields(value, jgen, provider);
+            }
+        }
+        typeSer.writeTypeSuffixForObject(value, jgen);
+    }
+
+    /*
+    /**********************************************************
+    /* JsonSerializer implementation
+    /**********************************************************
+     */
+    
+    /**
+     * Method called to serialize fields, when the value type is not statically known.
+     */
+    public void serializeFields(Map<?,?> value, JsonGenerator jgen, SerializerProvider provider)
+        throws IOException, JsonGenerationException
+    {
+        // If value type needs polymorphic type handling, some more work needed:
+        if (_valueTypeSerializer != null) {
+            serializeTypedFields(value, jgen, provider);
+            return;
+        }
+        final JsonSerializer<Object> keySerializer = _keySerializer;
+        
+        final HashSet<String> ignored = _ignoredEntries;
+        final boolean skipNulls = !provider.isEnabled(SerializationConfig.Feature.WRITE_NULL_MAP_VALUES);
+
+        PropertySerializerMap serializers = _dynamicValueSerializers;
+
+        for (Map.Entry<?,?> entry : value.entrySet()) {
+            Object valueElem = entry.getValue();
+            // First, serialize key
+            Object keyElem = entry.getKey();
+            if (keyElem == null) {
+                provider.getNullKeySerializer().serialize(null, jgen, provider);
+            } else {
+                // [JACKSON-314] skip entries with null values?
+                if (skipNulls && valueElem == null) continue;
+                // One twist: is entry ignorable? If so, skip
+                if (ignored != null && ignored.contains(keyElem)) continue;
+                keySerializer.serialize(keyElem, jgen, provider);
+            }
+
+            // And then value
+            if (valueElem == null) {
+                provider.defaultSerializeNull(jgen);
+            } else {
+                Class<?> cc = valueElem.getClass();
+                JsonSerializer<Object> serializer = serializers.serializerFor(cc);
+                if (serializer == null) {
+                    if (_valueType.hasGenericTypes()) {
+                        serializer = _findAndAddDynamic(serializers,
+                                provider.constructSpecializedType(_valueType, cc), provider);
+                    } else {
+                        serializer = _findAndAddDynamic(serializers, cc, provider);
+                    }
+                    serializers = _dynamicValueSerializers;
+                }
+                try {
+                    serializer.serialize(valueElem, jgen, provider);
+                } catch (Exception e) {
+                    // [JACKSON-55] Need to add reference information
+                    String keyDesc = ""+keyElem;
+                    wrapAndThrow(provider, e, value, keyDesc);
+                }
+            }
+        }
+    }
+
+    /**
+     * Method called to serialize fields, when the value type is statically known,
+     * so that value serializer is passed and does not need to be fetched from
+     * provider.
+     */
+    protected void serializeFieldsUsing(Map<?,?> value, JsonGenerator jgen, SerializerProvider provider,
+            JsonSerializer<Object> ser)
+            throws IOException, JsonGenerationException
+    {
+        final JsonSerializer<Object> keySerializer = _keySerializer;
+        final HashSet<String> ignored = _ignoredEntries;
+        final TypeSerializer typeSer = _valueTypeSerializer;
+        final boolean skipNulls = !provider.isEnabled(SerializationConfig.Feature.WRITE_NULL_MAP_VALUES);
+
+        for (Map.Entry<?,?> entry : value.entrySet()) {
+            Object valueElem = entry.getValue();
+            Object keyElem = entry.getKey();
+            if (keyElem == null) {
+                provider.getNullKeySerializer().serialize(null, jgen, provider);
+            } else {
+                // [JACKSON-314] also may need to skip entries with null values
+                if (skipNulls && valueElem == null) continue;
+                if (ignored != null && ignored.contains(keyElem)) continue;
+                keySerializer.serialize(keyElem, jgen, provider);
+            }
+            if (valueElem == null) {
+                provider.defaultSerializeNull(jgen);
+            } else {
+                try {
+                    if (typeSer == null) {
+                        ser.serialize(valueElem, jgen, provider);
+                    } else {
+                        ser.serializeWithType(valueElem, jgen, provider, typeSer);
+                    }
+                } catch (Exception e) {
+                    // [JACKSON-55] Need to add reference information
+                    String keyDesc = ""+keyElem;
+                    wrapAndThrow(provider, e, value, keyDesc);
+                }
+            }
+        }
+    }
+
+    protected void serializeTypedFields(Map<?,?> value, JsonGenerator jgen, SerializerProvider provider)
+        throws IOException, JsonGenerationException
+    {
+        final JsonSerializer<Object> keySerializer = _keySerializer;
+        JsonSerializer<Object> prevValueSerializer = null;
+        Class<?> prevValueClass = null;
+        final HashSet<String> ignored = _ignoredEntries;
+        final boolean skipNulls = !provider.isEnabled(SerializationConfig.Feature.WRITE_NULL_MAP_VALUES);
+    
+        for (Map.Entry<?,?> entry : value.entrySet()) {
+            Object valueElem = entry.getValue();
+            // First, serialize key
+            Object keyElem = entry.getKey();
+            if (keyElem == null) {
+                provider.getNullKeySerializer().serialize(null, jgen, provider);
+            } else {
+                // [JACKSON-314] also may need to skip entries with null values
+                if (skipNulls && valueElem == null) continue;
+                // One twist: is entry ignorable? If so, skip
+                if (ignored != null && ignored.contains(keyElem)) continue;
+                keySerializer.serialize(keyElem, jgen, provider);
+            }
+    
+            // And then value
+            if (valueElem == null) {
+                provider.defaultSerializeNull(jgen);
+            } else {
+                Class<?> cc = valueElem.getClass();
+                JsonSerializer<Object> currSerializer;
+                if (cc == prevValueClass) {
+                    currSerializer = prevValueSerializer;
+                } else {
+                    currSerializer = provider.findValueSerializer(cc, _property);
+                    prevValueSerializer = currSerializer;
+                    prevValueClass = cc;
+                }
+                try {
+                    currSerializer.serializeWithType(valueElem, jgen, provider, _valueTypeSerializer);
+                } catch (Exception e) {
+                    // [JACKSON-55] Need to add reference information
+                    String keyDesc = ""+keyElem;
+                    wrapAndThrow(provider, e, value, keyDesc);
+                }
+            }
+        }
+    }
+    
+    @Override
+    public JsonNode getSchema(SerializerProvider provider, Type typeHint)
+    {
+        ObjectNode o = createSchemaNode("object", true);
+        //(ryan) even though it's possible to statically determine the "value" type of the map,
+        // there's no way to statically determine the keys, so the "Entries" can't be determined.
+        return o;
+    }
+
+    /**
+     * Need to get callback to resolve value serializer, if static typing
+     * is used (either being forced, or because value type is final)
+     */
+    @Override
+    public void resolve(SerializerProvider provider)
+        throws JsonMappingException
+    {
+        if (_valueTypeIsStatic && _valueSerializer == null) {
+            _valueSerializer = provider.findValueSerializer(_valueType, _property);
+        }
+        /* 10-Dec-2010, tatu: Let's also fetch key serializer; and always assume we'll
+         *   do that just by using static type information
+         */
+        /* 25-Feb-2011, tatu: May need to reconsider this static checking (since it
+         *   differs from value handling)... but for now, it's ok to ensure contextual
+         *   aspects are handled; this is done by provider.
+         */
+        if (_keySerializer == null) {
+            _keySerializer = provider.findKeySerializer(_keyType, _property);
+        }
+    }
+
+    /*
+    /**********************************************************
+    /* Internal methods
+    /**********************************************************
+     */
+    
+    protected final JsonSerializer<Object> _findAndAddDynamic(PropertySerializerMap map,
+            Class<?> type, SerializerProvider provider) throws JsonMappingException
+    {
+        PropertySerializerMap.SerializerAndMapResult result = map.findAndAddSerializer(type, provider, _property);
+        // did we get a new map of serializers? If so, start using it
+        if (map != result.map) {
+            _dynamicValueSerializers = result.map;
+        }
+        return result.serializer;
+    }
+
+    protected final JsonSerializer<Object> _findAndAddDynamic(PropertySerializerMap map,
+            JavaType type, SerializerProvider provider) throws JsonMappingException
+    {
+        PropertySerializerMap.SerializerAndMapResult result = map.findAndAddSerializer(type, provider, _property);
+        if (map != result.map) {
+            _dynamicValueSerializers = result.map;
+        }
+        return result.serializer;
+    }
+
+}
+

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

@@ -0,0 +1,34 @@
+package sh.calaba.org.codehaus.jackson.map.ser.std;
+
+import java.io.IOException;
+
+import sh.calaba.org.codehaus.jackson.JsonGenerationException;
+import sh.calaba.org.codehaus.jackson.JsonGenerator;
+import sh.calaba.org.codehaus.jackson.map.SerializerProvider;
+import sh.calaba.org.codehaus.jackson.map.TypeSerializer;
+
+/**
+ * Intermediate base class for limited number of scalar types
+ * that should never include type information. These are "native"
+ * types that are default mappings for corresponding JSON scalar
+ * types: {@link java.lang.String}, {@link java.lang.Integer},
+ * {@link java.lang.Double} and {@link java.lang.Boolean}.
+ * 
+ * @since 1.9 (refactored from 'sh.calaba.org.codehaus.jackson.map.StdSerializers#NontTypedScalarSerializer')
+ */
+public abstract class NonTypedScalarSerializerBase<T>
+    extends ScalarSerializerBase<T>
+{
+    protected NonTypedScalarSerializerBase(Class<T> t) {
+        super(t);
+    }
+
+    @Override
+    public final void serializeWithType(T value, JsonGenerator jgen, SerializerProvider provider,
+            TypeSerializer typeSer)
+        throws IOException, JsonGenerationException
+    {
+        // no type info, just regular serialization
+        serialize(value, jgen, provider);            
+    }
+}