testautoa 0.4.0.pre16

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

@@ -0,0 +1,383 @@
+package sh.calaba.org.codehaus.jackson.node;
+
+import java.io.IOException;
+import java.math.BigDecimal;
+import java.math.BigInteger;
+
+import sh.calaba.org.codehaus.jackson.*;
+import sh.calaba.org.codehaus.jackson.impl.JsonParserMinimalBase;
+
+/**
+ * Facade over {@link JsonNode} that implements {@link JsonParser} to allow
+ * accessing contents of JSON tree in alternate form (stream of tokens).
+ * Useful when a streaming source is expected by code, such as data binding
+ * functionality.
+ * 
+ * @author tatu
+ * 
+ * @since 1.3
+ */
+public class TreeTraversingParser extends JsonParserMinimalBase
+{
+    /*
+    /**********************************************************
+    /* Configuration
+    /**********************************************************
+     */
+
+    protected ObjectCodec _objectCodec;
+
+    /**
+     * Traversal context within tree
+     */
+    protected NodeCursor _nodeCursor;
+
+    /*
+    /**********************************************************
+    /* State
+    /**********************************************************
+     */
+
+    /**
+     * Sometimes parser needs to buffer a single look-ahead token; if so,
+     * it'll be stored here. This is currently used for handling 
+     */
+    protected JsonToken _nextToken;
+
+    /**
+     * Flag needed to handle recursion into contents of child
+     * Array/Object nodes.
+     */
+    protected boolean _startContainer;
+    
+    /**
+     * Flag that indicates whether parser is closed or not. Gets
+     * set when parser is either closed by explicit call
+     * ({@link #close}) or when end-of-input is reached.
+     */
+    protected boolean _closed;
+
+    /*
+    /**********************************************************
+    /* Life-cycle
+    /**********************************************************
+     */
+
+    public TreeTraversingParser(JsonNode n) { this(n, null); }
+
+    public TreeTraversingParser(JsonNode n, ObjectCodec codec)
+    {
+        super(0);
+        _objectCodec = codec;
+        if (n.isArray()) {
+            _nextToken = JsonToken.START_ARRAY;
+            _nodeCursor = new NodeCursor.Array(n, null);
+        } else if (n.isObject()) {
+            _nextToken = JsonToken.START_OBJECT;
+            _nodeCursor = new NodeCursor.Object(n, null);
+        } else { // value node
+            _nodeCursor = new NodeCursor.RootValue(n, null);
+        }
+    }
+
+    @Override
+    public void setCodec(ObjectCodec c) {
+        _objectCodec = c;
+    }
+
+    @Override
+    public ObjectCodec getCodec() {
+        return _objectCodec;
+    }
+
+    /*
+    /**********************************************************
+    /* Closeable implementation
+    /**********************************************************
+     */
+
+    @Override
+    public void close() throws IOException
+    {
+        if (!_closed) {
+            _closed = true;
+            _nodeCursor = null;
+            _currToken = null;
+        }
+    }
+
+    /*
+    /**********************************************************
+    /* Public API, traversal
+    /**********************************************************
+     */
+
+    @Override
+    public JsonToken nextToken() throws IOException, JsonParseException
+    {
+        if (_nextToken != null) {
+            _currToken = _nextToken;
+            _nextToken = null;
+            return _currToken;
+        }
+        // are we to descend to a container child?
+        if (_startContainer) {
+            _startContainer = false;
+            // minor optimization: empty containers can be skipped
+            if (!_nodeCursor.currentHasChildren()) {
+                _currToken = (_currToken == JsonToken.START_OBJECT) ?
+                    JsonToken.END_OBJECT : JsonToken.END_ARRAY;
+                return _currToken;
+            }
+            _nodeCursor = _nodeCursor.iterateChildren();
+            _currToken = _nodeCursor.nextToken();
+            if (_currToken == JsonToken.START_OBJECT || _currToken == JsonToken.START_ARRAY) {
+                _startContainer = true;
+            }
+            return _currToken;
+        }
+        // No more content?
+        if (_nodeCursor == null) {
+            _closed = true; // if not already set
+            return null;
+        }
+        // Otherwise, next entry from current cursor
+        _currToken = _nodeCursor.nextToken();
+        if (_currToken != null) {
+            if (_currToken == JsonToken.START_OBJECT || _currToken == JsonToken.START_ARRAY) {
+                _startContainer = true;
+            }
+            return _currToken;
+        }
+        // null means no more children; need to return end marker
+        _currToken = _nodeCursor.endToken();
+        _nodeCursor = _nodeCursor.getParent();
+        return _currToken;
+    }
+    
+    // default works well here:
+    //public JsonToken nextValue() throws IOException, JsonParseException
+
+    @Override
+    public JsonParser skipChildren() throws IOException, JsonParseException
+    {
+        if (_currToken == JsonToken.START_OBJECT) {
+            _startContainer = false;
+            _currToken = JsonToken.END_OBJECT;
+        } else if (_currToken == JsonToken.START_ARRAY) {
+            _startContainer = false;
+            _currToken = JsonToken.END_ARRAY;
+        }
+        return this;
+    }
+
+    @Override
+    public boolean isClosed() {
+        return _closed;
+    }
+
+    /*
+    /**********************************************************
+    /* Public API, token accessors
+    /**********************************************************
+     */
+
+    @Override
+    public String getCurrentName() {
+        return (_nodeCursor == null) ? null : _nodeCursor.getCurrentName();
+    }
+
+    @Override
+    public JsonStreamContext getParsingContext() {
+        return _nodeCursor;
+    }
+
+    @Override
+    public JsonLocation getTokenLocation() {
+        return JsonLocation.NA;
+    }
+
+    @Override
+    public JsonLocation getCurrentLocation() {
+        return JsonLocation.NA;
+    }
+
+    /*
+    /**********************************************************
+    /* Public API, access to textual content
+    /**********************************************************
+     */
+
+    @Override
+    public String getText()
+    {
+        if (_closed) {
+            return null;
+        }
+        // need to separate handling a bit...
+        switch (_currToken) {
+        case FIELD_NAME:
+            return _nodeCursor.getCurrentName();
+        case VALUE_STRING:
+            return currentNode().getTextValue();
+        case VALUE_NUMBER_INT:
+        case VALUE_NUMBER_FLOAT:
+            return String.valueOf(currentNode().getNumberValue());
+        case VALUE_EMBEDDED_OBJECT:
+            JsonNode n = currentNode();
+            if (n != null && n.isBinary()) {
+                // this will convert it to base64
+                return n.asText();
+            }
+        }
+
+        return (_currToken == null) ? null : _currToken.asString();
+    }
+
+    @Override
+    public char[] getTextCharacters() throws IOException, JsonParseException {
+        return getText().toCharArray();
+    }
+
+    @Override
+    public int getTextLength() throws IOException, JsonParseException {
+        return getText().length();
+    }
+
+    @Override
+    public int getTextOffset() throws IOException, JsonParseException {
+        return 0;
+    }
+
+    @Override
+    public boolean hasTextCharacters() {
+        // generally we do not have efficient access as char[], hence:
+        return false;
+    }
+    
+    /*
+    /**********************************************************
+    /* Public API, typed non-text access
+    /**********************************************************
+     */
+
+    //public byte getByteValue() throws IOException, JsonParseException
+
+    @Override
+    public NumberType getNumberType() throws IOException, JsonParseException {
+        JsonNode n = currentNumericNode();
+        return (n == null) ? null : n.getNumberType();
+    }
+
+    @Override
+    public BigInteger getBigIntegerValue() throws IOException, JsonParseException
+    {
+        return currentNumericNode().getBigIntegerValue();
+    }
+
+    @Override
+    public BigDecimal getDecimalValue() throws IOException, JsonParseException {
+        return currentNumericNode().getDecimalValue();
+    }
+
+    @Override
+    public double getDoubleValue() throws IOException, JsonParseException {
+        return currentNumericNode().getDoubleValue();
+    }
+
+    @Override
+    public float getFloatValue() throws IOException, JsonParseException {
+        return (float) currentNumericNode().getDoubleValue();
+    }
+
+    @Override
+    public long getLongValue() throws IOException, JsonParseException {
+        return currentNumericNode().getLongValue();
+    }
+
+    @Override
+    public int getIntValue() throws IOException, JsonParseException {
+        return currentNumericNode().getIntValue();
+    }
+
+    @Override
+    public Number getNumberValue() throws IOException, JsonParseException {
+        return currentNumericNode().getNumberValue();
+    }
+
+    @Override
+    public Object getEmbeddedObject()
+    {
+        if (!_closed) {
+            JsonNode n = currentNode();
+            if (n != null) {
+                if (n.isPojo()) {
+                    return ((POJONode) n).getPojo();
+                }
+                if (n.isBinary()) {
+                    return ((BinaryNode) n).getBinaryValue();
+                }
+            }
+        }
+        return null;
+    }
+
+    /*
+    /**********************************************************
+    /* Public API, typed binary (base64) access
+    /**********************************************************
+     */
+
+    @Override
+    public byte[] getBinaryValue(Base64Variant b64variant)
+        throws IOException, JsonParseException
+    {
+        // Multiple possibilities...
+        JsonNode n = currentNode();
+        if (n != null) { // binary node?
+            byte[] data = n.getBinaryValue();
+            // (or TextNode, which can also convert automatically!)
+            if (data != null) {
+                return data;
+            }
+            // Or maybe byte[] as POJO?
+            if (n.isPojo()) {
+                Object ob = ((POJONode) n).getPojo();
+                if (ob instanceof byte[]) {
+                    return (byte[]) ob;
+                }
+            }
+        }
+        // otherwise return null to mark we have no binary content
+        return null;
+    }
+
+    /*
+    /**********************************************************
+    /* Internal methods
+    /**********************************************************
+     */
+
+    protected JsonNode currentNode() {
+        if (_closed || _nodeCursor == null) {
+            return null;
+        }
+        return _nodeCursor.currentNode();
+    }
+
+    protected JsonNode currentNumericNode()
+        throws JsonParseException
+    {
+        JsonNode n = currentNode();
+        if (n == null || !n.isNumber()) {
+            JsonToken t = (n == null) ? null : n.asToken();
+            throw _constructError("Current token ("+t+") not numeric, can not use numeric value accessors");
+        }
+        return n;
+    }
+
+    @Override
+    protected void _handleEOF() throws JsonParseException {
+        _throwInternal(); // should never get called
+    }
+}

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

