Java Code Examples for com.fasterxml.jackson.databind.JsonNode#asDouble()

private Object valueFromJsonNode(String path, JsonNode valueNode) {
	if (valueNode == null || valueNode.isNull()) {
		return null;
	} else if (valueNode.isTextual()) {
		return valueNode.asText();
	} else if (valueNode.isFloatingPointNumber()) {
		return valueNode.asDouble();
	} else if (valueNode.isBoolean()) {
		return valueNode.asBoolean();
	} else if (valueNode.isInt()) {
		return valueNode.asInt();
	} else if (valueNode.isLong()) {
		return valueNode.asLong();
	} else if (valueNode.isObject()) {
		return new JsonLateObjectEvaluator(valueNode);
	} else if (valueNode.isArray()) {
		// TODO: Convert valueNode to array
	}
	
	return null;
}
 

/**
 * @see org.mvel2.integration.VariableResolver#getValue()
 */
@Override
public Object getValue() {
    JsonNode varNode = node.get(fieldName);
    if (varNode.isObject()) {
        return varNode;
    } else if (varNode.isArray()) {
        List<Object> rval = new ArrayList<>();
        for (int idx = 0; idx < varNode.size(); idx++) {
            JsonNode idxNode = varNode.get(idx);
            rval.add(idxNode);
        }
        return rval;
    } else if (varNode.isNull()) {
        return null;
    } else if (varNode.isBoolean()) {
        return varNode.asBoolean();
    } else if (varNode.isTextual()) {
        return varNode.asText();
    } else if (varNode.isInt()) {
        return varNode.asInt();
    } else if (varNode.isDouble()) {
        return varNode.asDouble();
    }
    return varNode;
}
 

private static Object extractValue(JsonNode valueNode) {
    JsonToken type = valueNode.asToken();

    switch (type) {
        case VALUE_NUMBER_INT:
            return valueNode.asInt();
        case VALUE_NUMBER_FLOAT:
            return valueNode.asDouble();
        case VALUE_TRUE:
            return Boolean.TRUE;
        case VALUE_FALSE:
            return Boolean.FALSE;
        case VALUE_NULL:
            return null;
        case START_ARRAY:
            return extractArray(valueNode);
        default:
            // String parameters may need to be parsed further. Defer parsing
            // until it is placed in the context of an expression...
            return valueNode;
    }
}
 

static Object getValue(JsonNode value) {
    if (value.isValueNode()) {
        switch (value.getNodeType()) {
            case BOOLEAN:
                return value.asBoolean();
            case NUMBER:
                if (value.isInt()) {
                    return value.asInt();
                } else if (value.isLong()) {
                    return value.asLong();
                } else if (value.isDouble()) {
                    return value.asDouble();
                }
            case STRING :
                return value.asText();
        }
    }
    return value;
}
 

public static Object parserValue(JsonNode node) {
    if (node == null || node.isNull()) {
        return null;
    }
    if (node.isArray()) {
        return parserArrayNode((ArrayNode) node);
    } else if (node.isObject()) {
        return parserMap((ObjectNode) node);
    } else {
        if (node.isBigDecimal() || node.isBigInteger() || node.isLong()) {
            return node.asLong();
        } else if (node.isFloat() || node.isDouble()) {
            return node.asDouble();
        } else if (node.isInt() || node.isNumber() || node.isShort()) {
            return node.asInt();
        } else if (node.isBoolean()) {
            return node.asBoolean();
        } else if (node.isTextual()) {
            return node.asText();
        } else {// 其他类型
            return node.textValue();
        }
    }
}
 

private static Object toValueByJson(CWLTypeSymbol outputType, JsonNode jsonNode) {
    switch (outputType) {
    case STRING:
        return jsonNode.asText();
    case INT:
        return jsonNode.asInt();
    case FLOAT:
        return jsonNode.floatValue();
    case DOUBLE:
        return jsonNode.asDouble();
    case BOOLEAN:
        return jsonNode.asBoolean();
    default:
        return null;
    }
}
 

