testautoa 0.4.0.pre16

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

@@ -0,0 +1,122 @@
+package sh.calaba.org.codehaus.jackson.node;
+
+import java.io.IOException;
+import java.util.List;
+
+import sh.calaba.org.codehaus.jackson.*;
+import sh.calaba.org.codehaus.jackson.map.JsonSerializableWithType;
+import sh.calaba.org.codehaus.jackson.map.SerializerProvider;
+import sh.calaba.org.codehaus.jackson.map.TypeSerializer;
+
+/**
+ * Abstract base class common to all standard {@link JsonNode}
+ * implementations.
+ * The main addition here is that we declare that sub-classes must
+ * implement {@link JsonSerializableWithType}.
+ * This simplifies object mapping
+ * aspects a bit, as no external serializers are needed.
+ */
+public abstract class BaseJsonNode
+    extends JsonNode
+    implements JsonSerializableWithType
+{
+    protected BaseJsonNode() { }
+
+    /*
+    /**********************************************************
+    /* Basic definitions for non-container types
+    /**********************************************************
+     */
+
+    @Override
+    public JsonNode findValue(String fieldName) {
+        return null;
+    }
+
+    @Override
+    public final JsonNode findPath(String fieldName)
+    {
+        JsonNode value = findValue(fieldName);
+        if (value == null) {
+            return MissingNode.getInstance();
+        }
+        return value;
+    }
+    
+    // note: co-variant return type
+    @Override
+    public ObjectNode findParent(String fieldName) {
+        return null;
+    }
+
+    @Override
+    public List<JsonNode> findValues(String fieldName, List<JsonNode> foundSoFar) {
+        return foundSoFar;
+    }
+
+    @Override
+    public List<String> findValuesAsText(String fieldName, List<String> foundSoFar) {
+        return foundSoFar;
+    }
+    
+    @Override
+    public List<JsonNode> findParents(String fieldName, List<JsonNode> foundSoFar) {
+        return foundSoFar;
+    }
+    
+    /*
+    /**********************************************************
+    /* Support for traversal-as-stream
+    /**********************************************************
+     */
+
+    @Override
+    public JsonParser traverse() {
+        return new TreeTraversingParser(this);
+    }
+
+    /**
+     * Method that can be used for efficient type detection
+     * when using stream abstraction for traversing nodes.
+     * Will return the first {@link JsonToken} that equivalent
+     * stream event would produce (for most nodes there is just
+     * one token but for structured/container types multiple)
+     *
+     * @since 1.3
+     */
+    @Override
+    public abstract JsonToken asToken();
+
+    /**
+     * @since 1.3
+     */
+    @Override
+    public JsonParser.NumberType getNumberType() {
+        // most types non-numeric, so:
+        return null; 
+    }
+
+    /*
+    /**********************************************************
+    /* JsonSerializable
+    /**********************************************************
+     */
+
+    /**
+     * Method called to serialize node instances using given generator.
+     */
+    @SuppressWarnings("deprecation")
+    @Override
+    public abstract void serialize(JsonGenerator jgen, SerializerProvider provider)
+        throws IOException, JsonProcessingException;
+
+    /**
+     * Type information is needed, even if JsonNode instances are "plain" JSON,
+     * since they may be mixed with other types.
+     */
+    @Override
+    public abstract void serializeWithType(JsonGenerator jgen, SerializerProvider provider,
+            TypeSerializer typeSer)
+        throws IOException, JsonProcessingException;
+}
+

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

