calabash-android 0.0.1

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

@@ -0,0 +1,372 @@
+package sh.calaba.org.codehaus.jackson.map.ser;
+
+import java.io.IOException;
+import java.lang.reflect.Type;
+import java.math.BigDecimal;
+import java.math.BigInteger;
+
+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.std.NonTypedScalarSerializerBase;
+import sh.calaba.org.codehaus.jackson.map.ser.std.ScalarSerializerBase;
+
+/**
+ * Container class for serializers used for handling standard JDK-provided types.
+ * 
+ * @since 1.5
+ */
+public class StdSerializers
+{
+    protected StdSerializers() { }
+    
+    /*
+    /**********************************************************
+    /* Concrete serializers, non-numeric primitives, Strings, Classes
+    /**********************************************************
+     */
+    
+    /**
+     * Serializer used for primitive boolean, as well as java.util.Boolean
+     * wrapper type.
+     *<p>
+     * Since this is one of "native" types, no type information is ever
+     * included on serialization (unlike for most scalar types as of 1.5)
+     */
+    @JacksonStdImpl
+    public final static class BooleanSerializer
+        extends NonTypedScalarSerializerBase<Boolean>
+    {
+        /**
+         * Whether type serialized is primitive (boolean) or wrapper
+         * (java.lang.Boolean); if true, former, if false, latter.
+         */
+        final boolean _forPrimitive;
+    
+        public BooleanSerializer(boolean forPrimitive)
+        {
+            super(Boolean.class);
+            _forPrimitive = forPrimitive;
+        }
+    
+        @Override
+        public void serialize(Boolean value, JsonGenerator jgen, SerializerProvider provider)
+            throws IOException, JsonGenerationException
+        {
+            jgen.writeBoolean(value.booleanValue());
+        }
+    
+        @Override
+        public JsonNode getSchema(SerializerProvider provider, Type typeHint)
+        {
+            /*(ryan) it may not, in fact, be optional, but there's no way
+             * to tell whether we're referencing a boolean or java.lang.Boolean.
+             */
+            /* 27-Jun-2009, tatu: Now we can tell, after passing
+             *   'forPrimitive' flag...
+             */
+            return createSchemaNode("boolean", !_forPrimitive);
+        }
+    }
+
+    /**
+     * @deprecated Since 1.9, use {@link sh.calaba.org.codehaus.jackson.map.ser.std.StringSerializer} instead
+     */
+    @Deprecated
+    @JacksonStdImpl
+    public final static class StringSerializer
+        extends NonTypedScalarSerializerBase<String>
+    {
+        public StringSerializer() { super(String.class); }
+
+        @Override
+        public void serialize(String value, JsonGenerator jgen, SerializerProvider provider)
+            throws IOException, JsonGenerationException
+        {
+            jgen.writeString(value);
+        }
+
+        @Override
+        public JsonNode getSchema(SerializerProvider provider, Type typeHint)
+        {
+            return createSchemaNode("string", true);
+        }
+    }
+
+    /*
+    /**********************************************************
+    /* Concrete serializers, numerics
+    /**********************************************************
+     */
+
+    /**
+     * This is the special serializer for regular {@link java.lang.Integer}s
+     * (and primitive ints)
+     *<p>
+     * Since this is one of "native" types, no type information is ever
+     * included on serialization (unlike for most scalar types as of 1.5)
+     */
+    @JacksonStdImpl
+    public final static class IntegerSerializer
+        extends NonTypedScalarSerializerBase<Integer>
+    {
+        public IntegerSerializer() { super(Integer.class); }
+    
+        @Override
+        public void serialize(Integer value, JsonGenerator jgen, SerializerProvider provider)
+            throws IOException, JsonGenerationException
+        {
+            jgen.writeNumber(value.intValue());
+        }
+    
+        @Override
+        public JsonNode getSchema(SerializerProvider provider, Type typeHint)
+        {
+            return createSchemaNode("integer", true);
+        }
+    }
+
+    /**
+     * Similar to {@link IntegerSerializer}, but will not cast to Integer:
+     * instead, cast is to {@link java.lang.Number}, and conversion is
+     * by calling {@link java.lang.Number#intValue}.
+     */
+    @JacksonStdImpl
+    public final static class IntLikeSerializer
+        extends ScalarSerializerBase<Number>
+    {
+        final static IntLikeSerializer instance = new IntLikeSerializer();
+    
+        public IntLikeSerializer() { super(Number.class); }
+        
+        @Override
+        public void serialize(Number value, JsonGenerator jgen, SerializerProvider provider)
+            throws IOException, JsonGenerationException
+        {
+            jgen.writeNumber(value.intValue());
+        }
+    
+        @Override
+        public JsonNode getSchema(SerializerProvider provider, Type typeHint)
+        {
+            return createSchemaNode("integer", true);
+        }
+    }
+
+    @JacksonStdImpl
+    public final static class LongSerializer
+        extends ScalarSerializerBase<Long>
+    {
+        final static LongSerializer instance = new LongSerializer();
+    
+        public LongSerializer() { super(Long.class); }
+        
+        @Override
+        public void serialize(Long value, JsonGenerator jgen, SerializerProvider provider)
+            throws IOException, JsonGenerationException
+        {
+            jgen.writeNumber(value.longValue());
+        }
+    
+        @Override
+        public JsonNode getSchema(SerializerProvider provider, Type typeHint)
+        {
+            return createSchemaNode("number", true);
+        }
+    }
+    
+    @JacksonStdImpl
+    public final static class FloatSerializer
+        extends ScalarSerializerBase<Float>
+    {
+        final static FloatSerializer instance = new FloatSerializer();
+    
+        public FloatSerializer() { super(Float.class); }
+        
+        @Override
+        public void serialize(Float value, JsonGenerator jgen, SerializerProvider provider)
+            throws IOException, JsonGenerationException
+        {
+            jgen.writeNumber(value.floatValue());
+        }
+    
+        @Override
+        public JsonNode getSchema(SerializerProvider provider, Type typeHint)
+        {
+            return createSchemaNode("number", true);
+        }
+    }
+
+    /**
+     * This is the special serializer for regular {@link java.lang.Double}s
+     * (and primitive doubles)
+     *<p>
+     * Since this is one of "native" types, no type information is ever
+     * included on serialization (unlike for most scalar types as of 1.5)
+     */
+    @JacksonStdImpl
+    public final static class DoubleSerializer
+        extends NonTypedScalarSerializerBase<Double>
+    {
+        final static DoubleSerializer instance = new DoubleSerializer();
+    
+        public DoubleSerializer() { super(Double.class); }
+    
+        @Override
+        public void serialize(Double value, JsonGenerator jgen, SerializerProvider provider)
+            throws IOException, JsonGenerationException
+        {
+            jgen.writeNumber(value.doubleValue());
+        }
+    
+        @Override
+        public JsonNode getSchema(SerializerProvider provider, Type typeHint)
+        {
+            return createSchemaNode("number", true);
+        }
+    }
+    
+    /**
+     * As a fallback, we may need to use this serializer for other
+     * types of {@link Number}s (custom types).
+     */
+    @JacksonStdImpl
+    public final static class NumberSerializer
+        extends ScalarSerializerBase<Number>
+    {
+        public final static NumberSerializer instance = new NumberSerializer();
+    
+        public NumberSerializer() { super(Number.class); }
+    
+        @Override
+        public void serialize(Number value, JsonGenerator jgen, SerializerProvider provider)
+            throws IOException, JsonGenerationException
+        {
+            // As per [JACKSON-423], handling for BigInteger and BigDecimal was missing!
+            if (value instanceof BigDecimal) {
+                jgen.writeNumber((BigDecimal) value);
+            } else if (value instanceof BigInteger) {
+                jgen.writeNumber((BigInteger) value);
+                
+            /* These shouldn't match (as there are more specific ones),
+             * but just to be sure:
+             */
+            } else if (value instanceof Integer) {
+                jgen.writeNumber(value.intValue());
+            } else if (value instanceof Long) {
+                jgen.writeNumber(value.longValue());
+            } else if (value instanceof Double) {
+                jgen.writeNumber(value.doubleValue());
+            } else if (value instanceof Float) {
+                jgen.writeNumber(value.floatValue());
+            } else if ((value instanceof Byte) || (value instanceof Short)) {
+                jgen.writeNumber(value.intValue()); // doesn't need to be cast to smaller numbers
+            } else {
+                // We'll have to use fallback "untyped" number write method
+                jgen.writeNumber(value.toString());
+            }
+        }
+    
+        @Override
+        public JsonNode getSchema(SerializerProvider provider, Type typeHint)
+        {
+            return createSchemaNode("number", true);
+        }
+    }
+
+    /*
+    /**********************************************************
+    /* Serializers for JDK date/time data types
+    /**********************************************************
+     */
+
+    /**
+     * @deprecated Since 1.9, use {@link sh.calaba.org.codehaus.jackson.map.ser.std.DateSerializer} instead
+     */
+    @JacksonStdImpl
+    @Deprecated
+    public final static class CalendarSerializer
+        extends sh.calaba.org.codehaus.jackson.map.ser.std.CalendarSerializer { }
+
+    /**
+     * @deprecated Since 1.9, use {@link sh.calaba.org.codehaus.jackson.map.ser.std.DateSerializer} instead
+     */
+    @Deprecated
+    @JacksonStdImpl
+    public final static class UtilDateSerializer
+        extends sh.calaba.org.codehaus.jackson.map.ser.std.DateSerializer {
+        
+    }
+
+    /**
+     * Compared to regular {@link UtilDateSerializer}, we do use String
+     * representation here. Why? Basically to truncate of time part, since
+     * that should not be used by plain SQL date.
+     */
+    @JacksonStdImpl
+    public final static class SqlDateSerializer
+        extends ScalarSerializerBase<java.sql.Date>
+    {
+        public SqlDateSerializer() { super(java.sql.Date.class); }
+
+        @Override
+        public void serialize(java.sql.Date value, JsonGenerator jgen, SerializerProvider provider)
+            throws IOException, JsonGenerationException
+        {
+            jgen.writeString(value.toString());
+        }
+
+        @Override
+        public JsonNode getSchema(SerializerProvider provider, Type typeHint)
+        {
+            //todo: (ryan) add a format for the date in the schema?
+            return createSchemaNode("string", true);
+        }
+    }
+
+    @JacksonStdImpl
+    public final static class SqlTimeSerializer
+        extends ScalarSerializerBase<java.sql.Time>
+    {
+        public SqlTimeSerializer() { super(java.sql.Time.class); }
+
+        @Override
+        public void serialize(java.sql.Time value, JsonGenerator jgen, SerializerProvider provider)
+            throws IOException, JsonGenerationException
+        {
+            jgen.writeString(value.toString());
+        }
+
+        @Override
+        public JsonNode getSchema(SerializerProvider provider, Type typeHint)
+        {
+            return createSchemaNode("string", true);
+        }
+    }
+
+    
+    /*
+    /**********************************************************
+    / Other serializers
+    /**********************************************************
+     */
+
+    /**
+     * @deprecated Since 1.9, use {@link sh.calaba.org.codehaus.jackson.map.ser.std.DateSerializer} instead
+     */
+    @Deprecated
+    @JacksonStdImpl
+    public final static class SerializableSerializer
+        extends sh.calaba.org.codehaus.jackson.map.ser.std.SerializableSerializer { }
+
+    /**
+     * @deprecated Since 1.9, use {@link sh.calaba.org.codehaus.jackson.map.ser.std.DateSerializer} instead
+     */
+    @Deprecated
+    @JacksonStdImpl
+    public final static class SerializableWithTypeSerializer
+        extends sh.calaba.org.codehaus.jackson.map.ser.std.SerializableWithTypeSerializer {
+    }
+}

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