private static Object extractValue(JsonNode valueNode) {
    JsonToken type = valueNode.asToken();

    // ExtJS converts everything to String except for NULL and booleans. So
    // follow the same logic here...
    // (http://docs.sencha.com/extjs/4.1.2/source/Filter.html#Ext-util-Filter)
    switch (type) {
        case VALUE_NULL:
            return null;
        case VALUE_FALSE:
            return false;
        case VALUE_TRUE:
            return true;
        case VALUE_NUMBER_INT:
            return valueNode.asInt();
        case VALUE_NUMBER_FLOAT:
            return valueNode.asDouble();
        case START_ARRAY:
            return extractArray(valueNode);
        default:
            return valueNode.asText();
    }
}
 

@Override
public Object value(JsonNode valueNode) {
	JsonToken type = valueNode.asToken();

	switch (type) {
	case VALUE_NUMBER_INT:
		return valueNode.asInt();
	case VALUE_NUMBER_FLOAT:
		return valueNode.asDouble();
	case VALUE_TRUE:
		return Boolean.TRUE;
	case VALUE_FALSE:
		return Boolean.FALSE;
	case VALUE_NULL:
		return null;
	default:
		return valueNode.asText();
	}
}
 

private Object enforceFieldType(Schema fieldSchema, JsonNode fieldJsonNode) {

    if (fieldJsonNode.isNull()) {
      return null;
    }
    switch (fieldSchema.type()) {
      case BOOLEAN:
        return fieldJsonNode.asBoolean();
      case INT32:
        return fieldJsonNode.asInt();
      case INT64:
        return fieldJsonNode.asLong();
      case FLOAT64:
        return fieldJsonNode.asDouble();
      case STRING:
        if (fieldJsonNode.isTextual()) {
          return fieldJsonNode.asText();
        } else {
          return fieldJsonNode.toString();
        }
      case ARRAY:
        return handleArray(fieldSchema, (ArrayNode) fieldJsonNode);
      case MAP:
        return handleMap(fieldSchema, fieldJsonNode);
      default:
        throw new KsqlException("Type is not supported: " + fieldSchema.type());
    }
  }
 

@Override
public SyncToken deserialize(final JsonParser jp, final DeserializationContext ctx)
        throws IOException {

    ObjectNode tree = jp.readValueAsTree();

    Object value = null;
    if (tree.has("value")) {
        JsonNode node = tree.get("value");
        if (node.isBoolean()) {
            value = node.asBoolean();
        } else if (node.isDouble()) {
            value = node.asDouble();
        } else if (node.isLong()) {
            value = node.asLong();
        } else if (node.isInt()) {
            value = node.asInt();
        } else {
            value = node.asText();
        }

        if (value instanceof String) {
            String base64 = (String) value;
            try {
                value = Base64.getDecoder().decode(base64);
            } catch (RuntimeException e) {
                value = base64;
            }
        }
    }

    return new SyncToken(Objects.requireNonNull(value));
}
 

private double checkFloat(ObjectNode node, String key) throws QueryException {
	if (!node.has(key)) {
		throw new QueryException("\"" + key + "\" not found on \"inBoundingBox\"");
	}
	JsonNode jsonNode = node.get(key);
	if (jsonNode.isNumber()) {
		return jsonNode.asDouble();
	} else {
		throw new QueryException("\"" + key + "\" should be of type number");
	}
}
 