@@ -0,0 +1,58 @@
+package sh.calaba.org.codehaus.jackson.node;
+
+import java.io.IOException;
+
+import sh.calaba.org.codehaus.jackson.JsonGenerator;
+import sh.calaba.org.codehaus.jackson.JsonNode;
+import sh.calaba.org.codehaus.jackson.JsonProcessingException;
+import sh.calaba.org.codehaus.jackson.JsonToken;
+import sh.calaba.org.codehaus.jackson.map.SerializerProvider;
+import sh.calaba.org.codehaus.jackson.map.TypeSerializer;
+
+/**
+ * This intermediate base class is used for all leaf nodes, that is,
+ * all non-container (array or object) nodes, except for the
+ * "missing node".
+ */
+public abstract class ValueNode
+    extends BaseJsonNode
+{
+    protected ValueNode() { }
+
+    @Override
+    public boolean isValueNode() { return true; }
+
+    @Override
+    public abstract JsonToken asToken();
+
+    @Override
+    public void serializeWithType(JsonGenerator jg, SerializerProvider provider,
+            TypeSerializer typeSer)
+        throws IOException, JsonProcessingException
+    {
+        typeSer.writeTypePrefixForScalar(this, jg);
+        serialize(jg, provider);
+        typeSer.writeTypeSuffixForScalar(this, jg);
+    }
+    
+    /*
+    /**********************************************************************
+    /* Public API, path handling
+    /**********************************************************************
+     */
+
+    @Override
+    public JsonNode path(String fieldName) { return MissingNode.getInstance(); }
+
+    @Override
+    public JsonNode path(int index) { return MissingNode.getInstance(); }
+
+    /*
+    /**********************************************************************
+    /* Base impls for standard methods
+    /**********************************************************************
+     */
+
+    @Override
+    public String toString() { return asText(); }
+}

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

