testautoa 0.4.0.pre16

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

@@ -0,0 +1,28 @@
+package sh.calaba.org.codehaus.jackson.map.util;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+/**
+ * Helper for simple bounded LRU maps used for reusing lookup values.
+ * 
+ * @since 1.7
+ */
+@SuppressWarnings("serial")
+public class LRUMap<K,V> extends LinkedHashMap<K,V>
+{
+    protected final int _maxEntries;
+    
+    public LRUMap(int initialEntries, int maxEntries)
+    {
+        super(initialEntries, 0.8f, true);
+        _maxEntries = maxEntries;
+    }
+
+    @Override
+    protected boolean removeEldestEntry(Map.Entry<K,V> eldest)
+    {
+        return size() > _maxEntries;
+    }
+
+}

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

@@ -0,0 +1,45 @@
+package sh.calaba.org.codehaus.jackson.map.util;
+
+/**
+ * Node of a forward-only linked list.
+ * 
+ * @author tatu
+ *
+ * @param <T> Type of contained object
+ */
+public final class LinkedNode<T>
+{
+    final T _value;
+    final LinkedNode<T> _next;
+    
+    public LinkedNode(T value, LinkedNode<T> next)
+    {
+        _value = value;
+        _next = next;
+    }
+    
+    public LinkedNode<T> next() { return _next; }
+    
+    public T value() { return _value; }
+    
+    /**
+     * Convenience method that can be used to check if a linked list
+     * with given head node (which may be null to indicate empty list)
+     * contains given value
+     * 
+     * @param <ST> Type argument that defines contents of the linked list parameter
+     * @param node Head node of the linked list
+     * @param value Value to look for
+     * @return True if linked list contains the value, false otherwise
+     */
+    public static <ST> boolean contains(LinkedNode<ST> node, ST value)
+    {
+        while (node != null) {
+            if (node.value() == value) {
+                return true;
+            }
+            node = node.next();
+        }
+        return false;
+    }
+}

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

@@ -0,0 +1,10 @@
+package sh.calaba.org.codehaus.jackson.map.util;
+
+/**
+ * Simple tag interface mostly to allow sorting by name
+ *
+ * @since 1.9
+ */
+public interface Named {
+    public String getName();
+}

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