@@ -0,0 +1,104 @@
+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.map.SerializerProvider;
+
+/**
+ * Numeric node that contains simple 64-bit integer values.
+ */
+public final class BigIntegerNode
+    extends NumericNode
+{
+    final protected BigInteger _value;
+
+    /*
+    /**********************************************************
+    /* Construction
+    /**********************************************************
+     */
+
+    public BigIntegerNode(BigInteger v) { _value = v; }
+
+    public static BigIntegerNode valueOf(BigInteger v) { return new BigIntegerNode(v); }
+
+    /* 
+    /**********************************************************
+    /* Overrridden JsonNode methods
+    /**********************************************************
+     */
+
+    @Override
+    public JsonToken asToken() { return JsonToken.VALUE_NUMBER_INT; }
+
+    @Override
+    public JsonParser.NumberType getNumberType() { return JsonParser.NumberType.BIG_INTEGER; }
+
+    @Override
+    public boolean isIntegralNumber() { return true; }
+
+    @Override
+    public boolean isBigInteger() { return true; }
+
+    @Override
+    public Number getNumberValue() {
+        return _value;
+    }
+
+    @Override
+    public int getIntValue() { return _value.intValue(); }
+
+    @Override
+    public long getLongValue() { return _value.longValue(); }
+
+    @Override
+    public BigInteger getBigIntegerValue() { return _value; }
+
+    @Override
+    public double getDoubleValue() { return _value.doubleValue(); }
+
+    @Override
+    public BigDecimal getDecimalValue() { return new BigDecimal(_value); }
+
+    /* 
+    /**********************************************************
+    /* General type coercions
+    /**********************************************************
+     */
+    
+    @Override
+    public String asText() {
+        return _value.toString();
+    }
+
+    @Override
+    public boolean asBoolean(boolean defaultValue) {
+        return !BigInteger.ZERO.equals(_value);
+    }
+    
+    @Override
+    public final void serialize(JsonGenerator jg, SerializerProvider provider)
+        throws IOException, JsonProcessingException
+    {
+        jg.writeNumber(_value);
+    }
+
+    @Override
+    public boolean equals(Object o)
+    {
+        if (o == this) return true;
+        if (o == null) return false;
+        if (o.getClass() != getClass()) { // final class, can do this
+            return false;
+        }
+        return ((BigIntegerNode) o)._value == _value;
+    }
+
+    @Override
+    public int hashCode() {
+        return _value.hashCode();
+    }
+}

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

@@ -0,0 +1,136 @@
+package sh.calaba.org.codehaus.jackson.node;
+
+import java.io.IOException;
+import java.util.Arrays;
+
+import sh.calaba.org.codehaus.jackson.*;
+import sh.calaba.org.codehaus.jackson.map.SerializerProvider;
+
+/**
+ * Value node that contains Base64 encoded binary value, which will be
+ * output and stored as Json String value.
+ */
+public final class BinaryNode
+    extends ValueNode
+{
+    final static BinaryNode EMPTY_BINARY_NODE = new BinaryNode(new byte[0]);
+
+    final byte[] _data;
+
+    /* 
+    /**********************************************************
+    /* Construction
+    /**********************************************************
+     */
+    
+    public BinaryNode(byte[] data)
+    {
+        _data = data;
+    }
+
+    public BinaryNode(byte[] data, int offset, int length)
+    {
+        if (offset == 0 && length == data.length) {
+            _data = data;
+        } else {
+            _data = new byte[length];
+            System.arraycopy(data, offset, _data, 0, length);
+        }
+    }
+
+    public static BinaryNode valueOf(byte[] data)
+    {
+        if (data == null) {
+            return null;
+        }
+        if (data.length == 0) {
+            return EMPTY_BINARY_NODE;
+        }
+        return new BinaryNode(data);
+    }
+
+    public static BinaryNode valueOf(byte[] data, int offset, int length)
+    {
+        if (data == null) {
+            return null;
+        }
+        if (length == 0) {
+            return EMPTY_BINARY_NODE;
+        }
+        return new BinaryNode(data, offset, length);
+    }
+
+    /* 
+    /**********************************************************
+    /* General type coercions
+    /**********************************************************
+     */
+    
+    @Override
+    public JsonToken asToken() {
+        /* No distinct type; could use one for textual values,
+         * but given that it's not in text form at this point,
+         * embedded-object is closest
+         */
+        return JsonToken.VALUE_EMBEDDED_OBJECT;
+    }
+
+    @Override
+    public boolean isBinary() { return true; }
+
+    /**
+     *<p>
+     * Note: caller is not to modify returned array in any way, since
+     * it is not a copy but reference to the underlying byte array.
+     */
+    @Override
+    public byte[] getBinaryValue() { return _data; }
+
+    /**
+     * Hmmh. This is not quite as efficient as using {@link #serialize},
+     * but will work correctly.
+     */
+    @Override
+    public String asText() {
+        return Base64Variants.getDefaultVariant().encode(_data, false);
+    }
+
+    /*
+    /**********************************************************
+    /* Public API, serialization
+    /**********************************************************
+     */
+    
+    @Override
+    public final void serialize(JsonGenerator jg, SerializerProvider provider)
+        throws IOException, JsonProcessingException
+    {
+        jg.writeBinary(_data);
+    }
+
+    @Override
+    public boolean equals(Object o)
+    {
+        if (o == this) return true;
+        if (o == null) return false;
+        if (o.getClass() != getClass()) { // final class, can do this
+            return false;
+        }
+        return Arrays.equals(((BinaryNode) o)._data, _data);
+    }
+
+    @Override
+    public int hashCode() {
+        return (_data == null) ? -1 : _data.length;
+    }
+
+    /**
+     * Different from other values, since contents need to be surrounded
+     * by (double) quotes.
+     */
+    @Override
+    public String toString()
+    {
+        return Base64Variants.getDefaultVariant().encode(_data, true);
+    }
+}

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