@@ -0,0 +1,8 @@
+/**
+ * Contains concrete {@link sh.calaba.org.codehaus.jackson.JsonNode} implementations
+ * Jackson uses for the Tree model.
+ * These classes are public since concrete type will be needed
+ * for most operations that modify node trees. For read-only access concrete
+ * types are usually not needed.
+ */
+package sh.calaba.org.codehaus.jackson.node;

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

@@ -0,0 +1,30 @@
+/**
+ * Main public API classes of the core streaming JSON
+ * processor: most importantly {@link sh.calaba.org.codehaus.jackson.JsonFactory}
+ * used for constructing
+ * JSON parser ({@link sh.calaba.org.codehaus.jackson.JsonParser})
+ * and generator
+ * ({@link sh.calaba.org.codehaus.jackson.JsonParser})
+ * instances.
+ * <p>
+ * Public API of the higher-level mapping interfaces ("Mapping API")
+ * is found from
+ * under {@link sh.calaba.org.codehaus.jackson.map} and not included here,
+ * except for following base interfaces:
+ * <ul>
+ *<li>{@link sh.calaba.org.codehaus.jackson.JsonNode} is included
+ *within Streaming API to support integration of the Tree Model
+ *(which is based on <code>JsonNode</code>) with the basic
+ *parsers and generators (iff using mapping-supporting factory: which
+ *is part of Mapping API, not core)
+ *  </li>
+ *<li>{@link sh.calaba.org.codehaus.jackson.ObjectCodec} is included so that
+ *  reference to the object capable of serializing/deserializing
+ *  Objects to/from JSON (usually, {@link sh.calaba.org.codehaus.jackson.map.ObjectMapper})
+ *  can be exposed, without adding direct dependency to implementation.
+ *  </li>
+ *</ul>
+ * </ul>
+ */
+
+package sh.calaba.org.codehaus.jackson;

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

