下面列出了com.google.gson.JsonPrimitive#isString ( ) 实例代码，或者点击链接到github查看源代码，也可以在右侧发表评论。
/**
* Unpack a JsonElement into the object type
*
* @param <T> The type to deserialize
* @param object The object used to accept the pare result
* @param valueObj The root of a tree of JsonElements or an indirection index
* @param gson A Gson context
* @param raw
* @throws GsonException
*/
public static <T extends GsonSerializable> void
extractJsonObject(T object, JsonElement valueObj, Gson gson, RawStringData raw)
throws GsonException {
if (valueObj.isJsonObject()) {
object.fromGson(valueObj.getAsJsonObject(), gson, raw);
} else if (valueObj.isJsonPrimitive()) {
JsonPrimitive primitive = valueObj.getAsJsonPrimitive();
String s = null;
if (raw == null || !primitive.isString()) {
throw new GsonException("Decoding " + valueObj + " as object " + object.getClass() +
" with no RawStringData given");
}
s = raw.getString(valueObj.getAsString());
GsonUtil.parseJson(object, gson, s, raw);
} else {
throw new GsonException("Cannot decode valueObject " + valueObj.getClass() +
" as object " + object.getClass());
}
}
/**
* Get JsonElement class type.
*
* @param element the element
* @return Class class
*/
public Class getType(final JsonElement element) {
if (!element.isJsonPrimitive()) {
return element.getClass();
}
final JsonPrimitive primitive = element.getAsJsonPrimitive();
if (primitive.isString()) {
return String.class;
} else if (primitive.isNumber()) {
String numStr = primitive.getAsString();
if (numStr.contains(DOT) || numStr.contains(E)
|| numStr.contains("E")) {
return Double.class;
}
return Long.class;
} else if (primitive.isBoolean()) {
return Boolean.class;
} else {
return element.getClass();
}
}
/**
* Utility to list indexes of a given type.
*
* @param type the type of index to list, null means all types
* @param modelType the class to deserialize the index into
* @param <T> the type of the index
* @return the list of indexes of the specified type
*/
private <T extends Index> List<T> listIndexType(String type, Class<T> modelType) {
List<T> indexesOfType = new ArrayList<T>();
Gson g = new Gson();
for (JsonElement index : indexes) {
if (index.isJsonObject()) {
JsonObject indexDefinition = index.getAsJsonObject();
JsonElement indexType = indexDefinition.get("type");
if (indexType != null && indexType.isJsonPrimitive()) {
JsonPrimitive indexTypePrimitive = indexType.getAsJsonPrimitive();
if (type == null || (indexTypePrimitive.isString() && indexTypePrimitive
.getAsString().equals(type))) {
indexesOfType.add(g.fromJson(indexDefinition, modelType));
}
}
}
}
return indexesOfType;
}
/**
* @return the string value represented by the object.
*
* @param o The object for which the string value is to be extracted
*/
protected String getStringValue(Object o) {
String result;
if (o instanceof String) {
result = (String) o;
} else if (o instanceof JsonElement) {
JsonElement json = (JsonElement) o;
if (json.isJsonPrimitive()) {
JsonPrimitive primitive = json.getAsJsonPrimitive();
if (primitive.isString()) {
result = primitive.getAsString();
} else {
throw new IllegalArgumentException("Object does not represent a string value.");
}
} else {
throw new IllegalArgumentException("Object does not represent a string value.");
}
} else {
throw new IllegalArgumentException("Object does not represent a string value.");
}
return result;
}
private static StdAttributeValue<?> parsePrimitiveAttribute(JsonPrimitive jsonPrimitive) {
try {
if (jsonPrimitive.isString()) {
return new StdAttributeValue<>(XACML3.ID_DATATYPE_STRING, jsonPrimitive.getAsString());
} else if (jsonPrimitive.isBoolean()) {
return new StdAttributeValue<>(XACML3.ID_DATATYPE_BOOLEAN, jsonPrimitive.getAsBoolean());
} else if (jsonPrimitive.isNumber()) {
Number number = jsonPrimitive.getAsNumber();
logger.debug("Number is {} {} ceil {}", number.doubleValue(), number.longValue(), Math.ceil(number.doubleValue()));
if (Math.ceil(number.doubleValue()) == number.longValue()) {
return new StdAttributeValue<>(XACML3.ID_DATATYPE_INTEGER, DataTypeInteger.newInstance().convert(jsonPrimitive.getAsInt()));
} else {
return new StdAttributeValue<>(XACML3.ID_DATATYPE_DOUBLE, jsonPrimitive.getAsDouble());
}
}
} catch (DataTypeException e) {
logger.error("Parse primitive failed", e);
}
return null;
}
private String keyToString(JsonElement keyElement) {
if (keyElement.isJsonPrimitive()) {
JsonPrimitive primitive = keyElement.getAsJsonPrimitive();
if (primitive.isNumber()) {
return String.valueOf(primitive.getAsNumber());
}
if (primitive.isBoolean()) {
return Boolean.toString(primitive.getAsBoolean());
}
if (primitive.isString()) {
return primitive.getAsString();
}
throw new AssertionError();
} else if (keyElement.isJsonNull()) {
return "null";
} else {
throw new AssertionError();
}
}
private Object getJsonObjectValue(JsonElement jsonElement) {
if (jsonElement.isJsonArray()) {
return getJsonObjectValueForArrays(jsonElement);
}
if (jsonElement.isJsonNull()) {
return null;
}
JsonPrimitive jsonPrimitive = jsonElement.getAsJsonPrimitive();
if (jsonPrimitive.isNumber()) {
if (jsonPrimitive.getAsString().indexOf(".") != -1) {
return jsonPrimitive.getAsDouble();
}
return jsonPrimitive.getAsLong();
}
if (jsonPrimitive.isString()) {
return jsonPrimitive.getAsString();
}
if (jsonPrimitive.isBoolean()) {
return jsonPrimitive.getAsBoolean();
}
// TODO timestamp
throw new RuntimeException("Invalid json value: " + jsonPrimitive.getAsString());
}
private Object getJsonValue(String key, JsonPrimitive elem) {
// TODO: Move to utils
if (elem.isString())
return elem.getAsString();
else if (elem.isNumber())
return elem.getAsNumber();
else if (elem.isBoolean())
return elem.getAsBoolean();
// ... TODO: Add more data types.
String value = elem.getAsString();
Wizardry.LOGGER.warn("| | |_ WARNING! Using fallback as string for parameter '" + key + "' having value '" + value + "'.");
return value;
}
private Object deserialize(JsonPrimitive primitive) {
if (primitive.isString()) {
return primitive.getAsString();
} else if (primitive.isNumber()) {
return primitive.getAsBigDecimal();
} else if (primitive.isBoolean()) {
return primitive.getAsBoolean();
} else {
throw new IllegalArgumentException("Unsupported primitive: " + primitive);
}
}
/**
* Generically generate annotations.
*
* @see OpProperties.ANNOTATIONS
*/
static void genericAnnotations(JsonObject op, StringBuilder sb) {
JsonArray annotations = GsonUtilities.array(op, OpProperties.ANNOTATIONS);
if (annotations == null)
return;
for (JsonElement a : annotations) {
JsonObject annotation = a.getAsJsonObject();
sb.append('@');
sb.append(jstring(annotation, OpProperties.ANNOTATION_TYPE));
sb.append('(');
JsonObject properties = GsonUtilities.object(annotation, OpProperties.ANNOTATION_PROPERTIES);
boolean first = true;
for (Entry<String, JsonElement> property : properties.entrySet()) {
if (!first)
sb.append(',');
sb.append(property.getKey());
sb.append('=');
if (property.getValue().isJsonPrimitive()) {
JsonPrimitive value = property.getValue().getAsJsonPrimitive();
if (value.isString())
sb.append(SPLGenerator.stringLiteral(value.getAsString()));
else
sb.append(value.getAsString());
} else {
SPLGenerator.value(sb, property.getValue().getAsJsonObject());
}
if (first)
first = false;
}
sb.append(')');
sb.append('\n');
}
}
private void parseChildPrimitiveInstance(Element context, Property property, String name, String npath,
JsonElement main, JsonElement fork) throws FHIRFormatError, DefinitionException {
if (main != null && !(main instanceof JsonPrimitive))
logError(line(main), col(main), npath, IssueType.INVALID, "This property must be an simple value, not a "+main.getClass().getName(), IssueSeverity.ERROR);
else if (fork != null && !(fork instanceof JsonObject))
logError(line(fork), col(fork), npath, IssueType.INVALID, "This property must be an object, not a "+fork.getClass().getName(), IssueSeverity.ERROR);
else {
Element n = new Element(name, property).markLocation(line(main != null ? main : fork), col(main != null ? main : fork));
context.getChildren().add(n);
if (main != null) {
JsonPrimitive p = (JsonPrimitive) main;
n.setValue(p.getAsString());
if (!n.getProperty().isChoice() && n.getType().equals("xhtml")) {
try {
n.setXhtml(new XhtmlParser().setValidatorMode(policy == ValidationPolicy.EVERYTHING).parse(n.getValue(), null).getDocumentElement());
} catch (Exception e) {
logError(line(main), col(main), npath, IssueType.INVALID, "Error parsing XHTML: "+e.getMessage(), IssueSeverity.ERROR);
}
}
if (policy == ValidationPolicy.EVERYTHING) {
// now we cross-check the primitive format against the stated type
if (Utilities.existsInList(n.getType(), "boolean")) {
if (!p.isBoolean())
logError(line(main), col(main), npath, IssueType.INVALID, "Error parsing JSON: the primitive value must be a boolean", IssueSeverity.ERROR);
} else if (Utilities.existsInList(n.getType(), "integer", "unsignedInt", "positiveInt", "decimal")) {
if (!p.isNumber())
logError(line(main), col(main), npath, IssueType.INVALID, "Error parsing JSON: the primitive value must be a number", IssueSeverity.ERROR);
} else if (!p.isString())
logError(line(main), col(main), npath, IssueType.INVALID, "Error parsing JSON: the primitive value must be a string", IssueSeverity.ERROR);
}
}
if (fork != null) {
JsonObject child = (JsonObject) fork;
checkObject(child, npath);
parseChildren(npath, child, n, false);
}
}
}
@Override
public void printPrimitive(JsonPrimitive primitive) {
if(primitive.isString()) {
printString(primitive.getAsString());
}
// TODO style by type?
else {
out.append(primitive.toString());
}
}
@Override
public <U> U convertTo(final DynamicOps<U> outOps, final JsonElement input) {
if (input instanceof JsonObject) {
return convertMap(outOps, input);
}
if (input instanceof JsonArray) {
return convertList(outOps, input);
}
if (input instanceof JsonNull) {
return outOps.empty();
}
final JsonPrimitive primitive = input.getAsJsonPrimitive();
if (primitive.isString()) {
return outOps.createString(primitive.getAsString());
}
if (primitive.isBoolean()) {
return outOps.createBoolean(primitive.getAsBoolean());
}
final BigDecimal value = primitive.getAsBigDecimal();
try {
final long l = value.longValueExact();
if ((byte) l == l) {
return outOps.createByte((byte) l);
}
if ((short) l == l) {
return outOps.createShort((short) l);
}
if ((int) l == l) {
return outOps.createInt((int) l);
}
return outOps.createLong(l);
} catch (final ArithmeticException e) {
final double d = value.doubleValue();
if ((float) d == d) {
return outOps.createFloat((float) d);
}
return outOps.createDouble(d);
}
}
private String a(JsonElement jsonelement)
{
if (jsonelement.isJsonPrimitive())
{
JsonPrimitive jsonprimitive = jsonelement.getAsJsonPrimitive();
if (jsonprimitive.isNumber())
{
return String.valueOf(jsonprimitive.getAsNumber());
}
if (jsonprimitive.isBoolean())
{
return Boolean.toString(jsonprimitive.getAsBoolean());
}
if (jsonprimitive.isString())
{
return jsonprimitive.getAsString();
} else
{
throw new AssertionError();
}
}
if (jsonelement.isJsonNull())
{
return "null";
} else
{
throw new AssertionError();
}
}
@Override
public Object unwarpPrimitive(JsonPrimitive primitive) {
if (primitive.isBoolean()) {
return primitive.getAsBoolean();
} else if (primitive.isNumber()) {
return primitive.getAsNumber();
} else if (primitive.isString()) {
return primitive.getAsString();
} else {
throw new IllegalArgumentException("Unknown primitive type: " + primitive);
}
}
/**
* Validates if the object represents a string value.
*
* @param o
* @return
*/
protected boolean isStringType(Object o) {
boolean result = (o instanceof String);
if (o instanceof JsonElement) {
JsonElement json = (JsonElement) o;
if (json.isJsonPrimitive()) {
JsonPrimitive primitive = json.getAsJsonPrimitive();
result = primitive.isString();
}
}
return result;
}
@Override public JsonToken peek() throws IOException {
if (stackSize == 0) {
return JsonToken.END_DOCUMENT;
}
Object o = peekStack();
if (o instanceof Iterator) {
boolean isObject = stack[stackSize - 2] instanceof JsonObject;
Iterator<?> iterator = (Iterator<?>) o;
if (iterator.hasNext()) {
if (isObject) {
return JsonToken.NAME;
} else {
push(iterator.next());
return peek();
}
} else {
return isObject ? JsonToken.END_OBJECT : JsonToken.END_ARRAY;
}
} else if (o instanceof JsonObject) {
return JsonToken.BEGIN_OBJECT;
} else if (o instanceof JsonArray) {
return JsonToken.BEGIN_ARRAY;
} else if (o instanceof JsonPrimitive) {
JsonPrimitive primitive = (JsonPrimitive) o;
if (primitive.isString()) {
return JsonToken.STRING;
} else if (primitive.isBoolean()) {
return JsonToken.BOOLEAN;
} else if (primitive.isNumber()) {
return JsonToken.NUMBER;
} else {
throw new AssertionError();
}
} else if (o instanceof JsonNull) {
return JsonToken.NULL;
} else if (o == SENTINEL_CLOSED) {
throw new IllegalStateException("JsonReader is closed");
} else {
throw new AssertionError();
}
}
/**
*
* @Title: jsonTree
* @Description: To generate a JSON tree
* @param @param e
* @param @param layer
* @param @param sb
* @return layer
* @throws
*/
public static void jsonTree(JsonElement e, int layer, StringBuilder sb)
{
if (e.isJsonNull())
{
return;
}
if (e.isJsonPrimitive())
{
return;
}
if (e.isJsonArray())
{
JsonArray ja = e.getAsJsonArray();
if (ja.size() > 0)
{
jsonTree(ja.get(0), layer, sb);
}
return;
}
if (e.isJsonObject())
{
String line = RESTConst.LINE;
String type = RESTConst.UNKNOWN;
String spaces = " ";
String vertLine = "│ ";
String indent = dup(layer, spaces);
layer++;
if (layer <= 0)
{
line = " ";
}
Set<Entry<String, JsonElement>> es = e.getAsJsonObject().entrySet();
for (Entry<String, JsonElement> en : es)
{
indent = dup(layer, spaces);
if (layer >= 2)
{
indent = dup(1, spaces) + dup(layer - 1, vertLine);
}
sb.append(indent).append(line).append(en.getKey()).append(" [");
if (en.getValue().isJsonArray())
{
type = Array.class.getSimpleName();
}
else if (en.getValue().isJsonObject())
{
type = Object.class.getSimpleName();
}
else if (en.getValue().isJsonPrimitive())
{
JsonPrimitive jp = en.getValue().getAsJsonPrimitive();
if (jp.isBoolean())
{
type = Boolean.class.getSimpleName();
}
else if (jp.isNumber())
{
type = Number.class.getSimpleName();
}
else if (jp.isString())
{
type = String.class.getSimpleName();
}
}
else if (en.getValue().isJsonNull())
{
type = null + "";
}
sb.append(type.toLowerCase()).append("]").append(lines(1));
jsonTree(en.getValue(), layer, sb);
}
}
}
/**
* Attempts to convert a JsonElement to an a known type.
*
* @param element JsonElement
* @return Optional<Object>
*/
private static Optional<Object> jsonElementToObject(JsonElement element) {
if (element.isJsonArray()) {
List<Object> list = Lists.newArrayList();
JsonArray jsonArray = element.getAsJsonArray();
jsonArray.forEach(entry -> jsonElementToObject(entry).ifPresent(list::add));
return Optional.of(list);
} else if (element.isJsonObject()) {
JsonObject jsonObject = element.getAsJsonObject();
PrimitiveArray primitiveArray = PrimitiveArray.of(jsonObject);
if (primitiveArray != null) {
return Optional.of(primitiveArray.getArray());
}
return Optional.of(dataViewFromJson(jsonObject));
} else if (element.isJsonPrimitive()) {
JsonPrimitive jsonPrimitive = element.getAsJsonPrimitive();
if (jsonPrimitive.isBoolean()) {
return Optional.of(jsonPrimitive.getAsBoolean());
} else if (jsonPrimitive.isNumber()) {
Number number = NumberUtils.createNumber(jsonPrimitive.getAsString());
if (number instanceof Byte) {
return Optional.of(number.byteValue());
} else if (number instanceof Double) {
return Optional.of(number.doubleValue());
} else if (number instanceof Float) {
return Optional.of(number.floatValue());
} else if (number instanceof Integer) {
return Optional.of(number.intValue());
} else if (number instanceof Long) {
return Optional.of(number.longValue());
} else if (number instanceof Short) {
return Optional.of(number.shortValue());
}
} else if (jsonPrimitive.isString()) {
return Optional.of(jsonPrimitive.getAsString());
}
}
return Optional.empty();
}
public static SNode castToSNode(JsonElement object) {
Preconditions.checkArgument(object != null, "Null argument");
if (object.isJsonPrimitive()) {
JsonPrimitive primitiveObject = object.getAsJsonPrimitive();
if (primitiveObject.isBoolean()) {
return new SPrimitive(primitiveObject.getAsBoolean(), new SNodeAccessControl());
} else if (primitiveObject.isNumber()) {
return new SPrimitive(primitiveObject.getAsDouble(), new SNodeAccessControl());
} else if (primitiveObject.isString()) {
return new SPrimitive(primitiveObject.isString(), new SNodeAccessControl());
}
} else if (object.isJsonObject()) {
return SMapGson.create(object.getAsJsonObject());
} else if (object.isJsonArray()) {
return SListGson.create(object.getAsJsonArray());
}
throw new IllegalStateException("Unable to cast object to JS native SNode");
}