@@ -0,0 +1,257 @@
+package sh.calaba.org.codehaus.jackson.map.util;
+
+import java.lang.reflect.Array;
+import java.util.List;
+
+/**
+ * Helper class to use for constructing Object arrays by appending entries
+ * to create arrays of various lengths (length that is not known a priori). 
+ */
+public final class ObjectBuffer
+{
+    // // // Config constants
+
+    /**
+     * Let's start with small chunks; typical usage is for small arrays anyway.
+     */
+    final static int INITIAL_CHUNK_SIZE = 12;
+
+    /**
+     * Also: let's expand by doubling up until 64k chunks (which is 16k entries for
+     * 32-bit machines)
+     */
+    final static int SMALL_CHUNK_SIZE = (1 << 14);
+
+    /**
+     * Let's limit maximum size of chunks we use; helps avoid excessive allocation
+     * overhead for huge data sets.
+     * For now, let's limit to quarter million entries, 1 meg chunks for 32-bit
+     * machines.
+     */
+    final static int MAX_CHUNK_SIZE = (1 << 18);
+
+    // // // Data storage
+
+    private Node _bufferHead;
+
+    private Node _bufferTail;
+
+    /**
+     * Number of total buffered entries in this buffer, counting all instances
+     * within linked list formed by following {@link #_bufferHead}.
+     */
+    private int _bufferedEntryCount;
+
+    // // // Simple reuse
+
+    /**
+     * Reusable Object array, stored here after buffer has been released having
+     * been used previously.
+     */
+    private Object[] _freeBuffer;
+
+    /*
+    /**********************************************************
+    /* Construction
+    /**********************************************************
+     */
+
+    public ObjectBuffer() { }
+
+    /*
+    /**********************************************************
+    /* Public API
+    /**********************************************************
+     */
+
+    /**
+     * Method called to start buffering process. Will ensure that the buffer
+     * is empty, and then return an object array to start chunking content on
+     */
+    public Object[] resetAndStart()
+    {
+        _reset();
+        if (_freeBuffer == null) {
+            return new Object[INITIAL_CHUNK_SIZE];
+        }
+        return _freeBuffer;
+    }
+
+    /**
+     * Method called to add a full Object array as a chunk buffered within
+     * this buffer, and to obtain a new array to fill. Caller is not to use
+     * the array it gives; but to use the returned array for continued
+     * buffering.
+     *
+     * @param fullChunk Completed chunk that the caller is requesting
+     *   to append to this buffer. It is generally chunk that was
+     *   returned by an earlier call to {@link #resetAndStart} or
+     *   {@link #appendCompletedChunk} (although this is not required or
+     *   enforced)
+     *
+     * @return New chunk buffer for caller to fill
+     */
+    public Object[] appendCompletedChunk(Object[] fullChunk)
+    {
+        Node next = new Node(fullChunk);
+        if (_bufferHead == null) { // first chunk
+            _bufferHead = _bufferTail = next;
+        } else { // have something already
+            _bufferTail.linkNext(next);
+            _bufferTail = next;
+        }
+        int len = fullChunk.length;
+        _bufferedEntryCount += len;
+        // double the size for small chunks
+        if (len < SMALL_CHUNK_SIZE) {
+            len += len;
+        } else { // but by +25% for larger (to limit overhead)
+            len += (len >> 2);
+        }
+        return new Object[len];
+    }
+
+    /**
+     * Method called to indicate that the buffering process is now
+     * complete; and to construct a combined exactly-sized result
+     * array. Additionally the buffer itself will be reset to
+     * reduce memory retention.
+     *<p>
+     * Resulting array will be of generic <code>Object[]</code> type:
+     * if a typed array is needed, use the method with additional
+     * type argument.
+     */
+    public Object[] completeAndClearBuffer(Object[] lastChunk, int lastChunkEntries)
+    {
+        int totalSize = lastChunkEntries + _bufferedEntryCount;
+        Object[] result = new Object[totalSize];
+        _copyTo(result, totalSize, lastChunk, lastChunkEntries);
+        return result;
+    }
+
+    /**
+     * Type-safe alternative to
+     * {@link #completeAndClearBuffer(Object[], int)}, to allow
+     * for constructing explicitly typed result array.
+     *
+     * @param componentType Type of elements included in the buffer. Will be
+     *   used for constructing the result array.
+     */
+    public <T> T[] completeAndClearBuffer(Object[] lastChunk, int lastChunkEntries, Class<T> componentType)
+    {
+       int totalSize = lastChunkEntries + _bufferedEntryCount;
+ 	   @SuppressWarnings("unchecked")
+        T[] result = (T[]) Array.newInstance(componentType, totalSize);
+        _copyTo(result, totalSize, lastChunk, lastChunkEntries);
+        _reset();
+        return result;
+    }
+
+    /**
+     * Another
+     * 
+     * @since 1.6
+     */
+    public void completeAndClearBuffer(Object[] lastChunk, int lastChunkEntries, List<Object> resultList)
+    {
+        for (Node n = _bufferHead; n != null; n = n.next()) {
+            Object[] curr = n.getData();
+            for (int i = 0, len = curr.length; i < len; ++i) {
+                resultList.add(curr[i]);
+            }
+        }
+        // and then the last one
+        for (int i = 0; i < lastChunkEntries; ++i) {
+            resultList.add(lastChunk[i]);
+        }
+    }
+    
+    /**
+     * Helper method that can be used to check how much free capacity
+     * will this instance start with. Can be used to choose the best
+     * instance to reuse, based on size of reusable object chunk
+     * buffer holds reference to.
+     */
+    public int initialCapacity()
+    {
+        return (_freeBuffer == null) ? 0 : _freeBuffer.length;
+    }
+
+    /**
+     * Method that can be used to check how many Objects have been buffered
+     * within this buffer.
+     */
+    public int bufferedSize() { return _bufferedEntryCount; }
+
+    /*
+    /**********************************************************
+    /* Internal methods
+    /**********************************************************
+     */
+
+    protected void _reset()
+    {
+        // can we reuse the last (and thereby biggest) array for next time?
+        if (_bufferTail != null) {
+            _freeBuffer = _bufferTail.getData();
+        }
+        // either way, must discard current contents
+        _bufferHead = _bufferTail = null;
+        _bufferedEntryCount = 0;
+    }
+
+    protected final void _copyTo(Object resultArray, int totalSize,
+                                 Object[] lastChunk, int lastChunkEntries)
+    {
+        int ptr = 0;
+
+        for (Node n = _bufferHead; n != null; n = n.next()) {
+            Object[] curr = n.getData();
+            int len = curr.length;
+            System.arraycopy(curr, 0, resultArray, ptr, len);
+            ptr += len;
+        }
+        System.arraycopy(lastChunk, 0, resultArray, ptr, lastChunkEntries);
+        ptr += lastChunkEntries;
+
+        // sanity check (could have failed earlier due to out-of-bounds, too)
+        if (ptr != totalSize) {
+            throw new IllegalStateException("Should have gotten "+totalSize+" entries, got "+ptr);
+        }
+    }
+
+    /*
+    /**********************************************************
+    /* Helper classes
+    /**********************************************************
+     */
+
+    /**
+     * Helper class used to store actual data, in a linked list.
+     */
+    final static class Node
+    {
+        /**
+         * Data stored in this node. Array is considered to be full.
+         */
+        final Object[] _data;
+
+        Node _next;
+
+        public Node(Object[] data) {
+            _data = data;
+        }
+
+        public Object[] getData() { return _data; }
+
+        public Node next() { return _next; }
+
+        public void linkNext(Node next)
+        {
+            if (_next != null) { // sanity check
+                throw new IllegalStateException();
+            }
+            _next = next;
+        }
+    }
+}

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

