calabash-android 0.0.1

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

@@ -0,0 +1,52 @@
+package sh.calaba.org.codehaus.jackson.map.deser;
+
+import sh.calaba.org.codehaus.jackson.map.*;
+
+/**
+ * Interface for providers of {@link ValueInstantiator} instances.
+ * Implemented when an object wants to provide custom value instantiators,
+ * usually to support custom value types with alternate constructors, or
+ * which need specified post-processing after construction but before
+ * binding data.
+ * 
+ * @since 1.9
+ */
+public interface ValueInstantiators
+{
+    /**
+     * Method called to find the {@link ValueInstantiator} to use for creating
+     * instances of specified type during deserialization.
+     * Note that a default value instantiator is always created first and passed;
+     * if an implementation does not want to modify or replace it, it has to return
+     * passed instance as is (returning null is an error)
+     * 
+     * @param config Deserialization configuration in use
+     * @param beanDesc Additional information about POJO type to be instantiated:
+     *    description will always be of type
+     *    {@link sh.calaba.org.codehaus.jackson.map.introspect.BasicBeanDescription} (that is,
+     *    safe to cast to this more specific type)
+     * @param defaultInstantiator Instantiator that will be used if no changes are made;
+     *   passed to allow custom instances to use annotation-provided information
+     *   (note, however, that earlier {@link ValueInstantiators} may have changed it to
+     *   a custom instantiator already)
+     *   
+     * @return Instantiator to use; either <code>defaultInstantiator</code> that was passed,
+     *   or a custom variant; can not be null.
+     */
+    public ValueInstantiator findValueInstantiator(DeserializationConfig config,
+            BeanDescription beanDesc, ValueInstantiator defaultInstantiator);
+
+    /**
+     * Basic "NOP" implementation that can be used as the base class for custom implementations.
+     * Safer to extend (instead of implementing {@link ValueInstantiators}) in case later
+     * Jackson versions add new methods in base interface.
+     */
+    public static class Base implements ValueInstantiators
+    {
+        @Override
+        public ValueInstantiator findValueInstantiator(DeserializationConfig config,
+                BeanDescription beanDesc, ValueInstantiator defaultInstantiator) {
+            return defaultInstantiator;
+        }
+    }
+}

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