@@ -0,0 +1,14 @@
+package sh.calaba.org.codehaus.jackson.map.ser;
+
+import sh.calaba.org.codehaus.jackson.map.annotate.JacksonStdImpl;
+
+/**
+ * @deprecated Since 1.9 use {@link sh.calaba.org.codehaus.jackson.map.ser.std.ToStringSerializer}
+ */
+@Deprecated
+@JacksonStdImpl
+public final class ToStringSerializer
+    extends sh.calaba.org.codehaus.jackson.map.ser.std.ToStringSerializer
+{
+    public final static ToStringSerializer instance = new ToStringSerializer();
+}

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

@@ -0,0 +1,43 @@
+package sh.calaba.org.codehaus.jackson.map.ser.impl;
+
+import java.io.IOException;
+import java.lang.reflect.Type;
+
+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.JsonMappingException;
+import sh.calaba.org.codehaus.jackson.map.SerializerProvider;
+import sh.calaba.org.codehaus.jackson.map.ser.std.SerializerBase;
+
+/**
+ * Special bogus "serializer" that will throw
+ * {@link JsonGenerationException} if its {@link #serialize}
+ * gets invoked. Most commonly registered as handler for unknown types,
+ * as well as for catching unintended usage (like trying to use null
+ * as Map/Object key).
+ */
+public final class FailingSerializer
+    extends SerializerBase<Object>
+{
+    final String _msg;
+    
+    public FailingSerializer(String msg) {
+        super(Object.class);
+        _msg = msg;
+    }
+    
+    @Override
+    public void serialize(Object value, JsonGenerator jgen, SerializerProvider provider)
+        throws IOException, JsonGenerationException
+    {
+        throw new JsonGenerationException(_msg);
+    }
+
+    @Override
+    public JsonNode getSchema(SerializerProvider provider, Type typeHint)
+        throws JsonMappingException
+    {
+        return null;
+    }
+}

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