private Geolocation asGeolocation(JsonNode json) {
  JsonNode jsonIp          = json.get("ip");
  JsonNode jsonCountryCode = json.get("country_code");
  JsonNode jsonCountryName = json.get("country_name");
  JsonNode jsonRegionCode  = json.get("region_code");
  JsonNode jsonRegionName  = json.get("region_name");
  JsonNode jsonCity        = json.get("city");
  JsonNode jsonLatitude    = json.get("latitude");
  JsonNode jsonLongitude   = json.get("longitude");
  JsonNode jsonTimeZone    = json.get("time_zone");

  if (jsonIp          == null ||
      jsonCountryCode == null ||
      jsonCountryName == null ||
      jsonRegionCode  == null ||
      jsonRegionName  == null ||
      jsonCity        == null ||
      jsonLatitude    == null ||
      jsonLongitude   == null ||
      jsonTimeZone    == null) {
    return Geolocation.empty();
  }

  return new Geolocation(
      jsonIp.asText(),
      jsonCountryCode.asText(),
      jsonCountryName.asText(),
      jsonRegionCode.asText(),
      jsonRegionName.asText(),
      jsonCity.asText(),
      jsonLatitude.asDouble(),
      jsonLongitude.asDouble(),
      jsonTimeZone.asText()
  );
}
 

private Object getSimpleMemberValue(JsonNode currentNode, MemberModel memberModel) {
    if (memberModel.getHttp().getIsStreaming()) {
        return null;
    }
    switch (memberModel.getVariable().getSimpleType()) {
        case "Long":
            return currentNode.asLong();
        case "Integer":
            return currentNode.asInt();
        case "String":
            return currentNode.asText();
        case "Boolean":
            return currentNode.asBoolean();
        case "Double":
            return currentNode.asDouble();
        case "Instant":
            return Instant.ofEpochMilli(currentNode.asLong());
        case "SdkBytes":
            return SdkBytes.fromUtf8String(currentNode.asText());
        case "Float":
            return (float) currentNode.asDouble();
        case "Character":
            return asCharacter(currentNode);
        case "BigDecimal":
            return new BigDecimal(currentNode.asText());
        default:
            throw new IllegalArgumentException(
                    "Unsupported fieldType " + memberModel.getVariable().getSimpleType());
    }
}
 

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 double decodeDouble(JsonNode tree, String name) {
    final JsonNode n = tree.get(name);

    if (n == null) {
        return Double.NaN;
    }

    return n.asDouble();
}
 

private Value<?> getValueFromNode(JsonNode nodeValue, DataSetDataType type) {
	switch (type) {
		case Boolean:
			return new Value<Boolean>(type, (boolean)nodeValue.asBoolean());
		case DateTime:
			return new Value<Date>(type, new Date(nodeValue.asLong()));
		case Double:
			return new Value<Double>(type, nodeValue.asDouble());
		case Float:
			return new Value<Float>(type, (float)nodeValue.asDouble());
		case Int16:
		case UInt8:
			return new Value<Byte>(type, (byte)nodeValue.asInt());
		case UInt16:
		case Int32:
			return new Value<Integer>(type, nodeValue.asInt());
		case UInt32:
		case Int64:
			return new Value<Long>(type, (long)nodeValue.asLong());
		case Text:
		case String:
			return new Value<String>(type, nodeValue.asText());
		case UInt64:
			return new Value<BigInteger>(type, BigInteger.valueOf(nodeValue.asLong()));
		case Unknown:
		default:
			return null;
	}
}
 

/**
 * Matches an annotation constraint against a JSON representation of the
 * constraint.
 *
 * @param annotationConstraint constraint object to match
 * @param constraintJson JSON representation of the constraint
 * @return true if the constraint and JSON match, false otherwise.
 */
private boolean matchAnnotationConstraint(AnnotationConstraint annotationConstraint,
                                          JsonNode constraintJson) {
    final JsonNode keyJson = constraintJson.get("key");
    final JsonNode thresholdJson = constraintJson.get("threshold");
    return (keyJson != null
            && keyJson.asText().equals(annotationConstraint.key())) &&
           (thresholdJson != null
            && thresholdJson.asDouble() == annotationConstraint.threshold());
}
 

public static double ifDouble(JsonNode node, double defaultValue) {
  return isTruthy(node) ? node.asDouble() : defaultValue;
}
 

public Object convert(JsonNode node) {
  if (!node.isNumber())
    throw new JsltException("Cannot convert " + node + " to double");
  else
    return node.asDouble();
}
 

public boolean compare(JsonNode value1, JsonNode value2) {
    return value1.asDouble() < value2.asDouble();
}