@@ -0,0 +1,257 @@
+package sh.calaba.org.codehaus.jackson.map.deser.impl;
+
+import java.util.*;
+
+import sh.calaba.org.codehaus.jackson.map.deser.SettableBeanProperty;
+
+/**
+ * Helper class used for storing mapping from property name to
+ * {@link SettableBeanProperty} instances.
+ *<p>
+ * Note that this class is used instead of generic {@link java.util.HashMap}
+ * is performance: although default implementation is very good for generic
+ * use cases, it can still be streamlined a bit for specific use case
+ * we have.
+ * 
+ * @since 1.7
+ */
+public final class BeanPropertyMap
+{
+    private final Bucket[] _buckets;
+    
+    private final int _hashMask;
+
+    private final int _size;
+    
+    public BeanPropertyMap(Collection<SettableBeanProperty> properties)
+    {
+        _size = properties.size();
+        int bucketCount = findSize(_size);
+        _hashMask = bucketCount-1;
+        Bucket[] buckets = new Bucket[bucketCount];
+        for (SettableBeanProperty property : properties) {
+            String key = property.getName();
+            int index = key.hashCode() & _hashMask;
+            buckets[index] = new Bucket(buckets[index], key, property);
+        }
+        _buckets = buckets;
+    }
+
+    public void assignIndexes()
+    {
+        // order is arbitrary, but stable:
+        int index = 0;
+        for (Bucket bucket : _buckets) {
+            while (bucket != null) {
+                bucket.value.assignIndex(index++);
+                bucket = bucket.next;
+            }
+        }
+    }
+    
+    private final static int findSize(int size)
+    {
+        // For small enough results (32 or less), we'll require <= 50% fill rate; otherwise 80%
+        int needed = (size <= 32) ? (size + size) : (size + (size >> 2));
+        int result = 2;
+        while (result < needed) {
+            result += result;
+        }
+        return result;
+    }
+    
+    /*
+    /**********************************************************
+    /* Public API
+    /**********************************************************
+     */
+
+    public int size() { return _size; }
+
+    /**
+     * Accessor for traversing over all contained properties.
+     */
+    public Iterator<SettableBeanProperty> allProperties() {
+        return new IteratorImpl(_buckets);
+    }
+    
+    public SettableBeanProperty find(String key)
+    {
+        int index = key.hashCode() & _hashMask;
+        Bucket bucket = _buckets[index];
+        // Let's unroll first lookup since that is null or match in 90+% cases
+        if (bucket == null) {
+            return null;
+        }
+        // Primarily we do just identity comparison as keys should be interned
+        if (bucket.key == key) {
+            return bucket.value;
+        }
+        while ((bucket = bucket.next) != null) {
+            if (bucket.key == key) {
+                return bucket.value;
+            }
+        }
+        // Do we need fallback for non-interned Strings?
+        return _findWithEquals(key, index);
+    }
+
+    /**
+     * Specialized method that can be used to replace an existing entry
+     * (note: entry MUST exist; otherwise exception is thrown) with
+     * specified replacement.
+     */
+    public void replace(SettableBeanProperty property)
+    {
+        String name = property.getName();
+        int index = name.hashCode() & (_buckets.length-1);
+
+        /* This is bit tricky just because buckets themselves
+         * are immutable, so we need to recreate the chain. Fine.
+         */
+        Bucket tail = null;
+        boolean found = false;
+
+        
+        for (Bucket bucket = _buckets[index]; bucket != null; bucket = bucket.next) {
+            // match to remove?
+            if (!found && bucket.key.equals(name)) {
+                found = true;
+            } else {
+                tail = new Bucket(tail, bucket.key, bucket.value);
+            }
+        }
+        // Not finding specified entry is error, so:
+        if (!found) {
+            throw new NoSuchElementException("No entry '"+property+"' found, can't replace");
+        }
+        /* So let's attach replacement in front: useful also because
+         * it allows replacement even when iterating over entries
+         */
+        _buckets[index] = new Bucket(tail, name, property);
+    }
+
+    /**
+     * Specialized method for removing specified existing entry.
+     * NOTE: entry MUST exist, otherwise an exception is thrown.
+     * 
+     * @since 1.9
+     */
+    public void remove(SettableBeanProperty property)
+    {
+        // Mostly this is the same as code with 'replace', just bit simpler...
+        String name = property.getName();
+        int index = name.hashCode() & (_buckets.length-1);
+        Bucket tail = null;
+        boolean found = false;
+        // slightly complex just because chain is immutable, must recreate
+        for (Bucket bucket = _buckets[index]; bucket != null; bucket = bucket.next) {
+            // match to remove?
+            if (!found && bucket.key.equals(name)) {
+                found = true;
+            } else {
+                tail = new Bucket(tail, bucket.key, bucket.value);
+            }
+        }
+        if (!found) { // must be found
+            throw new NoSuchElementException("No entry '"+property+"' found, can't remove");
+        }
+        _buckets[index] = tail;
+    }
+    
+    /*
+    /**********************************************************
+    /* Helper methods
+    /**********************************************************
+     */
+    
+    private SettableBeanProperty _findWithEquals(String key, int index)
+    {
+        Bucket bucket = _buckets[index];
+        while (bucket != null) {
+            if (key.equals(bucket.key)) {
+                return bucket.value;
+            }
+            bucket = bucket.next;
+        }
+        return null;
+    }
+
+    /*
+    /**********************************************************
+    /* Helper beans
+    /**********************************************************
+     */
+    
+    private final static class Bucket
+    {
+        public final Bucket next;
+        public final String key;
+        public final SettableBeanProperty value;
+        
+        public Bucket(Bucket next, String key, SettableBeanProperty value)
+        {
+            this.next = next;
+            this.key = key;
+            this.value = value;
+        }
+    }
+
+    private final static class IteratorImpl implements Iterator<SettableBeanProperty>
+    {
+        /**
+         * Buckets of the map
+         */
+        private final Bucket[] _buckets;
+
+        /**
+         * Bucket that contains next value to return (if any); null if nothing more to iterate
+         */
+        private Bucket _currentBucket;
+
+        /**
+         * Index of the next bucket in bucket array to check.
+         */
+        private int _nextBucketIndex;
+        
+        public IteratorImpl(Bucket[] buckets) {
+            _buckets = buckets;
+            // need to initialize to point to first entry...
+            int i = 0;
+            for (int len = _buckets.length; i < len; ) {
+                Bucket b = _buckets[i++];
+                if (b != null) {
+                    _currentBucket = b;
+                    break;
+                }
+            }
+            _nextBucketIndex = i;
+        }
+
+        @Override
+        public boolean hasNext() {
+            return _currentBucket != null;
+        }
+
+        @Override
+        public SettableBeanProperty next()
+        {
+            Bucket curr = _currentBucket;
+            if (curr == null) { // sanity check
+                throw new NoSuchElementException();
+            }
+            // need to advance, too
+            Bucket b = curr.next;
+            while (b == null && _nextBucketIndex < _buckets.length) {
+                b = _buckets[_nextBucketIndex++];
+            }
+            _currentBucket = b;
+            return curr.value;
+        }
+
+        @Override
+        public void remove() {
+            throw new UnsupportedOperationException();
+        }
+    }
+}

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

