testautoa 0.4.0.pre16

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

@@ -0,0 +1,54 @@
+package sh.calaba.org.codehaus.jackson;
+
+/**
+ * Interface that defines how Jackson package can interact with efficient
+ * pre-serialized or lazily-serialized and reused String representations.
+ * Typically implementations store possible serialized version(s) so that
+ * serialization of String can be done more efficiently, especially when
+ * used multiple times.
+ *
+ * @since 1.7 (1.6 introduced implementation, but interface extracted later)
+ * 
+ * @see sh.calaba.org.codehaus.jackson.io.SerializedString
+ */
+public interface SerializableString
+{
+    /**
+     * Returns unquoted String that this object represents (and offers
+     * serialized forms for)
+     */
+    public String getValue();
+    
+    /**
+     * Returns length of the (unquoted) String as characters.
+     * Functionally equvalent to:
+     *<pre>
+     *   getValue().length();
+     *</pre>
+     */
+    public int charLength();
+
+    /**
+     * Returns JSON quoted form of the String, as character array. Result
+     * can be embedded as-is in textual JSON as property name or JSON String.
+     */
+    public char[] asQuotedChars();
+
+    /**
+     * Returns UTF-8 encoded version of unquoted String.
+     * Functionally equivalent to (but more efficient than):
+     *<pre>
+     * getValue().getBytes("UTF-8");
+     *</pre>
+     */
+    public byte[] asUnquotedUTF8();
+
+    /**
+     * Returns UTF-8 encoded version of JSON-quoted String.
+     * Functionally equivalent to (but more efficient than):
+     *<pre>
+     * new String(asQuotedChars()).getBytes("UTF-8");
+     *</pre>
+     */
+    public byte[] asQuotedUTF8();
+}

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

@@ -0,0 +1,90 @@
+package sh.calaba.org.codehaus.jackson;
+
+/**
+ * Object that encapsulates version information of a component,
+ * and is return by {@link Versioned#version}.
+ * 
+ * @since 1.6
+ */
+public class Version
+    implements Comparable<Version>
+{
+    private final static Version UNKNOWN_VERSION = new Version(0, 0, 0, null);
+
+    protected final int _majorVersion;
+
+    protected final int _minorVersion;
+
+    protected final int _patchLevel;
+
+    /**
+     * Additional information for snapshot versions; null for non-snapshot
+     * (release) versions.
+     */
+    protected final String _snapshotInfo;
+    
+    public Version(int major, int minor, int patchLevel,
+            String snapshotInfo)
+    {
+        _majorVersion = major;
+        _minorVersion = minor;
+        _patchLevel = patchLevel;
+        _snapshotInfo = snapshotInfo;
+    }
+
+    /**
+     * Method returns canonical "not known" version, which is used as version
+     * in cases where actual version information is not known (instead of null).
+     */
+    public static Version unknownVersion() { return UNKNOWN_VERSION; }
+
+    public boolean isUknownVersion() { return (this == UNKNOWN_VERSION); }
+    public boolean isSnapshot() { return (_snapshotInfo != null && _snapshotInfo.length() > 0); }
+    
+    public int getMajorVersion() { return _majorVersion; }
+    public int getMinorVersion() { return _minorVersion; }
+    public int getPatchLevel() { return _patchLevel; }
+
+    @Override
+    public String toString()
+    {
+        StringBuilder sb = new StringBuilder();
+        sb.append(_majorVersion).append('.');
+        sb.append(_minorVersion).append('.');
+        sb.append(_patchLevel);
+        if (isSnapshot()) {
+            sb.append('-').append(_snapshotInfo);
+        }
+        return sb.toString();
+    }
+
+    @Override
+    public int hashCode() {
+        return _majorVersion + _minorVersion + _patchLevel;
+    }
+
+    @Override
+    public boolean equals(Object o)
+    {
+        if (o == this) return true;
+        if (o == null) return false;
+        if (o.getClass() != getClass()) return false;
+        Version other = (Version) o;
+        return (other._majorVersion == _majorVersion)
+            && (other._minorVersion == _minorVersion)
+            && (other._patchLevel == _patchLevel);
+    }
+
+    @Override
+    public int compareTo(Version other)
+    {
+        int diff = _majorVersion - other._majorVersion;
+        if (diff == 0) {
+            diff = _minorVersion - other._minorVersion;
+            if (diff == 0) {
+                diff = _patchLevel - other._patchLevel;
+            }
+        }
+        return diff;
+    }
+}

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