@@ -0,0 +1,93 @@
+package sh.calaba.org.codehaus.jackson.map.ser.impl;
+
+import java.util.Map;
+
+import sh.calaba.org.codehaus.jackson.map.JsonSerializer;
+import sh.calaba.org.codehaus.jackson.map.ser.impl.SerializerCache.TypeKey;
+
+/**
+ * Specialized read-only map used for storing and accessing serializers by type.
+ * 
+ * @since 1.7
+ */
+public class JsonSerializerMap
+{
+    private final Bucket[] _buckets;
+
+    private final int _size;
+    
+    public JsonSerializerMap(Map<TypeKey,JsonSerializer<Object>> serializers)
+    {
+        int size = findSize(serializers.size());
+        _size = size;
+        int hashMask = (size-1);
+        Bucket[] buckets = new Bucket[size];
+        for (Map.Entry<TypeKey,JsonSerializer<Object>> entry : serializers.entrySet()) {
+            TypeKey key = entry.getKey();
+            int index = key.hashCode() & hashMask;
+            buckets[index] = new Bucket(buckets[index], key, entry.getValue());
+        }
+        _buckets = buckets;
+    }
+    
+    private final static int findSize(int size)
+    {
+        // For small enough results (64 or less), we'll require <= 50% fill rate; otherwise 80%
+        int needed = (size <= 64) ? (size + size) : (size + (size >> 2));
+        int result = 8;
+        while (result < needed) {
+            result += result;
+        }
+        return result;
+    }
+
+    /*
+    /**********************************************************
+    /* Public API
+    /**********************************************************
+     */
+
+    public int size() { return _size; }
+    
+    public JsonSerializer<Object> find(TypeKey key)
+    {
+        int index = key.hashCode() & (_buckets.length-1);
+        Bucket bucket = _buckets[index];
+        /* Ok let's actually try unrolling loop slightly as this shows up in profiler;
+         * and also because in vast majority of cases first entry is either null
+         * or matches.
+         */
+        if (bucket == null) {
+            return null;
+        }
+        if (key.equals(bucket.key)) {
+            return bucket.value;
+        }
+        while ((bucket = bucket.next) != null) {
+            if (key.equals(bucket.key)) {
+                return bucket.value;
+            }
+        }
+        return null;
+    }
+
+    /*
+    /**********************************************************
+    /* Helper beans
+    /**********************************************************
+     */
+    
+    private final static class Bucket
+    {
+        public final TypeKey key;
+        public final JsonSerializer<Object> value;
+        public final Bucket next;
+        
+        public Bucket(Bucket next, TypeKey key, JsonSerializer<Object> value)
+        {
+            this.next = next;
+            this.key = key;
+            this.value = value;
+        }
+    }
+}