calabash-android 0.4.7.pre4 → 0.4.7.pre6

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

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

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

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