@@ -0,0 +1,84 @@
+package sh.calaba.org.codehaus.jackson.node;
+
+import java.io.IOException;
+
+import sh.calaba.org.codehaus.jackson.*;
+import sh.calaba.org.codehaus.jackson.map.SerializerProvider;
+
+/**
+ * This concrete value class is used to contain boolean (true / false)
+ * values. Only two instances are ever created, to minimize memory
+ * usage
+ */
+public final class BooleanNode
+    extends ValueNode
+{
+    // // Just need two instances...
+
+    public final static BooleanNode TRUE = new BooleanNode();
+    public final static BooleanNode FALSE = new BooleanNode();
+
+    private BooleanNode() { }
+
+    public static BooleanNode getTrue() { return TRUE; }
+    public static BooleanNode getFalse() { return FALSE; }
+
+    public static BooleanNode valueOf(boolean b) { return b ? TRUE : FALSE; }
+
+    // Interesting... two choices...
+    @Override public JsonToken asToken() {
+        return (this == TRUE) ? JsonToken.VALUE_TRUE : JsonToken.VALUE_FALSE;
+    }
+
+    @Override
+    public boolean isBoolean() { return true; }
+
+    @Override
+    public boolean getBooleanValue() {
+        return (this == TRUE);
+    }
+
+    @Override
+    public String asText() {
+        return (this == TRUE) ? "true" : "false";
+    }
+
+    @Override
+    public boolean asBoolean() {
+        return (this == TRUE);
+    }
+
+    @Override
+    public boolean asBoolean(boolean defaultValue) {
+        return (this == TRUE);
+    }
+    
+    @Override
+    public int asInt(int defaultValue) {
+        return (this == TRUE) ? 1 : 0;
+    }
+    @Override
+    public long asLong(long defaultValue) {
+        return (this == TRUE) ? 1L : 0L;
+    }
+    @Override
+    public double asDouble(double defaultValue) {
+        return (this == TRUE) ? 1.0 : 0.0;
+    }
+    
+    @Override
+    public final void serialize(JsonGenerator jg, SerializerProvider provider)
+        throws IOException, JsonProcessingException
+    {
+        jg.writeBoolean(this == TRUE);
+    }
+
+    @Override
+    public boolean equals(Object o)
+    {
+        /* Since there are only ever two instances in existence
+         * can do identity comparison
+         */
+        return (o == this);
+    }
+}

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

