下面列出了怎么用com.fasterxml.jackson.databind.node.BigIntegerNode的API类实例代码及写法,或者点击链接到github查看源代码。
/**
* Converts JsonNode to PrimitiveObject.
*/
public static PrimitiveObject get( final JsonNode jsonNode ) throws IOException {
if ( jsonNode instanceof TextNode ) {
return new StringObj( ( (TextNode)jsonNode ).textValue() );
} else if ( jsonNode instanceof BooleanNode ) {
return new BooleanObj( ( (BooleanNode)jsonNode ).booleanValue() );
} else if ( jsonNode instanceof IntNode ) {
return new IntegerObj( ( (IntNode)jsonNode ).intValue() );
} else if ( jsonNode instanceof LongNode ) {
return new LongObj( ( (LongNode)jsonNode ).longValue() );
} else if ( jsonNode instanceof DoubleNode ) {
return new DoubleObj( ( (DoubleNode)jsonNode ).doubleValue() );
} else if ( jsonNode instanceof BigIntegerNode ) {
return new StringObj( ( (BigIntegerNode)jsonNode ).bigIntegerValue().toString() );
} else if ( jsonNode instanceof DecimalNode ) {
return new StringObj( ( (DecimalNode)jsonNode ).decimalValue().toString() );
} else if ( jsonNode instanceof BinaryNode ) {
return new BytesObj( ( (BinaryNode)jsonNode ).binaryValue() );
} else if ( jsonNode instanceof POJONode ) {
return new BytesObj( ( (POJONode)jsonNode ).binaryValue() );
} else if ( jsonNode instanceof NullNode ) {
return NullObj.getInstance();
} else if ( jsonNode instanceof MissingNode ) {
return NullObj.getInstance();
} else {
return new StringObj( jsonNode.toString() );
}
}
@Test
public void testIsIntegerFunction() {
// check that is-integer still works if input
// is a BigIntegerNode not just IntNode
Expression expr = Parser.compileString("is-integer(.)");
JsonNode context = new BigIntegerNode(BigInteger.ONE);
JsonNode actual = expr.apply(context);
assertTrue(actual.isBoolean());
assertTrue(actual.booleanValue());
}
@Override
public Number serialize(Object dataFetcherResult) {
if (dataFetcherResult instanceof BigIntegerNode) {
return ((BigIntegerNode) dataFetcherResult).numberValue();
} else {
throw serializationException(dataFetcherResult, BigIntegerNode.class);
}
}
@Override
public BigIntegerNode parseValue(Object input) {
if (input instanceof Number || input instanceof String) {
return BigIntegerNode.valueOf(new BigInteger(input.toString()));
}
if (input instanceof BigIntegerNode) {
return (BigIntegerNode) input;
}
throw valueParsingException(input, Number.class, String.class, BigIntegerNode.class);
}
@Override
public BigIntegerNode parseLiteral(Object input) {
if (input instanceof IntValue) {
return BigIntegerNode.valueOf(((IntValue) input).getValue());
} else {
throw new CoercingParseLiteralException(errorMessage(input, IntValue.class));
}
}
private static Map<Type, GraphQLScalarType> getScalarMapping() {
Map<Type, GraphQLScalarType> scalarMapping = new HashMap<>();
scalarMapping.put(TextNode.class, JsonTextNode);
scalarMapping.put(BooleanNode.class, JsonBooleanNode);
scalarMapping.put(BinaryNode.class, JsonBinaryNode);
scalarMapping.put(BigIntegerNode.class, JsonBigIntegerNode);
scalarMapping.put(IntNode.class, JsonIntegerNode);
scalarMapping.put(ShortNode.class, JsonShortNode);
scalarMapping.put(DecimalNode.class, JsonDecimalNode);
scalarMapping.put(FloatNode.class, JsonFloatNode);
scalarMapping.put(DoubleNode.class, JsonDoubleNode);
scalarMapping.put(NumericNode.class, JsonDecimalNode);
return Collections.unmodifiableMap(scalarMapping);
}
public JacksonContainer(ObjectNode obj, JsonNode any, BinaryNode binary, TextNode text, IntNode integer,
DoubleNode dbl, BigIntegerNode bigInt, ArrayNode array) {
this.obj = obj;
this.any = any;
this.text = text;
this.binary = binary;
this.integer = integer;
this.dbl = dbl;
this.bigInt = bigInt;
this.array = array;
}
private static void emitJsonNode(StringBuilder buf, JsonNode node) {
if (node.isNumber()) {
// Formatting of numbers depending on type
switch (node.numberType()) {
case BIG_INTEGER:
buf.append(((BigIntegerNode)node).bigIntegerValue().toString());
break;
case BIG_DECIMAL:
buf.append(((DecimalNode)node).decimalValue().toPlainString());
break;
case INT:
case LONG:
buf.append(node.asLong());
break;
case FLOAT:
case DOUBLE:
double val = node.asDouble();
buf.append(Double.toString(val));
break;
default:
break;
}
} else if (node.isArray()) {
// JavaScript Array.toString() will comma-delimit the elements.
for (int i = 0, size = node.size(); i < size; i++) {
if (i >= 1) {
buf.append(",");
}
buf.append(node.path(i).asText());
}
} else if (!node.isNull() && !node.isMissingNode()) {
buf.append(node.asText());
}
}
private Example createExample(JsonNode node) {
if (node instanceof ObjectNode) {
ObjectExample obj = new ObjectExample();
ObjectNode on = (ObjectNode) node;
for (Iterator<Entry<String, JsonNode>> x = on.fields(); x.hasNext(); ) {
Entry<String, JsonNode> i = x.next();
String key = i.getKey();
JsonNode value = i.getValue();
obj.put(key, createExample(value));
}
return obj;
} else if (node instanceof ArrayNode) {
ArrayExample arr = new ArrayExample();
ArrayNode an = (ArrayNode) node;
for (JsonNode childNode : an) {
arr.add(createExample(childNode));
}
return arr;
} else if (node instanceof DoubleNode) {
return new DoubleExample(node.doubleValue());
} else if (node instanceof IntNode || node instanceof ShortNode) {
return new IntegerExample(node.intValue());
} else if (node instanceof FloatNode) {
return new FloatExample(node.floatValue());
} else if (node instanceof BigIntegerNode) {
return new BigIntegerExample(node.bigIntegerValue());
} else if (node instanceof DecimalNode) {
return new DecimalExample(node.decimalValue());
} else if (node instanceof LongNode) {
return new LongExample(node.longValue());
} else if (node instanceof BooleanNode) {
return new BooleanExample(node.booleanValue());
} else {
return new StringExample(node.asText());
}
}
@Test
public void T_get_bigIntegerObject() throws IOException {
PrimitiveObject obj = JsonNodeToPrimitiveObject.get( BigIntegerNode.valueOf( new BigInteger( "100" ) ) );
assertTrue( ( obj instanceof StringObj ) );
}
private static JsonNode parseNumber(String number) {
if (number.length() == 0)
return null;
int pos = 0;
if (number.charAt(0) == '-') {
pos = 1;
}
int endInteger = scanDigits(number, pos);
if (endInteger == pos)
return null;
if (endInteger == number.length()) {
if (number.length() < 10)
return new IntNode(Integer.parseInt(number));
else if (number.length() < 19)
return new LongNode(Long.parseLong(number));
else
return new BigIntegerNode(new BigInteger(number));
}
// since there's stuff after the initial integer it must be either
// the decimal part or the exponent
int intPart = Integer.parseInt(number.substring(0, endInteger));
pos = endInteger;
double value = intPart;
if (number.charAt(pos) == '.') {
pos += 1;
int endDecimal = scanDigits(number, pos);
if (endDecimal == pos)
return null;
long decimalPart = Long.parseLong(number.substring(endInteger + 1, endDecimal));
int digits = endDecimal - endInteger - 1;
value = (decimalPart / Math.pow(10, digits)) + intPart;
pos = endDecimal;
// if there's nothing more, then this is it
if (pos == number.length())
return new DoubleNode(value);
}
// there is more: next character MUST be 'e' or 'E'
char ch = number.charAt(pos);
if (ch != 'e' && ch != 'E')
return null;
// now we must have either '-', '+', or an integer
pos++;
if (pos == number.length())
return null;
ch = number.charAt(pos);
int sign = 1;
if (ch == '+')
pos++;
else if (ch == '-') {
sign = -1;
pos++;
}
int endExponent = scanDigits(number, pos);
if (endExponent != number.length() || endExponent == pos)
return null;
int exponent = Integer.parseInt(number.substring(pos)) * sign;
return new DoubleNode(value * Math.pow(10, exponent));
}
public BigIntegerNode getBigInt() {
return bigInt;
}
@Test
public void testLiteralBigInteger() throws Exception {
final Matcher<JsonNode> sut = jsonNumber(BigIntegerNode.valueOf(BigInteger.ONE));
assertThat(NF.numberNode(BigInteger.ONE), is(sut));
}
@Activate
public void activate() {
appId = coreService.registerApplication("org.onosproject.workplacestore");
log.info("appId=" + appId);
KryoNamespace workplaceNamespace = KryoNamespace.newBuilder()
.register(KryoNamespaces.API)
.register(WorkflowData.class)
.register(Workplace.class)
.register(DefaultWorkplace.class)
.register(WorkflowContext.class)
.register(DefaultWorkflowContext.class)
.register(SystemWorkflowContext.class)
.register(WorkflowState.class)
.register(ProgramCounter.class)
.register(DataModelTree.class)
.register(JsonDataModelTree.class)
.register(List.class)
.register(ArrayList.class)
.register(JsonNode.class)
.register(ObjectNode.class)
.register(TextNode.class)
.register(LinkedHashMap.class)
.register(ArrayNode.class)
.register(BaseJsonNode.class)
.register(BigIntegerNode.class)
.register(BinaryNode.class)
.register(BooleanNode.class)
.register(ContainerNode.class)
.register(DecimalNode.class)
.register(DoubleNode.class)
.register(FloatNode.class)
.register(IntNode.class)
.register(JsonNodeType.class)
.register(LongNode.class)
.register(MissingNode.class)
.register(NullNode.class)
.register(NumericNode.class)
.register(POJONode.class)
.register(ShortNode.class)
.register(ValueNode.class)
.register(JsonNodeCreator.class)
.register(JsonNodeFactory.class)
.build();
localWorkplaceMap.clear();
workplaceMap = storageService.<String, WorkflowData>consistentMapBuilder()
.withSerializer(Serializer.using(workplaceNamespace))
.withName("workplace-map")
.withApplicationId(appId)
.build();
workplaceMap.addListener(workplaceMapEventListener);
localContextMap.clear();
contextMap = storageService.<String, WorkflowData>consistentMapBuilder()
.withSerializer(Serializer.using(workplaceNamespace))
.withName("workflow-context-map")
.withApplicationId(appId)
.build();
contextMap.addListener(contextMapEventListener);
workplaceMapEventListener.syncLocal();
contextMapEventListener.syncLocal();
log.info("Started");
}