@@ -0,0 +1,20 @@
+package sh.calaba.org.codehaus.jackson;
+
+/**
+ * Interface that those Jackson components that are explicitly versioned will implement.
+ * Intention is to allow both plug-in components (custom extensions) and applications and
+ * frameworks that use Jackson to detect exact version of Jackson in use.
+ * This may be useful for example for ensuring that proper Jackson version is deployed
+ * (beyond mechanisms that deployment system may have), as well as for possible
+ * workarounds.
+ * 
+ * @since 1.6
+ */
+public interface Versioned {
+    /**
+     * Method called to detect version of the component that implements this interface;
+     * returned version should never be null, but may return specific "not available"
+     * instance (see {@link Version} for details).
+     */
+    public Version version();
+}

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

@@ -0,0 +1,20 @@
+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;
+
+/**
+ * Meta-annotation (annotations used on other annotations)
+ * used for marking all annotations that are
+ * part of Jackson package. Can be used for recognizing all
+ * Jackson annotations generically, and in future also for
+ * passing other generic annotation configuration.
+ */
+@Target({ElementType.ANNOTATION_TYPE})
+@Retention(RetentionPolicy.RUNTIME)
+public @interface JacksonAnnotation
+{
+    // for now, a pure tag annotation, no parameters
+}

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

@@ -0,0 +1,25 @@
+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 that can be used to define a non-static,
+ * no-argument method or member field as something of a reverse of
+ * {@link JsonAnySetter} method; basically being used like a
+ * getter but such that contents of the returned Map (type <b>must</b> be
+ * {@link java.util.Map}) are serialized as if they were actual properties
+ * of the bean that contains method/field with this annotations.
+ * As with {@link JsonAnySetter}, only one property should be annotated
+ * with this annotation.
+ * 
+ * @since 1.6
+ */
+@Target(ElementType.METHOD)
+@Retention(RetentionPolicy.RUNTIME)
+@JacksonAnnotation
+public @interface JsonAnyGetter
+{
+}

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

@@ -0,0 +1,24 @@
+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 that can be used to define a non-static,
+ * single-argument method, to be used as a "fallback" handler
+ * for all otherwise unrecognized properties found from Json content.
+ * It is similar to {@link javax.xml.bind.annotation.XmlAnyElement}
+ * in behavior; and can only be used to denote a single property
+ * per type.
+ *<p>
+ * If used, all otherwise unmapped key-value pairs from Json Object
+ * structs are added to the property (of type Map or bean).
+ */
+@Target(ElementType.METHOD)
+@Retention(RetentionPolicy.RUNTIME)
+@JacksonAnnotation
+public @interface JsonAnySetter
+{
+}

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

