testautoa 0.4.0.pre16

data/test-server/instrumentation-backend/src/sh/calaba/org/codehaus/jackson/annotate/JsonWriteNullProperties.java

@@ -0,0 +1,34 @@
+package sh.calaba.org.codehaus.jackson.annotate;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Annotation that can be used to define whether object properties
+ * that have null values are to be written out when serializing
+ * content as JSON. This affects Bean and Map serialization.
+ *<p>
+ * Annotation can be used with Classes (all instances of
+ * given class) and Methods.
+ *<p>
+ * Default value for this property is 'true', meaning that null
+ * properties are written.
+ *<p>
+ * @deprecated (since 1.6) Currently recommended annotation to use is
+ * {@link sh.calaba.org.codehaus.jackson.map.annotate.JsonSerialize#include()}
+ * (with values <code>ALWAYS</code> or <code>NON_NULL</code>)
+ */
+@Target({ElementType.TYPE, ElementType.METHOD, ElementType.FIELD})
+@Retention(RetentionPolicy.RUNTIME)
+@JacksonAnnotation
+@Deprecated
+public @interface JsonWriteNullProperties
+{
+    /**
+     * Whether properties for beans of annotated type will always be
+     * written (true), or only if not null (false).
+     */
+    boolean value() default true;
+}

data/test-server/instrumentation-backend/src/sh/calaba/org/codehaus/jackson/annotate/package-info.java

@@ -0,0 +1,16 @@
+/**
+ * Public core annotations, most of which are used to configure how
+ * Data Mapping/Binding works. Annotations in this package can only
+ * have dependencies to non-annotation classes in Core package;
+ * annotations that have dependencies to Mapper classes are included
+ * in Mapper module (under <code>sh.calaba.org.codehaus.jackson.map.annotate</code>).
+ * Also contains parameter types (mostly enums) needed by annotations.
+ *<p>
+ * In future (version 2.0?), this package will probably be split off
+ * as a separate jar/module, to allow use of annotations without
+ * including core module. This would be useful for third party value
+ * classes that themselves do not depend on Jackson, but may want to
+ * be annotated to be automatically and conveniently serializable by
+ * Jackson.
+ */
+package sh.calaba.org.codehaus.jackson.annotate;

data/test-server/instrumentation-backend/src/sh/calaba/org/codehaus/jackson/format/DataFormatDetector.java

@@ -0,0 +1,176 @@
+package sh.calaba.org.codehaus.jackson.format;
+
+import java.io.*;
+import java.util.*;
+
+import sh.calaba.org.codehaus.jackson.*;
+
+/**
+ * Simple helper class that allows data format (content type) auto-detection,
+ * given an ordered set of {@link JsonFactory} instances to use for actual low-level
+ * detection.
+ *
+ * @since 1.7
+ */
+public class DataFormatDetector
+{
+    /**
+     * By default we will look ahead at most 64 bytes; in most cases,
+     * much less (4 bytes or so) is needed, but we will allow bit more
+     * leniency to support data formats that need more complex heuristics.
+     */
+    public final static int DEFAULT_MAX_INPUT_LOOKAHEAD = 64;
+    
+    /**
+     * Ordered list of factories which both represent data formats to
+     * detect (in precedence order, starting with highest) and are used
+     * for actual detection.
+     */
+    protected final JsonFactory[] _detectors;
+
+    /**
+     * Strength of match we consider to be good enough to be used
+     * without checking any other formats.
+     * Default value is {@link MatchStrength#SOLID_MATCH}, 
+     */
+    protected final MatchStrength _optimalMatch;
+
+    /**
+     * Strength of minimal match we accept as the answer, unless
+     * better matches are found. 
+     * Default value is {@link MatchStrength#WEAK_MATCH}, 
+     */
+    protected final MatchStrength _minimalMatch;
+
+    /**
+     * Maximum number of leading bytes of the input that we can read
+     * to determine data format.
+     *<p>
+     * Default value is {@link #DEFAULT_MAX_INPUT_LOOKAHEAD}.
+     */
+    protected final int _maxInputLookahead;
+    
+    /*
+    /**********************************************************
+    /* Construction
+    /**********************************************************
+     */
+    
+    public DataFormatDetector(JsonFactory... detectors) {
+        this(detectors, MatchStrength.SOLID_MATCH, MatchStrength.WEAK_MATCH,
+            DEFAULT_MAX_INPUT_LOOKAHEAD);
+    }
+
+    public DataFormatDetector(Collection<JsonFactory> detectors) {
+        this(detectors.toArray(new JsonFactory[detectors.size()]));
+    }
+
+    /**
+     * Method that will return a detector instance that uses given
+     * optimal match level (match that is considered sufficient to return, without
+     * trying to find stronger matches with other formats).
+     */
+    public DataFormatDetector withOptimalMatch(MatchStrength optMatch) {
+        if (optMatch == _optimalMatch) {
+            return this;
+        }
+        return new DataFormatDetector(_detectors, optMatch, _minimalMatch, _maxInputLookahead);
+    }
+    /**
+     * Method that will return a detector instance that uses given
+     * minimal match level; match that may be returned unless a stronger match
+     * is found with other format detectors.
+     */
+    public DataFormatDetector withMinimalMatch(MatchStrength minMatch) {
+        if (minMatch == _minimalMatch) {
+            return this;
+        }
+        return new DataFormatDetector(_detectors, _optimalMatch, minMatch, _maxInputLookahead);
+    }
+
+    /**
+     * Method that will return a detector instance that allows detectors to
+     * read up to specified number of bytes when determining format match strength.
+     */
+    public DataFormatDetector withMaxInputLookahead(int lookaheadBytes)
+    {
+        if (lookaheadBytes == _maxInputLookahead) {
+            return this;
+        }
+        return new DataFormatDetector(_detectors, _optimalMatch, _minimalMatch, lookaheadBytes);
+    }
+    
+    private DataFormatDetector(JsonFactory[] detectors,
+            MatchStrength optMatch, MatchStrength minMatch,
+            int maxInputLookahead)
+    {
+        _detectors = detectors;
+        _optimalMatch = optMatch;
+        _minimalMatch = minMatch;
+        _maxInputLookahead = maxInputLookahead;
+    }
+
+    /*
+    /**********************************************************
+    /* Public API
+    /**********************************************************
+     */
+
+    /**
+     * Method to call to find format that content (accessible via given
+     * {@link InputStream}) given has, as per configuration of this detector
+     * instance.
+     * 
+     * @return Matcher object which contains result; never null, even in cases
+     *    where no match (with specified minimal match strength) is found.
+     */
+    public DataFormatMatcher findFormat(InputStream in) throws IOException
+    {
+        return _findFormat(new InputAccessor.Std(in, new byte[_maxInputLookahead]));
+    }
+
+    /**
+     * Method to call to find format that given content (full document)
+     * has, as per configuration of this detector instance.
+     * 
+     * @return Matcher object which contains result; never null, even in cases
+     *    where no match (with specified minimal match strength) is found.
+     */
+    public DataFormatMatcher findFormat(byte[] fullInputData) throws IOException
+    {
+        return _findFormat(new InputAccessor.Std(fullInputData));
+    }
+    
+    /*
+    /**********************************************************
+    /* Internal methods
+    /**********************************************************
+     */
+
+    private DataFormatMatcher _findFormat(InputAccessor.Std acc) throws IOException
+    {
+        JsonFactory bestMatch = null;
+        MatchStrength bestMatchStrength = null;
+        for (JsonFactory f : _detectors) {
+            acc.reset();
+            MatchStrength strength = f.hasFormat(acc);
+            // if not better than what we have so far (including minimal level limit), skip
+            if (strength == null || strength.ordinal() < _minimalMatch.ordinal()) {
+                continue;
+            }
+            // also, needs to better match than before
+            if (bestMatch != null) {
+                if (bestMatchStrength.ordinal() >= strength.ordinal()) {
+                    continue;
+                }
+            }
+            // finally: if it's good enough match, we are done
+            bestMatch = f;
+            bestMatchStrength = strength;
+            if (strength.ordinal() >= _optimalMatch.ordinal()) {
+                break;
+            }
+        }
+        return acc.createMatcher(bestMatch, bestMatchStrength);
+    }
+}

data/test-server/instrumentation-backend/src/sh/calaba/org/codehaus/jackson/format/DataFormatMatcher.java

@@ -0,0 +1,117 @@
+package sh.calaba.org.codehaus.jackson.format;
+
+import java.io.*;
+
+import sh.calaba.org.codehaus.jackson.JsonFactory;
+import sh.calaba.org.codehaus.jackson.JsonParser;
+import sh.calaba.org.codehaus.jackson.io.MergedStream;
+
+/**
+ * Result object constructed by {@link DataFormatDetector} when requested
+ * to detect format of given input data.
+ */
+public class DataFormatMatcher
+{
+    protected final InputStream _originalStream;
+
+    /**
+     * Content read during format matching process
+     */
+    protected final byte[] _bufferedData;
+
+    /**
+     * Number of bytes in {@link #_bufferedData} that were read.
+     */
+    protected final int _bufferedLength;
+
+    /**
+     * Factory that produced sufficient match (if any)
+     */
+    protected final JsonFactory _match;
+
+    /**
+     * Strength of match with {@link #_match}
+     */
+    protected final MatchStrength _matchStrength;
+    
+    protected DataFormatMatcher(InputStream in, byte[] buffered, int bufferedLength,
+            JsonFactory match, MatchStrength strength)
+    {
+        _originalStream = in;
+        _bufferedData = buffered;
+        _bufferedLength = bufferedLength;
+        _match = match;
+        _matchStrength = strength;
+    }
+
+    /*
+    /**********************************************************
+    /* Public API, simple accessors
+    /**********************************************************
+     */
+
+    /**
+     * Accessor to use to see if any formats matched well enough with
+     * the input data.
+     */
+    public boolean hasMatch() { return _match != null; }
+
+    /**
+     * Method for accessing strength of the match, if any; if no match,
+     * will return {@link MatchStrength#INCONCLUSIVE}.
+     */
+    public MatchStrength getMatchStrength() {
+        return (_matchStrength == null) ? MatchStrength.INCONCLUSIVE : _matchStrength;
+    }
+
+    /**
+     * Accessor for {@link JsonFactory} that represents format that data matched.
+     */
+    public JsonFactory getMatch() { return _match; }
+
+    /**
+     * Accessor for getting brief textual name of matched format if any (null
+     * if none). Equivalent to:
+     *<pre>
+     *   return hasMatch() ? getMatch().getFormatName() : null;
+     *</pre>
+     */
+    public String getMatchedFormatName() {
+        return _match.getFormatName();
+    }
+    
+    /*
+    /**********************************************************
+    /* Public API, factory methods
+    /**********************************************************
+     */
+    
+    /**
+     * Convenience method for trying to construct a {@link JsonParser} for
+     * parsing content which is assumed to be in detected data format.
+     * If no match was found, returns null.
+     */
+    public JsonParser createParserWithMatch() throws IOException {
+        if (_match == null) {
+            return null;
+        }
+        if (_originalStream == null) {
+            return _match.createJsonParser(_bufferedData, 0, _bufferedLength);
+        }
+        return _match.createJsonParser(getDataStream());
+    }
+    
+    /**
+     * Method to use for accessing input for which format detection has been done.
+     * This <b>must</b> be used instead of using stream passed to detector
+     * unless given stream itself can do buffering.
+     * Stream will return all content that was read during matching process, as well
+     * as remaining contents of the underlying stream.
+     */
+    public InputStream getDataStream() {
+        if (_originalStream == null) {
+            return new ByteArrayInputStream(_bufferedData, 0, _bufferedLength);
+        }
+        return new MergedStream(null, _originalStream, _bufferedData, 0, _bufferedLength);
+    }
+}

data/test-server/instrumentation-backend/src/sh/calaba/org/codehaus/jackson/format/InputAccessor.java

@@ -0,0 +1,130 @@
+package sh.calaba.org.codehaus.jackson.format;
+
+import java.io.*;
+
+import sh.calaba.org.codehaus.jackson.JsonFactory;
+
+/**
+ * Interface used to expose beginning of a data file to data format
+ * detection code.
+ * 
+ * @since 1.8
+ */
+public interface InputAccessor
+{
+    /**
+     * Method to call to check if more input is available.
+     * Since this may result in more content to be read (at least
+     * one more byte), a {@link IOException} may get thrown.
+     */
+    public boolean hasMoreBytes() throws IOException;
+
+    /**
+     * Returns next byte available, if any; if no more bytes are
+     * available, will throw {@link java.io.EOFException}.
+     */
+    public byte nextByte() throws IOException;
+
+    /**
+     * Method that can be called to reset accessor to read from beginning
+     * of input.
+     */
+    public void reset();
+
+    /*
+    /**********************************************************
+    /* Standard implementation
+    /**********************************************************
+     */
+
+    /**
+     * Basic implementation that reads data from given
+     * {@link InputStream} and buffers it as necessary.
+     */
+    public class Std implements InputAccessor
+    {
+        protected final InputStream _in;
+
+        protected final byte[] _buffer;
+
+        /**
+         * Number of bytes in {@link #_buffer} that are valid
+         * buffered content.
+         */
+        protected int _bufferedAmount;
+        
+        /**
+         * Pointer to next available buffered byte in {@link #_buffer}.
+         */
+        protected int _ptr;
+        
+        /**
+         * Constructor used when content to check is available via
+         * input stream and must be read.
+         */
+        public Std(InputStream in, byte[] buffer)
+        {
+            _in = in;
+            _buffer = buffer;
+            _bufferedAmount = 0;
+        }
+
+        /**
+         * Constructor used when the full input (or at least enough leading bytes
+         * of full input) is available.
+         */
+        public Std(byte[] inputDocument)
+        {
+            _in = null;
+            _buffer = inputDocument;
+            // we have it all:
+            _bufferedAmount = inputDocument.length;
+        }
+        
+        @Override
+        public boolean hasMoreBytes() throws IOException
+        {
+            if (_ptr < _bufferedAmount) { // already got more
+                return true;
+            }
+            int amount = _buffer.length - _ptr;
+            if (amount < 1) { // can not load any more
+                return false;
+            }
+            int count = _in.read(_buffer, _ptr, amount);
+            if (count <= 0) { // EOF
+                return false;
+            }
+            _bufferedAmount += count;
+            return true;
+        }
+
+        @Override
+        public byte nextByte() throws IOException
+        {
+            // should we just try loading more automatically?
+            if (_ptr >- _bufferedAmount) {
+                if (!hasMoreBytes()) {
+                    throw new EOFException("Could not read more than "+_ptr+" bytes (max buffer size: "+_buffer.length+")");
+                }
+            }
+            return _buffer[_ptr++];
+        }
+
+        @Override
+        public void reset() {
+            _ptr = 0;
+        }
+
+        /*
+        /**********************************************************
+        /* Extended API for DataFormatDetector/Matcher
+        /**********************************************************
+         */
+
+        public DataFormatMatcher createMatcher(JsonFactory match, MatchStrength matchStrength)
+        {
+            return new DataFormatMatcher(_in, _buffer, _bufferedAmount, match, matchStrength);
+        }
+    }
+}

data/test-server/instrumentation-backend/src/sh/calaba/org/codehaus/jackson/format/MatchStrength.java

@@ -0,0 +1,64 @@
+package sh.calaba.org.codehaus.jackson.format;
+
+/**
+ * Enumeration used to indicate strength of match between data format
+ * and piece of data (typically beginning of a data file).
+ * Values are in increasing match strength; and detectors should return
+ * "strongest" value: that is, it should start with strongest match
+ * criteria, and downgrading if criteria is not fulfilled.
+ * 
+ * @since 1.8
+ */
+public enum MatchStrength
+{
+    /**
+     * Value that indicates that given data can not be in given format.
+     */
+    NO_MATCH,
+    
+    /**
+     * Value that indicates that detector can not find out whether could
+     * be a match or not.
+     * This can occur for example for textual data formats t
+     * when there are so many leading spaces that detector can not
+     * find the first data byte (because detectors typically limit lookahead
+     * to some smallish value).
+     */
+    INCONCLUSIVE,
+
+    /**
+     * Value that indicates that given data could be of specified format (i.e.
+     * it can not be ruled out). This can occur for example when seen data
+     * is both not in canonical formats (for example: JSON data should be a JSON Array or Object
+     * not a scalar value, as per JSON specification) and there are known use case
+     * where a format detected is actually used (plain JSON Strings are actually used, even
+     * though specification does not indicate that as valid usage: as such, seeing a leading
+     * double-quote could indicate a JSON String, which plausibly <b>could</b> indicate
+     * non-standard JSON usage).
+     */
+    WEAK_MATCH,
+    
+    /**
+     * Value that indicates that given data conforms to (one of) canonical form(s) of
+     * the data format.
+     *<p>
+     * For example, when testing for XML data format,
+     * seeing a less-than character ("&lt;") alone (with possible leading spaces)
+     * would be a strong indication that data could
+     * be in xml format (but see below for {@link #FULL_MATCH} description for more)
+     */
+    SOLID_MATCH,
+
+    /**
+     * Value that indicates that given data contains a signature that is deemed
+     * specific enough to uniquely indicate data format used.
+     *<p>
+     * For example, when testing for XML data format,
+     * seing "&lt;xml" as the first data bytes ("XML declaration", as per XML specification)
+     * could give full confidence that data is indeed in XML format.
+     * Not all data formats have unique leading identifiers to allow full matches; for example,
+     * JSON only has heuristic matches and can have at most {@link #SOLID_MATCH}) match.
+     */
+    FULL_MATCH
+    ;
+}

data/test-server/instrumentation-backend/src/sh/calaba/org/codehaus/jackson/format/package-info.java

@@ -0,0 +1,8 @@
+/**
+ * Package that contains interfaces needed for dynamic, pluggable
+ * format (auto)detection; as well as basic utility classes for
+ * simple format detection functionality.
+ * 
+ * @since 1.8
+ */
+package sh.calaba.org.codehaus.jackson.format;