@@ -0,0 +1,82 @@
+package sh.calaba.org.codehaus.jackson.schema;
+
+import sh.calaba.org.codehaus.jackson.JsonNode;
+import sh.calaba.org.codehaus.jackson.annotate.JsonCreator;
+import sh.calaba.org.codehaus.jackson.annotate.JsonValue;
+import sh.calaba.org.codehaus.jackson.node.JsonNodeFactory;
+import sh.calaba.org.codehaus.jackson.node.ObjectNode;
+
+/**
+ * A {@link sh.calaba.org.codehaus.jackson.JsonNode} that represents a JSON-Schema instance.
+ *
+ * @author Ryan Heaton
+ * @see <a href="http://json-schema.org/">JSON Schema</a>
+ */
+public class JsonSchema
+{
+    private final ObjectNode schema;
+
+    /**
+     * Main constructor for schema instances.
+     *<p>
+     * This is the creator constructor used by Jackson itself when
+     * deserializing instances. It is so-called delegating creator, 
+     * meaning that its argument will be bound by Jackson before
+     * constructor gets called.
+     */
+    @JsonCreator
+    public JsonSchema(ObjectNode schema)
+    {
+        this.schema = schema;
+    }
+
+    /**
+     * Method for accessing root JSON object of the contained schema.
+     *<p>
+     * Note: this method is specified with {@link JsonValue} annotation
+     * to represent serialization to use; same as if explicitly
+     * serializing returned object.
+     *
+     * @return Root node of the schema tree
+     */
+    @JsonValue
+    public ObjectNode getSchemaNode()
+    {
+        return schema;
+    }
+
+    @Override
+    public String toString()
+    {
+        return this.schema.toString();
+    }
+
+    @Override
+    public boolean equals(Object o)
+    {
+        if (o == this) return true;
+        if (o == null) return false;
+        if (!(o instanceof JsonSchema)) return false;
+
+        JsonSchema other = (JsonSchema) o;
+        if (schema == null) {
+            return other.schema == null;
+        }
+        return schema.equals(other.schema);
+    }
+
+    /**
+     * Get the default schema node.
+     *
+     * @return The default schema node.
+     */
+    public static JsonNode getDefaultSchemaNode()
+    {
+        ObjectNode objectNode = JsonNodeFactory.instance.objectNode();
+        objectNode.put("type", "any");
+        // "required" is false by default, no need to include
+        //objectNode.put("required", false);
+        return objectNode;
+    }
+
+}

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

