calabash-android 0.0.1

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

@@ -0,0 +1,231 @@
+package sh.calaba.org.codehaus.jackson.map.ser.impl;
+
+import sh.calaba.org.codehaus.jackson.map.BeanProperty;
+import sh.calaba.org.codehaus.jackson.map.JsonMappingException;
+import sh.calaba.org.codehaus.jackson.map.JsonSerializer;
+import sh.calaba.org.codehaus.jackson.map.SerializerProvider;
+import sh.calaba.org.codehaus.jackson.type.JavaType;
+
+/**
+ * Helper container used for resolving serializers for dynamic (possibly but not
+ * necessarily polymorphic) properties: properties whose type is not forced
+ * to use dynamic (declared) type and that are not final.
+ * If so, serializer to use can only be established once actual value type is known.
+ * Since this happens a lot unless static typing is forced (or types are final)
+ * this implementation is optimized for efficiency.
+ * Instances are immutable; new instances are created with factory methods: this
+ * is important to ensure correct multi-threaded access.
+ * 
+ * @since 1.7
+ */
+public abstract class PropertySerializerMap
+{
+    /**
+     * Main lookup method. Takes a "raw" type since usage is always from
+     * place where parameterization is fixed such that there can not be
+     * type-parametric variations.
+     */
+    public abstract JsonSerializer<Object> serializerFor(Class<?> type);
+
+    /**
+     * Method called if initial lookup fails; will both find serializer
+     * and construct new map instance if warranted, and return both
+     * @throws JsonMappingException 
+     */
+    public final SerializerAndMapResult findAndAddSerializer(Class<?> type,
+            SerializerProvider provider, BeanProperty property)
+        throws JsonMappingException
+    {
+        JsonSerializer<Object> serializer = provider.findValueSerializer(type, property);
+        return new SerializerAndMapResult(serializer, newWith(type, serializer));
+    }
+
+    public final SerializerAndMapResult findAndAddSerializer(JavaType type,
+            SerializerProvider provider, BeanProperty property)
+        throws JsonMappingException
+    {
+        JsonSerializer<Object> serializer = provider.findValueSerializer(type, property);
+        return new SerializerAndMapResult(serializer, newWith(type.getRawClass(), serializer));
+    }
+
+    public abstract PropertySerializerMap newWith(Class<?> type, JsonSerializer<Object> serializer);
+    
+    public static PropertySerializerMap emptyMap() {
+        return Empty.instance;
+    }
+    
+    /*
+    /**********************************************************
+    /* Helper classes
+    /**********************************************************
+     */
+
+    /**
+     * Value class used for returning tuple that has both serializer
+     * that was retrieved and new map instance
+     */
+    public final static class SerializerAndMapResult
+    {
+        public final JsonSerializer<Object> serializer;
+        public final PropertySerializerMap map;
+        
+        public SerializerAndMapResult(JsonSerializer<Object> serializer,
+                PropertySerializerMap map)
+        {
+            this.serializer = serializer;
+            this.map = map;
+        }
+    }
+
+    /**
+     * Trivial container for bundling type + serializer entries.
+     */
+    private final static class TypeAndSerializer
+    {
+        public final Class<?> type;
+        public final JsonSerializer<Object> serializer;
+
+        public TypeAndSerializer(Class<?> type, JsonSerializer<Object> serializer) {
+            this.type = type;
+            this.serializer = serializer;
+        }
+    }
+
+    /*
+    /**********************************************************
+    /* Implementations
+    /**********************************************************
+     */
+
+    /**
+     * Bogus instance that contains no serializers; used as the default
+     * map with new serializers.
+     */
+    private final static class Empty extends PropertySerializerMap
+    {
+        protected final static Empty instance = new Empty();
+
+        @Override
+        public JsonSerializer<Object> serializerFor(Class<?> type) {
+            return null; // empty, nothing to find
+        }        
+
+        @Override
+        public PropertySerializerMap newWith(Class<?> type, JsonSerializer<Object> serializer) {
+            return new Single(type, serializer);
+        }
+    }
+
+    /**
+     * Map that contains a single serializer; although seemingly silly
+     * this is probably the most commonly used variant because many
+     * theoretically dynamic or polymorphic types just have single
+     * actual type.
+     */
+    private final static class Single extends PropertySerializerMap
+    {
+        private final Class<?> _type;
+        private final JsonSerializer<Object> _serializer;
+
+        public Single(Class<?> type, JsonSerializer<Object> serializer) {
+            _type = type;
+            _serializer = serializer;
+        }
+
+        @Override
+        public JsonSerializer<Object> serializerFor(Class<?> type)
+        {
+            if (type == _type) {
+                return _serializer;
+            }
+            return null;
+        }
+
+        @Override
+        public PropertySerializerMap newWith(Class<?> type, JsonSerializer<Object> serializer) {
+            return new Double(_type, _serializer, type, serializer);
+        }
+    }
+
+    private final static class Double extends PropertySerializerMap
+    {
+        private final Class<?> _type1, _type2;
+        private final JsonSerializer<Object> _serializer1, _serializer2;
+
+        public Double(Class<?> type1, JsonSerializer<Object> serializer1,
+                Class<?> type2, JsonSerializer<Object> serializer2)
+        {
+            _type1 = type1;
+            _serializer1 = serializer1;
+            _type2 = type2;
+            _serializer2 = serializer2;
+        }
+
+        @Override
+        public JsonSerializer<Object> serializerFor(Class<?> type)
+        {
+            if (type == _type1) {
+                return _serializer1;
+            }
+            if (type == _type2) {
+                return _serializer2;
+            }
+            return null;
+        }        
+
+        @Override
+        public PropertySerializerMap newWith(Class<?> type, JsonSerializer<Object> serializer) {
+            // Ok: let's just create generic one
+            TypeAndSerializer[] ts = new TypeAndSerializer[2];
+            ts[0] = new TypeAndSerializer(_type1, _serializer1);
+            ts[1] = new TypeAndSerializer(_type2, _serializer2);
+            return new Multi(ts);
+        }
+    }
+    
+    private final static class Multi extends PropertySerializerMap
+    {
+        /**
+         * Let's limit number of serializers we actually cache; linear
+         * lookup won't scale too well beyond smallish number, and if
+         * we really want to support larger collections should use
+         * a hash map. But it seems unlikely this is a common use
+         * case so for now let's just stop building after hard-coded
+         * limit. 8 sounds like a reasonable stab for now.
+         */
+        private final static int MAX_ENTRIES = 8;
+        
+        private final TypeAndSerializer[] _entries;
+
+        public Multi(TypeAndSerializer[] entries) {
+            _entries = entries;
+        }
+
+        @Override
+        public JsonSerializer<Object> serializerFor(Class<?> type)
+        {
+            for (int i = 0, len = _entries.length; i < len; ++i) {
+                TypeAndSerializer entry = _entries[i];
+                if (entry.type == type) {
+                    return entry.serializer;
+                }
+            }
+            return null;
+        }
+
+        @Override
+        public PropertySerializerMap newWith(Class<?> type, JsonSerializer<Object> serializer)
+        {
+            int len = _entries.length;
+            // Will only grow up to N entries
+            if (len == MAX_ENTRIES) {
+                return this;
+            }
+            // 1.6 has nice resize methods but we are still 1.5
+            TypeAndSerializer[] entries = new TypeAndSerializer[len+1];
+            System.arraycopy(_entries, 0, entries, 0, len);
+            entries[len] = new TypeAndSerializer(type, serializer);
+            return new Multi(entries);
+        }
+    }
+}

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

