testautoa 0.4.0.pre16

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

@@ -0,0 +1,280 @@
+package sh.calaba.org.codehaus.jackson.map.deser;
+
+import java.io.IOException;
+
+import sh.calaba.org.codehaus.jackson.JsonProcessingException;
+import sh.calaba.org.codehaus.jackson.map.JsonMappingException;
+import sh.calaba.org.codehaus.jackson.map.introspect.AnnotatedWithParams;
+import sh.calaba.org.codehaus.jackson.type.JavaType;
+
+/**
+ * Class that defines simple API implemented by objects that create value
+ * instances.  Some or all of properties of value instances may 
+ * be initialized by instantiator, rest being populated by deserializer,
+ * to which value instance is passed.
+ * Since different kinds of JSON values (structured and scalar)
+ * may be bound to Java values, in some cases instantiator
+ * fully defines resulting value; this is the case when JSON value
+ * is a scalar value (String, number, boolean).
+ *<p>
+ * Note that this type is not parameterized (even though it would seemingly
+ * make sense), because such type information can not be use effectively
+ * during runtime: access is always using either wildcard type, or just
+ * basic {@link java.lang.Object}; and so adding type parameter seems
+ * like unnecessary extra work.
+ *<p>
+ * Actual implementations are strongly recommended to be based on
+ * {@link sh.calaba.org.codehaus.jackson.map.deser.std.StdValueInstantiator}
+ * which implements all methods, and as such will be compatible
+ * across versions even if new methods were added to this interface.
+ * 
+ * @since 1.9
+ */
+public abstract class ValueInstantiator
+{
+    /*
+    /**********************************************************
+    /* Metadata accessors
+    /**********************************************************
+     */
+
+    /**
+     * Method that returns description of the value type this instantiator
+     * handles. Used for error messages, diagnostics.
+     */
+    public abstract String getValueTypeDesc();
+
+    /**
+     * Method that will return true if any of <code>canCreateXxx</code> method
+     * returns true: that is, if there is any way that an instance could
+     * be created.
+     */
+    public boolean canInstantiate() {
+        return
+             canCreateUsingDefault()
+             || canCreateUsingDelegate()
+             || canCreateFromObjectWith()
+             || canCreateFromString()
+             || canCreateFromInt()
+             || canCreateFromLong()
+             || canCreateFromDouble()
+             || canCreateFromBoolean()
+             ;
+    }    
+    
+    /**
+     * Method that can be called to check whether a String-based creator
+     * is available for this instantiator
+     */
+    public boolean canCreateFromString() {
+        return false;
+    }
+
+    /**
+     * Method that can be called to check whether an integer (int, Integer) based
+     * creator is available to use (to call {@link #createFromInt}).
+     */
+    public boolean canCreateFromInt() {
+        return false;
+    }
+
+    /**
+     * Method that can be called to check whether a long (long, Long) based
+     * creator is available to use (to call {@link #createFromLong}).
+     */
+    public boolean canCreateFromLong() {
+        return false;
+    }
+
+    /**
+     * Method that can be called to check whether a double (double / Double) based
+     * creator is available to use (to call {@link #createFromDouble}).
+     */
+    public boolean canCreateFromDouble() {
+        return false;
+    }
+
+    /**
+     * Method that can be called to check whether a double (boolean / Boolean) based
+     * creator is available to use (to call {@link #createFromDouble}).
+     */
+    public boolean canCreateFromBoolean() {
+        return false;
+    }
+    
+    /**
+     * Method that can be called to check whether a default creator (constructor,
+     * or no-arg static factory method)
+     * is available for this instantiator
+     */
+    public boolean canCreateUsingDefault() {
+        return getDefaultCreator() != null;
+    }
+
+    /**
+     * Method that can be called to check whether a delegate-based creator (single-arg
+     * constructor or factory method)
+     * is available for this instantiator
+     */
+    public boolean canCreateUsingDelegate() {
+        return getDelegateType() != null;
+    }
+
+    /**
+     * Method that can be called to check whether a property-based creator
+     * (argument-taking constructor or factory method)
+     * is available to instantiate values from JSON Object
+     */
+    public boolean canCreateFromObjectWith() {
+        return false;
+    }
+
+    /**
+     * Method called to determine types of instantiation arguments
+     * to use when creating instances with creator arguments
+     * (when {@link #canCreateFromObjectWith()} returns  true).
+     * These arguments are bound from JSON, using specified
+     * property types to locate deserializers.
+     *<p>
+     * NOTE: all properties will be of type
+     * {@link sh.calaba.org.codehaus.jackson.map.deser.impl.CreatorProperty}.
+     */
+    public SettableBeanProperty[] getFromObjectArguments() {
+        return null;
+    }
+
+    /**
+     * Method that can be used to determine what is the type of delegate
+     * type to use, if any; if no delegates are used, will return null.
+     * If non-null type is returned, deserializer will bind JSON into
+     * specified type (using standard deserializer for that type), and
+     * pass that to instantiator.
+     */
+    public JavaType getDelegateType() {
+        return null;
+    }
+    
+    /*
+    /**********************************************************
+    /* Instantiation methods for JSON Object
+    /**********************************************************
+     */
+
+    /**
+     * Method called to create value instance from a JSON value when
+     * no data needs to passed to creator (constructor, factory method);
+     * typically this will call the default constructor of the value object.
+     * It will only be used if more specific creator methods are not
+     * applicable; hence "default".
+     *<p>
+     * This method is called if {@link #getFromObjectArguments} returns
+     * null or empty List.
+     */
+    public Object createUsingDefault()
+        throws IOException, JsonProcessingException {
+        throw new JsonMappingException("Can not instantiate value of type "
+                +getValueTypeDesc()+"; no default creator found");
+    }
+
+    /**
+     * Method called to create value instance from JSON Object when
+     * instantiation arguments are passed; this is done, for example when passing information
+     * specified with "Creator" annotations.
+     *<p>
+     * This method is called if {@link #getFromObjectArguments} returns
+     * a non-empty List of arguments.
+     */
+    public Object createFromObjectWith(Object[] args)
+        throws IOException, JsonProcessingException {
+        throw new JsonMappingException("Can not instantiate value of type "
+                +getValueTypeDesc()+" with arguments");
+    }
+
+    /**
+     * Method to called to create value instance from JSON Object using
+     * an intermediate "delegate" value to pass to createor method
+     */
+    public Object createUsingDelegate(Object delegate)
+        throws IOException, JsonProcessingException
+    {
+        throw new JsonMappingException("Can not instantiate value of type "
+                +getValueTypeDesc()+" using delegate");
+    }
+    
+    /*
+    /**********************************************************
+    /* Instantiation methods for JSON scalar types
+    /* (String, Number, Boolean)
+    /**********************************************************
+     */
+    
+    public Object createFromString(String value) throws IOException, JsonProcessingException {
+        throw new JsonMappingException("Can not instantiate value of type "
+                +getValueTypeDesc()+" from JSON String");
+    }
+    
+    public Object createFromInt(int value) throws IOException, JsonProcessingException {
+        throw new JsonMappingException("Can not instantiate value of type "
+                +getValueTypeDesc()+" from JSON int number");
+    }
+
+    public Object createFromLong(long value) throws IOException, JsonProcessingException {
+        throw new JsonMappingException("Can not instantiate value of type "
+                +getValueTypeDesc()+" from JSON long number");
+    }
+
+    public Object createFromDouble(double value) throws IOException, JsonProcessingException {
+        throw new JsonMappingException("Can not instantiate value of type "
+                +getValueTypeDesc()+" from JSON floating-point number");
+    }
+    
+    public Object createFromBoolean(boolean value) throws IOException, JsonProcessingException {
+        throw new JsonMappingException("Can not instantiate value of type "
+                +getValueTypeDesc()+" from JSON boolean value");
+    }
+
+    /*
+    /**********************************************************
+    /* Accessors for underlying creator objects (optional)
+    /**********************************************************
+     */
+
+    /**
+     * Method that can be called to try to access member (constructor,
+     * static factory method) that is used as the "default creator"
+     * (creator that is called without arguments; typically default
+     * [zero-argument] constructor of the type).
+     * Note that implementations not required to return actual object
+     * they use (or, they may use some other instantiation) method.
+     * That is, even if {@link #canCreateUsingDefault()} returns true,
+     * this method may return null .
+     */
+    public AnnotatedWithParams getDefaultCreator() {
+        return null;
+    }
+    
+    /**
+     * Method that can be called to try to access member (constructor,
+     * static factory method) that is used as the "delegate creator".
+     * Note that implementations not required to return actual object
+     * they use (or, they may use some other instantiation) method.
+     * That is, even if {@link #canCreateUsingDelegate()} returns true,
+     * this method may return null .
+     */
+    public AnnotatedWithParams getDelegateCreator() {
+        return null;
+    }
+
+    /**
+     * Method that can be called to try to access member (constructor,
+     * static factory method) that is used as the "non-default creator"
+     * (constructor or factory method that takes one or more arguments).
+     * Note that implementations not required to return actual object
+     * they use (or, they may use some other instantiation) method.
+     * That is, even if {@link #canCreateFromObjectWith()} returns true,
+     * this method may return null .
+     */
+    public AnnotatedWithParams getWithArgsCreator() {
+        return null;
+    }
+}

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();
+        }
+    }
+}