@@ -0,0 +1,148 @@
+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;
+import java.lang.reflect.Member;
+import java.lang.reflect.Modifier;
+
+/**
+ * Class annotation that can be used to define which kinds of Methods
+ * are to be detected by auto-detection.
+ * Auto-detection means using name conventions
+ * and/or signature templates to find methods to use for data binding.
+ * For example, so-called "getters" can be auto-detected by looking for
+ * public member methods that return a value, do not take argument,
+ * and have prefix "get" in their name.
+ *<p>
+ * Pseudo-value <code>NONE</code> means that all auto-detection is disabled
+ * for the <b>specific</b> class that annotation is applied to (including
+ * its super-types, but only when resolving that class).
+ * Pseudo-value <code>ALWAYS</code> means that auto-detection is enabled
+ * for all method types for the class in similar way.
+ *<p>
+ * The default value is <code>ALWAYS</code>: that is, by default, auto-detection
+ * is enabled for all classes unless instructed otherwise.
+ *<p>
+ * Starting with version 1.5, it is also possible to use more fine-grained
+ * definitions, to basically define minimum visibility level needed. Defaults
+ * are different for different types (getters need to be public; setters can
+ * have any access modifier, for example).
+ */
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@JacksonAnnotation
+public @interface JsonAutoDetect
+{
+	/**
+	 * Enumeration for possible visibility thresholds (minimum visibility)
+	 * that can be used to limit which methods (and fields) are
+	 * auto-detected.
+	 * 
+	 * @since 1.5
+	 */
+	public enum Visibility {
+		/**
+		 * Value that means that all kinds of access modifiers are acceptable,
+		 * from private to public.
+		 */
+		ANY,
+		/**
+		 * Value that means that any other access modifier other than 'private'
+		 * is considered auto-detectable.
+		 */
+		NON_PRIVATE,
+		/**
+		 * Value that means access modifiers 'protected' and 'public' are
+		 * auto-detectable (and 'private' and "package access" == no modifiers
+		 * are not)
+		 */
+		PROTECTED_AND_PUBLIC,
+		/**
+		 * Value to indicate that only 'public' access modifier is considered
+		 * auto-detectable.
+		 */
+		PUBLIC_ONLY,
+		/**
+		 * Value that indicates that no access modifiers are auto-detectable:
+		 * this can be used to explicitly disable auto-detection for specified
+		 * types.
+		 */
+		NONE,
+		
+		/**
+		 * Value that indicates that default visibility level (whatever it is,
+		 * depends on context) is to be used. This usually means that inherited
+		 * value (from parent visibility settings) is to be used.
+		 */
+		DEFAULT;
+
+		public boolean isVisible(Member m) {
+			switch (this) {
+			case ANY:
+			    return true;
+			case NONE:
+			    return false;
+			case NON_PRIVATE:
+			    return !Modifier.isPrivate(m.getModifiers());
+			case PROTECTED_AND_PUBLIC:
+			    if (Modifier.isProtected(m.getModifiers())) {
+			        return true;
+			    }
+			    // fall through to public case:
+			case PUBLIC_ONLY:
+			    return Modifier.isPublic(m.getModifiers());
+			}
+			return false;
+		}
+	}
+	
+    /**
+     * Types of property elements (getters, setters, fields, creators) that
+     * can be auto-detected.
+     * NOTE: as of 1.5, it is recommended that instead of defining this property,
+     * distinct visibility properties are used instead. This because levels
+     * used with this method are not explicit, but global defaults that differ for different
+     * methods. As such, this property can be considered <b>deprecated</b> and
+     * only retained for backwards compatibility.
+     */
+    JsonMethod[] value() default { JsonMethod.ALL };
+    
+    /**
+     * Minimum visibility required for auto-detecting regular getter methods.
+     * 
+     * @since 1.5
+     */
+    Visibility getterVisibility() default Visibility.DEFAULT;
+
+    /**
+     * Minimum visibility required for auto-detecting is-getter methods.
+     * 
+     * @since 1.5
+     */
+    Visibility isGetterVisibility() default Visibility.DEFAULT;
+    
+    /**
+     * Minimum visibility required for auto-detecting setter methods.
+     * 
+     * @since 1.5
+     */    
+    Visibility setterVisibility() default Visibility.DEFAULT;
+
+    /**
+     * Minimum visibility required for auto-detecting Creator methods,
+     * except for no-argument constructors (which are always detected
+     * no matter what).
+     * 
+     * @since 1.5
+     */
+    Visibility creatorVisibility() default Visibility.DEFAULT;
+
+    /**
+     * Minimum visibility required for auto-detecting member fields.
+     * 
+     * @since 1.5
+     */ 
+    Visibility fieldVisibility() default Visibility.DEFAULT;
+}

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

