calabash-android 0.4.7.pre4 → 0.4.7.pre6

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

@@ -1,46 +0,0 @@
-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;
-
-/**
- * Marker annotation similar to
- * {@link javax.xml.bind.annotation.XmlValue} 
- * that indicates that results of the annotated "getter" method
- * (which means signature must be that of getters; non-void return
- * type, no args) is to be used as the single value to serialize
- * for the instance. Usually value will be of a simple scalar type
- * (String or Number), but it can be any serializable type (Collection,
- * Map or Bean).
- *<p>
- * At most one method of a Class can be annotated with this annotation;
- * if more than one is found, an exception may be thrown.
- * Also, if method signature is not compatible with Getters, an exception
- * may be thrown.
- * Whether exception is thrown or not is an implementation detail (due
- * to filtering during introspection, some annotations may be skipped)
- * and applications should not rely on specific behavior.
- *<p>
- * A typical use case is that of annotating <code>toString()</code>
- * method so that returned String value is Object's Json serialization.
- *<p>
- * Boolean argument is only used so that sub-classes can "disable"
- * annotation if necessary.
- */
-@Target({ElementType.METHOD})
-@Retention(RetentionPolicy.RUNTIME)
-@JacksonAnnotation
-public @interface JsonValue
-{
-    /**
-     * Optional argument that defines whether this annotation is active
-     * or not. The only use for value 'false' if for overriding purposes.
-     * Overriding may be necessary when used
-     * with "mix-in annotations" (aka "annotation overrides").
-     * For most cases, however, default value of "true" is just fine
-     * and should be omitted.
-     */
-    boolean value() default true;
-}

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

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

@@ -1,16 +0,0 @@
-/**
- * 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

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

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

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