/** Unit test to check for regression of [JACKSON-18]. */
public void testSmallNumbers() throws Exception {
ObjectMapper mapper = new ObjectMapper();
ArrayNode root = mapper.createArrayNode();
for (int i = -20; i <= 20; ++i) {
JsonNode n = root.numberNode(i);
root.add(n);
// Hmmh. Not sure why toString() won't be triggered otherwise...
assertEquals(String.valueOf(i), n.toString());
}
// Loop over 2 different serialization methods
for (int type = 0; type < 2; ++type) {
StringWriter sw = new StringWriter();
if (type == 0) {
JsonGenerator gen = new JsonFactory().createGenerator(sw);
root.serialize(gen, null);
gen.close();
} else {
mapper.writeValue(sw, root);
}
String doc = sw.toString();
JsonParser p = new JsonFactory().createParser(new StringReader(doc));
assertEquals(JsonToken.START_ARRAY, p.nextToken());
for (int i = -20; i <= 20; ++i) {
assertEquals(JsonToken.VALUE_NUMBER_INT, p.nextToken());
assertEquals(i, p.getIntValue());
assertEquals("" + i, p.getText());
}
assertEquals(JsonToken.END_ARRAY, p.nextToken());
p.close();
}
}
public CallTwoArgBlockNode(
ISourcePosition position, Node receiverNode, String name, ArrayNode args, IterNode iter) {
super(position, receiverNode, name, args, iter);
assert args.size() == 2 : "args.size() is 2";
arg1 = args.get(0);
arg2 = args.get(1);
}
/** {@inheritDoc} */
@Override
public V remove(K key) {
Node node = find(key.hashCode());
if (node == null) return null;
if (node instanceof ArrayNode) return null;
KeyValueNode<V> kvNode = (KeyValueNode<V>) node;
V value = kvNode.value;
if (node.parent == null) {
// If parent is null, removing the root
root = null;
} else {
ArrayNode parent = node.parent;
// Remove child from parent
int position = getPosition(parent.height, node.key);
parent.removeChild(position);
// Go back up the tree, pruning any array nodes which no longer have children.
int numOfChildren = parent.getNumberOfChildren();
while (numOfChildren == 0) {
node = parent;
parent = node.parent;
if (parent == null) {
// Reached root of the tree, need to stop
root = null;
break;
}
position = getPosition(parent.height, node.key);
parent.removeChild(position);
numOfChildren = parent.getNumberOfChildren();
}
}
size--;
return value;
}
private static <K, V> String getString(
Node parent, Node node, int height, String prefix, boolean isTail) {
StringBuilder builder = new StringBuilder();
if (node instanceof KeyValueNode) {
KeyValueNode<V> kvNode = (KeyValueNode<V>) node;
int position = getPosition(height, kvNode.key);
builder.append(
prefix
+ (isTail ? "└── " : "├── ")
+ ((parent == null) ? null : toBinaryString(position))
+ "="
+ toBinaryString(kvNode.key)
+ "="
+ kvNode.value
+ "\n");
} else {
ArrayNode arrayNode = (ArrayNode) node;
int position = (arrayNode.parent == null) ? -1 : getPosition(height, arrayNode.key);
builder.append(
prefix
+ (isTail ? "└── " : "├── ")
+ ((parent == null) ? null : toBinaryString(position))
+ " height="
+ ((height < 0) ? null : height)
+ " bitmap="
+ toBinaryString(arrayNode.bitmap)
+ "\n");
List<Node> children = new LinkedList<Node>();
for (int i = 0; i < MAX_BITS; i++) {
Node child = arrayNode.getChild(i);
if (child != null) children.add(child);
}
for (int i = 0; i < (children.size() - 1); i++) {
builder.append(
getString(
arrayNode,
children.get(i),
height + 1,
prefix + (isTail ? " " : "│ "),
false));
}
if (children.size() >= 1) {
builder.append(
getString(
arrayNode,
children.get(children.size() - 1),
height + 1,
prefix + (isTail ? " " : "│ "),
true));
}
}
return builder.toString();
}
private void addToSet(java.util.Set<java.util.Map.Entry<K, V>> set, Node node) {
if (node instanceof KeyValueNode) {
KeyValueNode<V> kvNode = (KeyValueNode<V>) node;
set.add(new JavaCompatibleMapEntry<K, V>((K) new Integer(kvNode.key), kvNode.value));
} else if (node instanceof ArrayNode) {
ArrayNode arrayNode = (ArrayNode) node;
for (int i = 0; i < MAX_BITS; i++) {
Node child = arrayNode.getChild(i);
if (child != null) addToSet(set, child);
}
}
}
public String toJson(ObjectMapper mapper) {
ObjectNode rootNode = mapper.createObjectNode();
ArrayNode keysNode = rootNode.putArray("keys");
for (Object key : keys) {
keysNode.addPOJO(key);
}
try {
return mapper.writeValueAsString(rootNode);
} catch (Exception e) {
throw Exceptions.propagate(e);
}
}
private Node find(Node node, int key) {
if (node instanceof KeyValueNode) {
KeyValueNode<V> kvNode = (KeyValueNode<V>) node;
if (kvNode.key == key) return kvNode;
return null;
} else if (node instanceof ArrayNode) {
ArrayNode arrayNode = (ArrayNode) node;
int position = getPosition(arrayNode.height, key);
Node possibleNode = arrayNode.getChild(position);
if (possibleNode == null) return null;
return find(possibleNode, key);
}
return null;
}
private static <K, V> boolean validate(ArrayNode parent, ArrayNode node) {
if (parent != null) {
if (parent.key != (node.parent.key)) return false;
if (parent.height + 1 != node.height) return false;
}
int children = 0;
for (int i = 0; i < node.children.length; i++) {
Node child = node.children[i];
if (child != null) {
children++;
if (child instanceof KeyValueNode) {
KeyValueNode<V> kvChild = (KeyValueNode<V>) child;
if (!validate(node, kvChild)) return false;
} else if (child instanceof ArrayNode) {
ArrayNode arrayNode = (ArrayNode) child;
if (!validate(node, arrayNode)) return false;
} else {
return false;
}
}
}
boolean result = (children == node.getNumberOfChildren());
if (!result) {
return false;
}
return true;
}
public void testFromArray() throws Exception {
ObjectMapper mapper = new ObjectMapper();
ArrayNode root = mapper.createArrayNode();
root.add(TEXT1);
root.add(3);
ObjectNode obj = root.addObject();
obj.put(FIELD1, true);
obj.putArray(FIELD2);
root.add(false);
/* Ok, ready... let's serialize using one of two alternate
* methods: first preferred (using generator)
* (there are 2 variants here too)
*/
for (int i = 0; i < 2; ++i) {
StringWriter sw = new StringWriter();
if (i == 0) {
JsonGenerator gen = new JsonFactory().createGenerator(sw);
root.serialize(gen, null);
gen.close();
} else {
mapper.writeValue(sw, root);
}
verifyFromArray(sw.toString());
}
// And then convenient but less efficient alternative:
verifyFromArray(root.toString());
}
private V put(ArrayNode parent, Node node, byte height, int key, V value) {
if (node instanceof KeyValueNode) {
KeyValueNode<V> kvNode = (KeyValueNode<V>) node;
if (key == kvNode.key) {
// Key already exists as key-value pair, replace value
kvNode.value = value;
return value;
}
// Key already exists but doesn't match current key
KeyValueNode<V> oldParent = kvNode;
int newParentPosition = getPosition(height - 1, key);
int oldParentPosition = getPosition(height, oldParent.key);
int childPosition = getPosition(height, key);
ArrayNode newParent = new ArrayNode(parent, key, height);
newParent.parent = parent;
if (parent == null) {
// Only the root doesn't have a parent, so new root
root = newParent;
} else {
// Add the child to the parent in it's parent's position
parent.addChild(newParentPosition, newParent);
}
if (oldParentPosition != childPosition) {
// The easy case, the two children have different positions in parent
newParent.addChild(oldParentPosition, oldParent);
oldParent.parent = newParent;
newParent.addChild(childPosition, new KeyValueNode<V>(newParent, key, value));
return null;
}
while (oldParentPosition == childPosition) {
// Handle the case when the new children map to same position.
height++;
if (height > MAX_DEPTH) {
// We have found two keys which match exactly.
System.err.println("Yikes! Found two keys which match exactly.");
return null;
}
newParentPosition = getPosition(height - 1, key);
ArrayNode newParent2 = new ArrayNode(newParent, key, height);
newParent.addChild(newParentPosition, newParent2);
oldParentPosition = getPosition(height, oldParent.key);
childPosition = getPosition(height, key);
if (oldParentPosition != childPosition) {
newParent2.addChild(oldParentPosition, oldParent);
oldParent.parent = newParent2;
newParent2.addChild(childPosition, new KeyValueNode<V>(newParent2, key, value));
} else {
newParent = newParent2;
}
}
return null;
} else if (node instanceof ArrayNode) {
ArrayNode arrayRoot = (ArrayNode) node;
int position = getPosition(arrayRoot.height, key);
Node child = arrayRoot.getChild(position);
if (child == null) {
// Found an empty slot in parent
arrayRoot.addChild(position, new KeyValueNode<V>(arrayRoot, key, value));
return null;
}
return put(arrayRoot, child, (byte) (height + 1), key, value);
}
return null;
}
public YieldTwoNode(ISourcePosition position, ArrayNode args) {
super(position, args, true);
argument1 = args.get(0);
argument2 = args.get(1);
}
private void handleProperties(
Map<String, Object> mapToFill,
ArrayList<Map.Entry<String, JsonNode>> itProperties,
Object returnedValue)
throws NoSuchMethodException, IllegalAccessException, InvocationTargetException {
for (int k = 0; k < itProperties.size(); k++) {
String titleBean = itProperties.get(k).getKey();
FMDProperty objectProperty =
fillObjectProperty(
Lists.newArrayList(itProperties.get(k).getValue().fields()).listIterator());
if (objectProperty.getTitleBean() == null) {
objectProperty.setTitleBean(titleBean);
}
Object mdsdValue = getReturnedValueFromObject(objectProperty, returnedValue, titleBean);
if (mdsdValue != null) {
// if there is not a reference
if (objectProperty.getReference() == null) {
String orderObj = getOrderFromEntity(objectProperty.getOrder());
if (isReadyToPut(objectProperty)) {
Object valueToPut =
((((ValueNode) mdsdValue).getNodeType().toString()).equals("NUMBER"))
? mdsdValue
: ((TextNode) mdsdValue).asText();
mapToFill.put(
orderObj,
new FMDescriptor(
titleBean,
objectProperty.getTitleToVisualize(),
objectProperty.getDescription(),
valueToPut));
} else if (objectProperty.getType() != null
&& objectProperty.getType().equals(ARRAY_TYPE)
&& objectProperty.getItems().get(TYPE_FIELD) != null
&& objectProperty.getItems().get(TYPE_FIELD).asText().equals(STRING_TYPE)) {
ArrayNode values = ((ArrayNode) mdsdValue);
for (int i = 0, size = values.size(); i < size; i++) {
values.add(values.get(i).textValue());
}
mapToFill.put(
orderObj,
new FMDescriptor(
titleBean,
objectProperty.getTitleToVisualize(),
objectProperty.getDescription(),
values));
} else {
mapToFill.put(
orderObj,
new FMDescriptor(
titleBean,
objectProperty.getTitleToVisualize(),
objectProperty.getDescription(),
fillRecursive2(itProperties.get(k).getValue().fields(), mdsdValue)));
}
}
// if it is a reference
else {
handleReferences(
objectProperty.getReference(), objectProperty, mapToFill, mdsdValue, false);
}
}
}
}