@@ -0,0 +1,41 @@
+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 used to indicate that associated property is part of
+ * two-way linkage between fields; and that its role is "child" (or "back") link.
+ * Value type of the property must be a bean: it can not be a Collection, Map,
+ * Array or enumeration.
+ * Linkage is handled such that the property
+ * annotated with this annotation is not serialized; and during deserialization,
+ * its value is set to instance that has the "managed" (forward) link.
+ *<p>
+ * All references have logical name to allow handling multiple linkages; typical case
+ * would be that where nodes have both parent/child and sibling linkages. If so,
+ * pairs of references should be named differently.
+ * It is an error for a class to have multiple back references with same name,
+ * even if types pointed are different.
+ *<p>
+ * Note: only methods and fields can be annotated with this annotation: constructor
+ * arguments should NOT be annotated, as they can not be either managed or back
+ * references.
+ * 
+ * @author tatu
+ */
+@Target({ElementType.FIELD, ElementType.METHOD})
+@Retention(RetentionPolicy.RUNTIME)
+@JacksonAnnotation
+public @interface JsonBackReference
+{
+    /**
+     * Logical have for the reference property pair; used to link managed and
+     * back references. Default name can be used if there is just single
+     * reference pair (for example, node class that just has parent/child linkage,
+     * consisting of one managed reference and matching back reference)
+     */
+    public String value() default "defaultReference";
+}

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

@@ -0,0 +1,19 @@
+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 that can be used to define constructors and factory
+ * methods as one to use for instantiating new instances of the associated
+ * class.
+ */
+@Target({ElementType.METHOD, ElementType.CONSTRUCTOR})
+@Retention(RetentionPolicy.RUNTIME)
+@JacksonAnnotation
+public @interface JsonCreator
+{
+    // no values, since there's no property
+}

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

@@ -0,0 +1,35 @@
+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 that can be used to define a non-static,
+ * no-argument value-returning (non-void) method to be used as a "getter"
+ * for a logical property,
+ * as an alternative to recommended
+ * {@link JsonProperty} annotation (which was introduced in version 1.1).
+ *<p>
+ * Getter means that when serializing Object instance of class that has
+ * this method (possibly inherited from a super class), a call is made
+ * through the method, and return value will be serialized as value of
+ * the property.
+ * 
+ * @deprecated Use {@link JsonProperty} instead (deprecated since version 1.5)
+ */
+@Target(ElementType.METHOD)
+@Retention(RetentionPolicy.RUNTIME)
+@JacksonAnnotation
+@Deprecated
+public @interface JsonGetter
+{
+    /**
+     * Defines name of the logical property this
+     * method is used to access ("get"); empty String means that
+     * name should be derived from the underlying method (using
+     * standard Bean name detection rules)
+     */
+    String value() default "";
+}

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