@@ -0,0 +1,46 @@
+package sh.calaba.org.codehaus.jackson.schema;
+
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Retention;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Target;
+
+import sh.calaba.org.codehaus.jackson.annotate.JacksonAnnotation;
+
+/**
+ * Annotation that can be used to define JSON Schema definition for
+ * the annotated class.
+ *<p>
+ * Note that annotation is often not needed: for example, regular
+ * Jackson beans that Jackson can introspect can be used without
+ * annotations, to produce JSON schema definition.
+ * 
+ * @author Ryan Heaton
+ */
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@JacksonAnnotation
+public @interface JsonSerializableSchema
+{
+    /**
+     * The schema type for this JsonSerializable instance.
+     * Possible values: "string", "number", "boolean", "object", "array", "null", "any"
+     *
+     * @return The schema type for this JsonSerializable instance.
+     */
+    String schemaType() default "any";
+
+    /**
+     * If the schema type is "object", the node that defines the properties of the object.
+     *
+     * @return The node representing the schema properties, or "##irrelevant" if irrelevant.
+     */
+    String schemaObjectPropertiesDefinition() default "##irrelevant";
+
+    /**
+     * If the schema type if "array", the node that defines the schema for the items in the array.
+     *
+     * @return The schema for the items in the array, or "##irrelevant" if irrelevant.
+     */
+    String schemaItemDefinition() default "##irrelevant";
+}

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

@@ -0,0 +1,25 @@
+package sh.calaba.org.codehaus.jackson.schema;
+
+import sh.calaba.org.codehaus.jackson.JsonNode;
+import sh.calaba.org.codehaus.jackson.map.JsonMappingException;
+import sh.calaba.org.codehaus.jackson.map.SerializerProvider;
+
+import java.lang.reflect.Type;
+
+/**
+ * Marker interface for schema-aware serializers.
+ *
+ * @author Ryan Heaton
+ */
+public interface SchemaAware
+{
+    /**
+     * Get the representation of the schema to which this serializer will conform.
+     *
+     * @param provider The serializer provider.
+     * @param typeHint A hint about the type.
+     * @return <a href="http://json-schema.org/">Json-schema</a> for this serializer.
+     */
+    JsonNode getSchema(SerializerProvider provider, Type typeHint)
+            throws JsonMappingException;
+}

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

@@ -0,0 +1,5 @@
+/**
+ * Classes needed for JSON schema support (currently just ability
+ * to generate schemas using serialization part of data mapping)
+ */
+package sh.calaba.org.codehaus.jackson.schema;