@@ -0,0 +1,180 @@
+package sh.calaba.org.codehaus.jackson.map.util;
+
+/**
+ * Base class for specialized primitive array builders.
+ */
+public abstract class PrimitiveArrayBuilder<T>
+{
+    /**
+     * Let's start with small chunks; typical usage is for small arrays anyway.
+     */
+    final static int INITIAL_CHUNK_SIZE = 12;
+
+    /**
+     * Also: let's expand by doubling up until 64k chunks (which is 16k entries for
+     * 32-bit machines)
+     */
+    final static int SMALL_CHUNK_SIZE = (1 << 14);
+
+    /**
+     * Let's limit maximum size of chunks we use; helps avoid excessive allocation
+     * overhead for huge data sets.
+     * For now, let's limit to quarter million entries, 1 meg chunks for 32-bit
+     * machines.
+     */
+    final static int MAX_CHUNK_SIZE = (1 << 18);
+
+    // // // Data storage
+
+    T _freeBuffer;
+
+    Node<T> _bufferHead;
+
+    Node<T> _bufferTail;
+
+    /**
+     * Number of total buffered entries in this buffer, counting all instances
+     * within linked list formed by following {@link #_bufferHead}.
+     */
+    int _bufferedEntryCount;
+
+    // // // Recycled instances of sub-classes
+
+    // // // Life-cycle
+
+    protected PrimitiveArrayBuilder() { }
+
+    /*
+    ////////////////////////////////////////////////////////////////////////
+    // Public API
+    ////////////////////////////////////////////////////////////////////////
+     */
+
+    public T resetAndStart()
+    {
+        _reset();
+        return (_freeBuffer == null) ?
+            _constructArray(INITIAL_CHUNK_SIZE) : _freeBuffer;
+    }
+
+    /**
+     * @return Length of the next chunk to allocate
+     */
+    public final T appendCompletedChunk(T fullChunk, int fullChunkLength)
+    {
+        Node<T> next = new Node<T>(fullChunk, fullChunkLength);
+        if (_bufferHead == null) { // first chunk
+            _bufferHead = _bufferTail = next;
+        } else { // have something already
+            _bufferTail.linkNext(next);
+            _bufferTail = next;
+        }
+        _bufferedEntryCount += fullChunkLength;
+        int nextLen = fullChunkLength; // start with last chunk size
+        // double the size for small chunks
+        if (nextLen < SMALL_CHUNK_SIZE) {
+            nextLen += nextLen;
+        } else { // but by +25% for larger (to limit overhead)
+            nextLen += (nextLen >> 2);
+        }
+        return _constructArray(nextLen);
+    }
+
+    public T completeAndClearBuffer(T lastChunk, int lastChunkEntries)
+    {
+        int totalSize = lastChunkEntries + _bufferedEntryCount;
+        T resultArray = _constructArray(totalSize);
+
+        int ptr = 0;
+
+        for (Node<T> n = _bufferHead; n != null; n = n.next()) {
+            ptr = n.copyData(resultArray, ptr);
+        }
+        System.arraycopy(lastChunk, 0, resultArray, ptr, lastChunkEntries);
+        ptr += lastChunkEntries;
+
+        // sanity check (could have failed earlier due to out-of-bounds, too)
+        if (ptr != totalSize) {
+            throw new IllegalStateException("Should have gotten "+totalSize+" entries, got "+ptr);
+        }
+        return resultArray;
+    }
+
+    /*
+    ////////////////////////////////////////////////////////////////////////
+    // Abstract methods for sub-classes to implement
+    ////////////////////////////////////////////////////////////////////////
+     */
+
+    protected abstract T _constructArray(int len);
+
+    /*
+    ////////////////////////////////////////////////////////////////////////
+    // Internal methods
+    ////////////////////////////////////////////////////////////////////////
+     */
+
+    protected void _reset()
+    {
+        // can we reuse the last (and thereby biggest) array for next time?
+        if (_bufferTail != null) {
+            _freeBuffer = _bufferTail.getData();
+        }
+        // either way, must discard current contents
+        _bufferHead = _bufferTail = null;
+        _bufferedEntryCount = 0;
+    }
+
+    /*
+    ////////////////////////////////////////////////////////////////////////
+    // Helper classes
+    ////////////////////////////////////////////////////////////////////////
+     */
+
+    /**
+     * For actual buffering beyond the current buffer, we can actually
+     * use shared class which only deals with opaque "untyped" chunks.
+     * This works because {@link java.lang.System#arraycopy} does not
+     * take type; hence we can implement some aspects of primitive data
+     * handling in generic fashion.
+     */
+    final static class Node<T>
+    {
+        /**
+         * Data stored in this node.
+         */
+        final T _data;
+
+        /**
+         * Number entries in the (untyped) array. Offset is assumed to be 0.
+         */
+        final int _dataLength;
+
+        Node<T> _next;
+
+        public Node(T data, int dataLen)
+        {
+            _data = data;
+            _dataLength = dataLen;
+        }
+
+        public T getData() { return _data; }
+
+        public int copyData(T dst, int ptr)
+        {
+            System.arraycopy(_data, 0, dst, ptr, _dataLength);
+            ptr += _dataLength;
+            return ptr;
+        }
+
+        public Node<T> next() { return _next; }
+
+        public void linkNext(Node<T> next)
+        {
+            if (_next != null) { // sanity check
+                throw new IllegalStateException();
+            }
+            _next = next;
+        }
+    }
+}

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