@@ -0,0 +1,73 @@
+package sh.calaba.org.codehaus.jackson.map.ser.impl;
+
+import java.util.*;
+
+import sh.calaba.org.codehaus.jackson.map.JsonSerializer;
+import sh.calaba.org.codehaus.jackson.map.ser.impl.SerializerCache.TypeKey;
+import sh.calaba.org.codehaus.jackson.type.JavaType;
+
+/**
+ * Optimized lookup table for accessing two types of serializers; typed
+ * and non-typed. Only accessed from a single thread, so no synchronization
+ * needed for accessors.
+ * 
+ * @since 1.7
+ */
+public final class ReadOnlyClassToSerializerMap
+{
+    /**
+     * Actual mappings from type key to serializers
+     */
+    protected final JsonSerializerMap _map;
+
+    /**
+     * We'll reuse key class to avoid unnecessary instantiations; since
+     * this is not shared between threads, we can just reuse single
+     * instance.
+     */
+    protected final TypeKey _cacheKey = new TypeKey(getClass(), false);
+    
+    private ReadOnlyClassToSerializerMap(JsonSerializerMap map)
+    {
+        _map = map;
+    }
+
+    public ReadOnlyClassToSerializerMap instance()
+    {
+        return new ReadOnlyClassToSerializerMap(_map);
+    }
+
+    /**
+     * Factory method for creating the "blueprint" lookup map. Such map
+     * can not be used as is but just shared: to get an actual usable
+     * instance, {@link #instance} has to be called first.
+     */
+    public static ReadOnlyClassToSerializerMap from(HashMap<TypeKey, JsonSerializer<Object>> src)
+    {
+        return new ReadOnlyClassToSerializerMap(new JsonSerializerMap(src));
+    }
+
+    public JsonSerializer<Object> typedValueSerializer(JavaType type)
+    { 
+        _cacheKey.resetTyped(type);
+        return _map.find(_cacheKey);
+    }
+
+    public JsonSerializer<Object> typedValueSerializer(Class<?> cls)
+    { 
+        _cacheKey.resetTyped(cls);
+        return _map.find(_cacheKey);
+    }
+    
+    public JsonSerializer<Object> untypedValueSerializer(Class<?> cls)
+    { 
+        _cacheKey.resetUntyped(cls);
+        return _map.find(_cacheKey);
+    }
+
+    public JsonSerializer<Object> untypedValueSerializer(JavaType type)
+    { 
+        _cacheKey.resetUntyped(type);
+        return _map.find(_cacheKey);
+    }
+}

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

