Java JsonToken.BEGIN_OBJECT属性代码示例

private static JsonToken toGsonToken(com.fasterxml.jackson.core.JsonToken token) {
  switch (token) {
  case START_ARRAY:
    return JsonToken.BEGIN_ARRAY;
  case END_ARRAY:
    return JsonToken.END_ARRAY;
  case START_OBJECT:
    return JsonToken.BEGIN_OBJECT;
  case END_OBJECT:
    return JsonToken.END_OBJECT;
  case FIELD_NAME:
    return JsonToken.NAME;
  case VALUE_FALSE:
    return JsonToken.BOOLEAN;
  case VALUE_TRUE:
    return JsonToken.BOOLEAN;
  case VALUE_NULL:
    return JsonToken.NULL;
  case VALUE_NUMBER_INT:
    return JsonToken.NUMBER;
  case VALUE_NUMBER_FLOAT:
    return JsonToken.NUMBER;
  case VALUE_STRING:
  case VALUE_EMBEDDED_OBJECT:
    return JsonToken.STRING;
  default: // Not semantically equivalent
    return JsonToken.NULL;
  }
}
 

@Override
public ItemStack read(JsonReader in) throws IOException {
    if (in.peek() != JsonToken.BEGIN_OBJECT)
        return null;

    int id = 1;
    short data = 0;
    int amount = 1;
    ItemMeta meta = null;

    in.beginObject();
    while (in.hasNext()) {
        String name = in.nextName();
        switch (name) {
            case "id":
                id = in.nextInt();
                break;
            case "damage":
                data = (short) in.nextInt();
                break;
            case "amount":
                amount = in.nextInt();
                break;
            case "meta":
                meta = metaAdapter.read(in);
                break;
            default:
                Static.log("Unknown type, " + name);
        }
    }
    in.endObject();

    ItemStack item = new ItemStack(id, amount, data);
    if (meta != null)
        item.setItemMeta(meta);
    return item;
}
 

private static JsonToken toGsonToken(BsonType type) {
  final JsonToken token;
  switch (type) {
    case END_OF_DOCUMENT:
      token = JsonToken.END_DOCUMENT;
      break;
    case DOUBLE:
      token = JsonToken.NUMBER;
      break;
    case STRING:
      token = JsonToken.STRING;
      break;
    case DOCUMENT:
      token = JsonToken.BEGIN_OBJECT;
      break;
    case ARRAY:
      token = JsonToken.BEGIN_ARRAY;
      break;
    case OBJECT_ID:
      token = JsonToken.STRING;
      break;
    case BOOLEAN:
      token = JsonToken.BOOLEAN;
      break;
    case DATE_TIME:
      token = JsonToken.NUMBER;
      break;
    case NULL:
      token = JsonToken.NULL;
      break;
    case REGULAR_EXPRESSION:
      token = JsonToken.STRING;
      break;
    case SYMBOL:
      token = JsonToken.STRING;
      break;
    case INT32:
      token = JsonToken.NUMBER;
      break;
    case INT64:
      token = JsonToken.NUMBER;
      break;
    case TIMESTAMP:
      token = JsonToken.NUMBER;
      break;
    case DECIMAL128:
      token = JsonToken.NUMBER;
      break;
    case BINARY:
      token = JsonToken.STRING;
      break;
    default:
      // not really sure what to do with this type
      token = JsonToken.NULL;
  }

  return token;
}
 

public JsonToken peek() throws IOException {
    if (this.stack.isEmpty()) {
        return JsonToken.END_DOCUMENT;
    }
    Iterator<?> o = peekStack();
    if (o instanceof Iterator) {
        boolean isObject = this.stack.get(this.stack.size() - 2) instanceof JsonObject;
        Iterator<?> iterator = o;
        if (!iterator.hasNext()) {
            return isObject ? JsonToken.END_OBJECT : JsonToken.END_ARRAY;
        } else {
            if (isObject) {
                return JsonToken.NAME;
            }
            this.stack.add(iterator.next());
            return peek();
        }
    } else if (o instanceof JsonObject) {
        return JsonToken.BEGIN_OBJECT;
    } else {
        if (o instanceof JsonArray) {
            return JsonToken.BEGIN_ARRAY;
        }
        if (o instanceof JsonPrimitive) {
            JsonPrimitive primitive = (JsonPrimitive) o;
            if (primitive.isString()) {
                return JsonToken.STRING;
            }
            if (primitive.isBoolean()) {
                return JsonToken.BOOLEAN;
            }
            if (primitive.isNumber()) {
                return JsonToken.NUMBER;
            }
            throw new AssertionError();
        } else if (o instanceof JsonNull) {
            return JsonToken.NULL;
        } else {
            if (o == SENTINEL_CLOSED) {
                throw new IllegalStateException("JsonReader is closed");
            }
            throw new AssertionError();
        }
    }
}
 