@@ -0,0 +1,185 @@
+package sh.calaba.org.codehaus.jackson.node;
+
+import java.math.BigDecimal;
+import java.util.Iterator;
+import java.util.List;
+import java.util.NoSuchElementException;
+
+import sh.calaba.org.codehaus.jackson.JsonNode;
+import sh.calaba.org.codehaus.jackson.JsonToken;
+
+/**
+ * This intermediate base class is used for all container nodes,
+ * specifically, array and object nodes.
+ */
+public abstract class ContainerNode
+    extends BaseJsonNode
+{
+    /**
+     * We will keep a reference to the Object (usually TreeMapper)
+     * that can construct instances of nodes to add to this container
+     * node.
+     */
+    JsonNodeFactory _nodeFactory;
+
+    protected ContainerNode(JsonNodeFactory nc)
+    {
+        _nodeFactory = nc;
+    }
+
+    @Override
+    public boolean isContainerNode() { return true; }
+
+    @Override
+    public abstract JsonToken asToken();
+
+    /* NOTE: must have separate implementations since semantics have
+     * slight difference; deprecated method must return null,
+     * new method empty string.
+     */
+
+    @SuppressWarnings("deprecation")
+    @Override
+    public String getValueAsText() { return null; }
+    
+    
+    @Override
+    public String asText() { return ""; }
+
+    /*
+    /**********************************************************
+    /* Find methods; made abstract again to ensure implementation
+    /**********************************************************
+     */
+
+    @Override
+    public abstract JsonNode findValue(String fieldName);
+    
+    @Override
+    public abstract ObjectNode findParent(String fieldName);
+
+    @Override
+    public abstract List<JsonNode> findValues(String fieldName, List<JsonNode> foundSoFar);
+    
+    @Override
+    public abstract List<JsonNode> findParents(String fieldName, List<JsonNode> foundSoFar);
+
+    @Override
+    public abstract List<String> findValuesAsText(String fieldName, List<String> foundSoFar);
+    
+    /*
+    /**********************************************************
+    /* Methods reset as abstract to force real implementation
+    /**********************************************************
+     */
+
+    @Override
+    public abstract int size();
+
+    @Override
+    public abstract JsonNode get(int index);
+
+    @Override
+    public abstract JsonNode get(String fieldName);
+
+    /*
+    /**********************************************************
+    /* NodeCreator implementation, just dispatch to
+    /* the real creator
+    /**********************************************************
+     */
+
+    /**
+     * Factory method that constructs and returns an empty {@link ArrayNode}
+     * Construction is done using registered {@link JsonNodeFactory}.
+     */
+    public final ArrayNode arrayNode() { return _nodeFactory.arrayNode(); }
+
+    /**
+     * Factory method that constructs and returns an empty {@link ObjectNode}
+     * Construction is done using registered {@link JsonNodeFactory}.
+     */
+    public final ObjectNode objectNode() { return _nodeFactory.objectNode(); }
+
+    public final NullNode nullNode() { return _nodeFactory.nullNode(); }
+
+    public final BooleanNode booleanNode(boolean v) { return _nodeFactory.booleanNode(v); }
+
+    public final NumericNode numberNode(byte v) { return _nodeFactory.numberNode(v); }
+    public final NumericNode numberNode(short v) { return _nodeFactory.numberNode(v); }
+    public final NumericNode numberNode(int v) { return _nodeFactory.numberNode(v); }
+    public final NumericNode numberNode(long v) { return _nodeFactory.numberNode(v); }
+    public final NumericNode numberNode(float v) { return _nodeFactory.numberNode(v); }
+    public final NumericNode numberNode(double v) { return _nodeFactory.numberNode(v); }
+    public final NumericNode numberNode(BigDecimal v) { return (_nodeFactory.numberNode(v)); }
+
+    public final TextNode textNode(String text) { return _nodeFactory.textNode(text); }
+
+    public final BinaryNode binaryNode(byte[] data) { return _nodeFactory.binaryNode(data); }
+    public final BinaryNode binaryNode(byte[] data, int offset, int length) { return _nodeFactory.binaryNode(data, offset, length); }
+
+    public final POJONode POJONode(Object pojo) { return _nodeFactory.POJONode(pojo); }
+
+    /*
+    /**********************************************************
+    /* Common mutators
+    /**********************************************************
+     */
+
+    /**
+     * Method for removing all children container has (if any)
+     *
+     * @return Container node itself (to allow method call chaining)
+     *
+     * @since 1.3
+     */
+    public abstract ContainerNode removeAll();
+
+    /*
+    /**********************************************************
+    /* Helper classes
+    /**********************************************************
+     */
+
+    protected static class NoNodesIterator
+        implements Iterator<JsonNode>
+    {
+        final static NoNodesIterator instance = new NoNodesIterator();
+
+        private NoNodesIterator() { }
+
+        public static NoNodesIterator instance() { return instance; }
+
+        @Override
+        public boolean hasNext() { return false; }
+        @Override
+        public JsonNode next() { throw new NoSuchElementException(); }
+
+        @Override
+        public void remove() {
+            // could as well throw IllegalOperationException?
+            throw new IllegalStateException();
+        }
+    }
+
+    protected static class NoStringsIterator
+        implements Iterator<String>
+    {
+        final static NoStringsIterator instance = new NoStringsIterator();
+
+        private NoStringsIterator() { }
+
+        public static NoStringsIterator instance() { return instance; }
+
+        @Override
+        public boolean hasNext() { return false; }
+        @Override
+        public String next() { throw new NoSuchElementException(); }
+
+        @Override
+        public void remove() {
+            // could as well throw IllegalOperationException?
+            throw new IllegalStateException();
+        }
+    }
+}