@@ -0,0 +1,141 @@
+package sh.calaba.org.codehaus.jackson.map.deser.impl;
+
+import java.lang.reflect.Member;
+import java.util.*;
+
+import sh.calaba.org.codehaus.jackson.map.DeserializationConfig;
+import sh.calaba.org.codehaus.jackson.map.deser.ValueInstantiator;
+import sh.calaba.org.codehaus.jackson.map.deser.std.StdValueInstantiator;
+import sh.calaba.org.codehaus.jackson.map.introspect.*;
+import sh.calaba.org.codehaus.jackson.map.type.TypeBindings;
+import sh.calaba.org.codehaus.jackson.map.util.ClassUtil;
+import sh.calaba.org.codehaus.jackson.type.JavaType;
+
+/**
+ * Container class for storing information on creators (based on annotations,
+ * visibility), to be able to build actual instantiator later on.
+ */
+public class CreatorCollector
+{
+    /// Type of bean being created
+    final BasicBeanDescription _beanDesc;
+
+    final boolean _canFixAccess;
+
+    protected AnnotatedConstructor _defaultConstructor;
+    
+    protected AnnotatedWithParams _stringCreator, _intCreator, _longCreator;
+    protected AnnotatedWithParams _doubleCreator, _booleanCreator;
+
+    protected AnnotatedWithParams _delegateCreator;
+    
+    protected AnnotatedWithParams _propertyBasedCreator;
+    protected CreatorProperty[] _propertyBasedArgs = null;
+
+    /*
+    /**********************************************************
+    /* Life-cycle
+    /**********************************************************
+     */
+    
+    public CreatorCollector(BasicBeanDescription beanDesc, boolean canFixAccess)
+    {
+        _beanDesc = beanDesc;
+        _canFixAccess = canFixAccess;
+    }
+
+    /**
+     * @since 1.9.0
+     */
+    public ValueInstantiator constructValueInstantiator(DeserializationConfig config)
+    {
+        StdValueInstantiator inst = new StdValueInstantiator(config, _beanDesc.getType());
+
+        JavaType delegateType;
+
+        if (_delegateCreator == null) {
+            delegateType = null;
+        } else {
+            TypeBindings bindings = _beanDesc.bindingsForBeanType();
+            delegateType = bindings.resolveType(_delegateCreator.getParameterType(0));
+        }
+        
+        inst.configureFromObjectSettings(_defaultConstructor,
+                _delegateCreator, delegateType,
+                _propertyBasedCreator, _propertyBasedArgs);
+        inst.configureFromStringCreator(_stringCreator);
+        inst.configureFromIntCreator(_intCreator);
+        inst.configureFromLongCreator(_longCreator);
+        inst.configureFromDoubleCreator(_doubleCreator);
+        inst.configureFromBooleanCreator(_booleanCreator);
+        return inst;
+    }
+    
+    /*
+    /**********************************************************
+    /* Setters
+    /**********************************************************
+     */
+
+    public void setDefaultConstructor(AnnotatedConstructor ctor) {
+        _defaultConstructor = ctor;
+    }
+    
+    public void addStringCreator(AnnotatedWithParams creator) {
+        _stringCreator = verifyNonDup(creator, _stringCreator, "String");
+    }
+    public void addIntCreator(AnnotatedWithParams creator) {
+        _intCreator = verifyNonDup(creator, _intCreator, "int");
+    }
+    public void addLongCreator(AnnotatedWithParams creator) {
+        _longCreator = verifyNonDup(creator, _longCreator, "long");
+    }
+    public void addDoubleCreator(AnnotatedWithParams creator) {
+        _doubleCreator = verifyNonDup(creator, _doubleCreator, "double");
+    }
+    public void addBooleanCreator(AnnotatedWithParams creator) {
+        _booleanCreator = verifyNonDup(creator, _booleanCreator, "boolean");
+    }
+
+    public void addDelegatingCreator(AnnotatedWithParams creator) {
+        _delegateCreator = verifyNonDup(creator, _delegateCreator, "delegate");
+    }
+    
+    public void addPropertyCreator(AnnotatedWithParams creator, CreatorProperty[] properties)
+    {
+        _propertyBasedCreator = verifyNonDup(creator, _propertyBasedCreator, "property-based");
+        // [JACKSON-470] Better ensure we have no duplicate names either...
+        if (properties.length > 1) {
+            HashMap<String,Integer> names = new HashMap<String,Integer>();
+            for (int i = 0, len = properties.length; i < len; ++i) {
+                String name = properties[i].getName();
+                Integer old = names.put(name, Integer.valueOf(i));
+                if (old != null) {
+                    throw new IllegalArgumentException("Duplicate creator property \""+name+"\" (index "+old+" vs "+i+")");
+                }
+            }
+        }
+        _propertyBasedArgs = properties;
+    }
+
+    /*
+    /**********************************************************
+    /* Helper methods
+    /**********************************************************
+     */
+
+    protected AnnotatedWithParams verifyNonDup(AnnotatedWithParams newOne, AnnotatedWithParams oldOne,
+            String type)
+    {
+        if (oldOne != null) {
+            // important: ok to override factory with constructor; but not within same type, so:
+            if (oldOne.getClass() == newOne.getClass()) {
+                throw new IllegalArgumentException("Conflicting "+type+" creators: already had "+oldOne+", encountered "+newOne);
+            }
+        }
+        if (_canFixAccess) {
+            ClassUtil.checkAndFixAccess((Member) newOne.getAnnotated());
+        }
+        return newOne;
+    }
+}