@@ -0,0 +1,21 @@
+package sh.calaba.org.codehaus.jackson.map.util;
+
+import java.util.*;
+
+/**
+* Simple helper class used for decoupling instantiation of
+* optionally loaded handlers, like deserializers and deserializers
+* for libraries that are only present on some platforms.
+ * 
+ * @author tatu
+ *
+ * @param <T> Type of objects provided
+ */
+public interface Provider<T>
+{
+    /**
+     * Method used to request provider to provide entries it has
+     */
+    public Collection<T> provide();
+}
+

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

@@ -0,0 +1,54 @@
+package sh.calaba.org.codehaus.jackson.map.util;
+
+import sh.calaba.org.codehaus.jackson.io.SerializedString;
+import sh.calaba.org.codehaus.jackson.map.AnnotationIntrospector;
+import sh.calaba.org.codehaus.jackson.map.MapperConfig;
+import sh.calaba.org.codehaus.jackson.map.introspect.AnnotatedClass;
+import sh.calaba.org.codehaus.jackson.map.introspect.BasicBeanDescription;
+import sh.calaba.org.codehaus.jackson.map.type.ClassKey;
+import sh.calaba.org.codehaus.jackson.type.JavaType;
+
+/**
+ * Helper class for caching resolved root names.
+ */
+public class RootNameLookup
+{
+    /**
+     * For efficient operation, let's try to minimize number of times we
+     * need to introspect root element name to use.
+     */
+    protected LRUMap<ClassKey,SerializedString> _rootNames;
+
+    public RootNameLookup() { }
+
+    public SerializedString findRootName(JavaType rootType, MapperConfig<?> config)
+    {
+        return findRootName(rootType.getRawClass(), config);
+    }
+
+    public synchronized SerializedString findRootName(Class<?> rootType, MapperConfig<?> config)
+    {
+        ClassKey key = new ClassKey(rootType);
+
+        if (_rootNames == null) {
+            _rootNames = new LRUMap<ClassKey,SerializedString>(20, 200);
+        } else {
+            SerializedString name = _rootNames.get(key);
+            if (name != null) {
+                return name;
+            }
+        }
+        BasicBeanDescription beanDesc = (BasicBeanDescription) config.introspectClassAnnotations(rootType);
+        AnnotationIntrospector intr = config.getAnnotationIntrospector();
+        AnnotatedClass ac = beanDesc.getClassInfo();
+        String nameStr = intr.findRootName(ac);
+        // No answer so far? Let's just default to using simple class name
+        if (nameStr == null) {
+            // Should we strip out enclosing class tho? For now, nope:
+            nameStr = rootType.getSimpleName();
+        }
+        SerializedString name = new SerializedString(nameStr);
+        _rootNames.put(key, name);
+        return name;
+    }
+}