@@ -0,0 +1,57 @@
+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 that indicates that the annotated method or field is to be
+ * ignored by introspection-based
+ * serialization and deserialization functionality. That is, it should
+ * not be consider a "getter", "setter" or "creator".
+ *<p>
+ * In addition, starting with Jackson 1.9, if this is the only annotation
+ * associated with a property, it will also cause cause the whole
+ * property to be ignored: that is, if setter has this annotation and
+ * getter has no annotations, getter is also effectively ignored.
+ * It is still possible for different accessors to use different
+ * annotations; so if only "getter" is to be ignored, other accessors
+ * (setter or field) would need explicit annotation to prevent
+ * ignoral (usually {@link JsonProperty}).
+ * <p>
+ * For example, a "getter" method that would otherwise denote
+ * a property (like, say, "getValue" to suggest property "value")
+ * to serialize, would be ignored and no such property would
+ * be output unless another annotation defines alternative method to use.
+ *<p>
+ * Before version 1.9, this annotation worked purely on method-by-method (or field-by-field)
+ * basis; annotation on one method or field does not imply ignoring other methods
+ * or fields. However, with version 1.9 and above, annotations associated
+ * with various accessors (getter, setter, field, constructor parameter) of
+ * a logical property are combined; meaning that annotations may be effectly
+ * combined.
+ *<p>
+ * Annotation is usually used just a like a marker annotation, that
+ * is, without explicitly defining 'value' argument (which defaults
+ * to <code>true</code>): but argument can be explicitly defined.
+ * This can be done to override an existing JsonIgnore by explictly
+ * defining one with 'false' argument.
+ *<p>
+ * Annotation is similar to {@link javax.xml.bind.annotation.XmlTransient} 
+ */
+@Target({ElementType.METHOD, ElementType.CONSTRUCTOR, ElementType.FIELD})
+@Retention(RetentionPolicy.RUNTIME)
+@JacksonAnnotation
+public @interface JsonIgnore
+{
+    /**
+     * Optional argument that defines whether this annotation is active
+     * or not. The only use for value 'false' if for overriding purposes
+     * (which is not needed often); most likely it is needed for use
+     * 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/JsonIgnoreProperties.java

@@ -0,0 +1,48 @@
+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 either suppress serialization of
+ * properties (during serialization), or ignore processing of
+ * JSON properties read (during deserialization).
+ *<p>
+ * Example:
+ *<pre>
+ * // to prevent specified fields from being serialized or deserialized
+ * // (i.e. not include in JSON output; or being set even if they were included)
+ * \@JsonIgnoreProperties({ "internalId", "secretKey" })
+ * // To ignore any unknown properties in JSON input without exception:
+ * \@JsonIgnoreProperties(ignoreUnknown=true)
+ *</pre>
+ *<p>
+ * Only applicable to classes, not for properties (getters, setters, fields).
+ * 
+ * @since 1.4
+ */
+@Target({ElementType.TYPE})
+@Retention(RetentionPolicy.RUNTIME)
+@JacksonAnnotation
+public @interface JsonIgnoreProperties
+{
+    /**
+     * Names of properties to ignore.
+     */
+    public String[] value() default { };
+
+    /**
+     * Property that defines whether it is ok to just ignore any
+     * unrecognized properties during deserialization.
+     * If true, all properties that are unrecognized -- that is,
+     * there are no setters or creators that accept them -- are
+     * ignored without warnings (although handlers for unknown
+     * properties, if any, will still be called) without
+     * exception.
+     *<p>
+     * Does not have any effect on serialization.
+     */
+    public boolean ignoreUnknown() default false;
+}

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

@@ -0,0 +1,33 @@
+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 that indicates that all properties of annotated
+ * type are to be ignored during serialization and deserialization.
+ *<p>
+ * Note: annotation does have boolean 'value' property (which defaults
+ * to 'true'), so that it is actually possible to override value
+ * using mix-in annotations.
+ * 
+ * @since 1.7
+ */
+@Target({ElementType.TYPE})
+@Retention(RetentionPolicy.RUNTIME)
+@JacksonAnnotation
+public @interface JsonIgnoreType
+{
+    /**
+     * Optional argument that defines whether this annotation is active
+     * or not. The only use for value 'false' if for overriding purposes
+     * (which is not needed often); most likely it is needed for use
+     * with "mix-in annotations" ("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/JsonManagedReference.java

@@ -0,0 +1,41 @@
+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 used to indicate that annotated property is part of
+ * two-way linkage between fields; and that its role is "parent" (or "forward") link.
+ * Value type (class) of property must have a single compatible property annotated with
+ * {@link JsonBackReference}. Linkage is handled such that the property
+ * annotated with this annotation is handled normally (serialized normally, no
+ * special handling for deserialization); it is the matching back reference
+ * that requires special handling
+ *<p>
+ * All references have logical name to allow handling multiple linkages; typical case
+ * would be that where nodes have both parent/child and sibling linkages. If so,
+ * pairs of references should be named differently.
+ * It is an error for a class too have multiple managed references with same name,
+ * even if types pointed are different.
+ *<p>
+ * Note: only methods and fields can be annotated with this annotation: constructor
+ * arguments should NOT be annotated, as they can not be either managed or back
+ * references.
+ * 
+ * @author tatu
+ */
+@Target({ElementType.FIELD, ElementType.METHOD})
+@Retention(RetentionPolicy.RUNTIME)
+@JacksonAnnotation
+public @interface JsonManagedReference
+{
+    /**
+     * Logical have for the reference property pair; used to link managed and
+     * back references. Default name can be used if there is just single
+     * reference pair (for example, node class that just has parent/child linkage,
+     * consisting of one managed reference and matching back reference)
+     */
+    public String value() default "defaultReference";
+}