@@ -0,0 +1,304 @@
+package sh.calaba.org.codehaus.jackson.map.ser.impl;
+
+import java.util.*;
+
+import sh.calaba.org.codehaus.jackson.map.JsonMappingException;
+import sh.calaba.org.codehaus.jackson.map.JsonSerializer;
+import sh.calaba.org.codehaus.jackson.map.ResolvableSerializer;
+import sh.calaba.org.codehaus.jackson.map.SerializerProvider;
+import sh.calaba.org.codehaus.jackson.type.JavaType;
+
+/**
+ * Simple cache object that allows for doing 2-level lookups: first level is
+ * by "local" read-only lookup Map (used without locking)
+ * and second backup level is by a shared modifiable HashMap.
+ * The idea is that after a while, most serializers are found from the
+ * local Map (to optimize performance, reduce lock contention),
+ * but that during buildup we can use a shared map to reduce both
+ * number of distinct read-only maps constructed, and number of
+ * serializers constructed.
+ *<p>
+ * Since version 1.5 cache will actually contain three kinds of entries,
+ * based on combination of class pair key. First class in key is for the
+ * type to serialize, and second one is type used for determining how
+ * to resolve value type. One (but not both) of entries can be null.
+ */
+public final class SerializerCache
+{
+    /**
+     * Shared, modifiable map; all access needs to be through synchronized blocks.
+     *<p>
+     * NOTE: keys are of various types (see below for key types), in addition to
+     * basic {@link JavaType} used for "untyped" serializers.
+     */
+    private HashMap<TypeKey, JsonSerializer<Object>> _sharedMap = new HashMap<TypeKey, JsonSerializer<Object>>(64);
+
+    /**
+     * Most recent read-only instance, created from _sharedMap, if any.
+     */
+    private ReadOnlyClassToSerializerMap _readOnlyMap = null;
+
+    public SerializerCache() {
+    }
+
+    /**
+     * Method that can be called to get a read-only instance populated from the
+     * most recent version of the shared lookup Map.
+     */
+    public ReadOnlyClassToSerializerMap getReadOnlyLookupMap()
+    {
+        ReadOnlyClassToSerializerMap m;
+        synchronized (this) {
+            m = _readOnlyMap;
+            if (m == null) {
+                _readOnlyMap = m = ReadOnlyClassToSerializerMap.from(_sharedMap);
+            }
+        }
+        return m.instance();
+    }
+
+    /*
+    /**********************************************************
+    /* Lookup methods for accessing shared (slow) cache
+    /**********************************************************
+     */
+
+    /**
+     * @since 1.4
+     */
+    public synchronized int size() {
+        return _sharedMap.size();
+    }
+    
+    /**
+     * Method that checks if the shared (and hence, synchronized) lookup Map might have
+     * untyped serializer for given type.
+     */
+    public JsonSerializer<Object> untypedValueSerializer(Class<?> type)
+    {
+        synchronized (this) {
+            return _sharedMap.get(new TypeKey(type, false));
+        }
+    }
+
+    /**
+     * @since 1.5
+     */
+    public JsonSerializer<Object> untypedValueSerializer(JavaType type)
+    {
+        synchronized (this) {
+            return _sharedMap.get(new TypeKey(type, false));
+        }
+    }
+
+    public JsonSerializer<Object> typedValueSerializer(JavaType type)
+    {
+        synchronized (this) {
+            return _sharedMap.get(new TypeKey(type, true));
+        }
+    }
+
+    public JsonSerializer<Object> typedValueSerializer(Class<?> cls)
+    {
+        synchronized (this) {
+            return _sharedMap.get(new TypeKey(cls, true));
+        }
+    }
+
+    /*
+    /**********************************************************
+    /* Methods for adding shared serializer instances
+    /**********************************************************
+     */
+    
+    /**
+     * Method called if none of lookups succeeded, and caller had to construct
+     * a serializer. If so, we will update the shared lookup map so that it
+     * can be resolved via it next time.
+     */
+    public void addTypedSerializer(JavaType type, JsonSerializer<Object> ser)
+    {
+        synchronized (this) {
+            if (_sharedMap.put(new TypeKey(type, true), ser) == null) {
+                // let's invalidate the read-only copy, too, to get it updated
+                _readOnlyMap = null;
+            }
+        }
+    }
+
+    public void addTypedSerializer(Class<?> cls, JsonSerializer<Object> ser)
+    {
+        synchronized (this) {
+            if (_sharedMap.put(new TypeKey(cls, true), ser) == null) {
+                // let's invalidate the read-only copy, too, to get it updated
+                _readOnlyMap = null;
+            }
+        }
+    }
+    
+    /**
+     * @since 1.8
+     */
+    public void addAndResolveNonTypedSerializer(Class<?> type, JsonSerializer<Object> ser,
+            SerializerProvider provider)
+        throws JsonMappingException
+    {
+        synchronized (this) {
+            if (_sharedMap.put(new TypeKey(type, false), ser) == null) {
+                // let's invalidate the read-only copy, too, to get it updated
+                _readOnlyMap = null;
+            }
+            /* Finally: some serializers want to do post-processing, after
+             * getting registered (to handle cyclic deps).
+             */
+            /* 14-May-2011, tatu: As per [JACKSON-570], resolving needs to be done
+             *   in synchronized manner; this because while we do need to register
+             *   instance first, we also must keep lock until resolution is complete
+             */
+            if (ser instanceof ResolvableSerializer) {
+                ((ResolvableSerializer) ser).resolve(provider);
+            }
+        }
+    }
+
+    /**
+     * @since 1.8
+     */
+    public void addAndResolveNonTypedSerializer(JavaType type, JsonSerializer<Object> ser,
+            SerializerProvider provider)
+        throws JsonMappingException
+    {
+        synchronized (this) {
+            if (_sharedMap.put(new TypeKey(type, false), ser) == null) {
+                // let's invalidate the read-only copy, too, to get it updated
+                _readOnlyMap = null;
+            }
+            /* Finally: some serializers want to do post-processing, after
+             * getting registered (to handle cyclic deps).
+             */
+            /* 14-May-2011, tatu: As per [JACKSON-570], resolving needs to be done
+             *   in synchronized manner; this because while we do need to register
+             *   instance first, we also must keep lock until resolution is complete
+             */
+            if (ser instanceof ResolvableSerializer) {
+                ((ResolvableSerializer) ser).resolve(provider);
+            }
+        }
+    }
+
+    /**
+     * Method called by StdSerializerProvider#flushCachedSerializers() to
+     * clear all cached serializers
+     */
+    public synchronized void flush() {
+        _sharedMap.clear();
+    }
+
+    /*
+    /**************************************************************
+    /* Helper class(es)
+    /**************************************************************
+     */
+
+    /**
+     * Key that offers two "modes"; one with raw class, as used for
+     * cases were raw class type is available (for example, when using
+     * runtime type); and one with full generics-including.
+     */
+    public final static class TypeKey
+    {
+        protected int _hashCode;
+
+        protected Class<?> _class;
+
+        protected JavaType _type;
+
+        /**
+         * Indicator of whether serializer stored has a type serializer
+         * wrapper around it or not; if not, it is "untyped" serializer;
+         * if it has, it is "typed"
+         */
+        protected boolean _isTyped;
+        
+        public TypeKey(Class<?> key, boolean typed) {
+            _class = key;
+            _type = null;
+            _isTyped = typed;
+            _hashCode = hash(key, typed);
+        }
+
+        public TypeKey(JavaType key, boolean typed) {
+            _type = key;
+            _class = null;
+            _isTyped = typed;
+            _hashCode = hash(key, typed);
+        }
+
+        private final static int hash(Class<?> cls, boolean typed) {
+            int hash = cls.getName().hashCode();
+            if (typed) {
+                ++hash;
+            }
+            return hash;
+        }
+
+        private final static int hash(JavaType type, boolean typed) {
+            int hash = type.hashCode() - 1;
+            if (typed) {
+                --hash;
+            }
+            return hash;
+        }
+        
+        public void resetTyped(Class<?> cls) {
+            _type = null;
+            _class = cls;
+            _isTyped = true;
+            _hashCode = hash(cls, true);
+        }
+
+        public void resetUntyped(Class<?> cls) {
+            _type = null;
+            _class = cls;
+            _isTyped = false;
+            _hashCode = hash(cls, false);
+        }
+        
+        public void resetTyped(JavaType type) {
+            _type = type;
+            _class = null;
+            _isTyped = true;
+            _hashCode = hash(type, true);
+        }
+
+        public void resetUntyped(JavaType type) {
+            _type = type;
+            _class = null;
+            _isTyped = false;
+            _hashCode = hash(type, false);
+        }
+        
+        @Override public final int hashCode() { return _hashCode; }
+
+        @Override public final String toString() {
+            if (_class != null) {
+                return "{class: "+_class.getName()+", typed? "+_isTyped+"}";
+            }
+            return "{type: "+_type+", typed? "+_isTyped+"}";
+        }
+        
+        // note: we assume key is never used for anything other than as map key, so:
+        @Override public final boolean equals(Object o)
+        {
+            if (o == this) return true;
+            TypeKey other = (TypeKey) o;
+            if (other._isTyped == _isTyped) {
+                if (_class != null) {
+                    return other._class == _class;
+                }
+                return _type.equals(other._type);
+            }
+            return false;
+        } 
+    }
+}