@Override public JsonToken peek() throws IOException {
  if (stack.isEmpty()) {
    return JsonToken.END_DOCUMENT;
  }

  Object o = peekStack();
  if (o instanceof Iterator) {
    boolean isObject = stack.get(stack.size() - 2) instanceof JsonObject;
    Iterator<?> iterator = (Iterator<?>) o;
    if (iterator.hasNext()) {
      if (isObject) {
        return JsonToken.NAME;
      } else {
        stack.add(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();
  }
}
 

@Override
public Location read(JsonReader in) throws IOException {
    if (in.peek() != JsonToken.BEGIN_OBJECT)
        return null;

    World world = null;
    Double x = null;
    Double y = null;
    Double z = null;
    Double yaw = null;
    Double pitch = null;

    in.beginObject();
    while (in.hasNext()) {
        String name = in.nextName();
        switch (name) {
            case "world":
                world = Bukkit.getWorld(in.nextString());
                break;
            case "x":
                x = in.nextDouble();
                break;
            case "y":
                y = in.nextDouble();
                break;
            case "z":
                z = in.nextDouble();
                break;
            case "yaw":
                yaw = in.nextDouble();
                break;
            case "pitch":
                pitch = in.nextDouble();
                break;
            default:
                Static.log("Unknown type, " + name);
        }
    }
    in.endObject();

    return world != null && x != null && y != null && z != null &&
            pitch != null && yaw != null
            ? new Location(world, x, y, z, yaw.floatValue(), pitch.floatValue())
            : null;
}
 

@Override
public GUISignature read(JsonReader in) throws IOException {
    if (in.peek() != JsonToken.BEGIN_OBJECT)
        return null;

    GUISignature signature = new GUISignature();
    Map<String, Object> contents = new HashMap<>();
    in.beginObject();
    while (in.hasNext()) {
        String name = in.nextName();
        switch (name) {
            case "type":
                signature.type(InventoryType.valueOf(in.nextString()));
                break;
            case "title":
                signature.title(in.nextString());
                break;
            case "size":
                signature.size(in.nextInt());
                break;
            case "handlerIndexes":
                for (Number index : (Collection<Number>) collectionAdapter.read(in)) {
                    signature.addHandlerIndexes(index.intValue());
                }
                break;
            case "data":
                contents = mapAdapter.read(in);
                break;
            default:
                Static.log("Unknown type, " + name);
        }
    }

    for (Map.Entry<String, Object> entry : contents.entrySet()) {
        Integer key = Integer.parseInt(entry.getKey());
        Object value = entry.getValue();
        if (value instanceof Map) {
            signature.item(key, ConfigurationSerializableAdapter.deserialize((Map<String, Object>) entry.getValue()));
        } else {
            Number numVal = (Number) value;
            signature.item(key, signature.getContents().get(numVal.intValue()));
        }
    }
    in.endObject();

    return signature;
}
 

public static <T> int readMessage(JsonReader reader,String tableName,Class<T> clazz,long last_sync_ts) throws IOException, JSONException,Exception {    
String n = null;
int i=0;

 		while (reader.hasNext()) {
 			JsonToken peek=reader.peek();

 			String v = null;
 			if (peek==JsonToken.BEGIN_OBJECT) {
 				reader.beginObject();
 			} else if (peek==JsonToken.NAME) {
 				n=reader.nextName();
 			} else if (peek==JsonToken.BEGIN_ARRAY) {   				
 				if (n.equals(tableName)) {
 					i=readJsnArr(reader,tableName,clazz);
 					
 				} else {
 					if (n.equals("params")) {
 						reader.beginArray();
 						if (reader.hasNext()) {
 						reader.beginObject();
 						if (reader.hasNext()) {
  						n=reader.nextName();
  						v=reader.nextString();
 						}
 						reader.endObject();
 						}
 						reader.endArray();
 					} else {
 						reader.skipValue();
 					}
 				}
 			} else if (peek==JsonToken.END_OBJECT) {
 				reader.endObject();
 			} else if (peek==JsonToken.END_ARRAY) {
 				reader.endArray();
 			} else if (peek==JsonToken.STRING) {
              reader.skipValue();
          } else {
              reader.skipValue();
          }
 		}
 		return i;      
  }