@SuppressWarnings("rawtypes")
public static Map parseMap(
DefaultJSONParser parser, Map<String, Object> map, Type valueType, Object fieldName) {
JSONLexer lexer = parser.getLexer();
if (lexer.token() != JSONToken.LBRACE) {
throw new JSONException("syntax error, expect {, actual " + lexer.token());
}
ParseContext context = parser.getContext();
try {
for (; ; ) {
lexer.skipWhitespace();
char ch = lexer.getCurrent();
if (parser.isEnabled(Feature.AllowArbitraryCommas)) {
while (ch == ',') {
lexer.next();
lexer.skipWhitespace();
ch = lexer.getCurrent();
}
}
String key;
if (ch == '"') {
key = lexer.scanSymbol(parser.getSymbolTable(), '"');
lexer.skipWhitespace();
ch = lexer.getCurrent();
if (ch != ':') {
throw new JSONException("expect ':' at " + lexer.pos());
}
} else if (ch == '}') {
lexer.next();
lexer.resetStringPosition();
lexer.nextToken(JSONToken.COMMA);
return map;
} else if (ch == '\'') {
if (!parser.isEnabled(Feature.AllowSingleQuotes)) {
throw new JSONException("syntax error");
}
key = lexer.scanSymbol(parser.getSymbolTable(), '\'');
lexer.skipWhitespace();
ch = lexer.getCurrent();
if (ch != ':') {
throw new JSONException("expect ':' at " + lexer.pos());
}
} else {
if (!parser.isEnabled(Feature.AllowUnQuotedFieldNames)) {
throw new JSONException("syntax error");
}
key = lexer.scanSymbolUnQuoted(parser.getSymbolTable());
lexer.skipWhitespace();
ch = lexer.getCurrent();
if (ch != ':') {
throw new JSONException("expect ':' at " + lexer.pos() + ", actual " + ch);
}
}
lexer.next();
lexer.skipWhitespace();
ch = lexer.getCurrent();
lexer.resetStringPosition();
if (key == JSON.DEFAULT_TYPE_KEY) {
String typeName = lexer.scanSymbol(parser.getSymbolTable(), '"');
Class<?> clazz = TypeUtils.loadClass(typeName);
if (clazz == map.getClass()) {
lexer.nextToken(JSONToken.COMMA);
if (lexer.token() == JSONToken.RBRACE) {
lexer.nextToken(JSONToken.COMMA);
return map;
}
continue;
}
ObjectDeserializer deserializer = parser.getConfig().getDeserializer(clazz);
lexer.nextToken(JSONToken.COMMA);
parser.setResolveStatus(DefaultJSONParser.TypeNameRedirect);
if (context != null && !(fieldName instanceof Integer)) {
parser.popContext();
}
return (Map) deserializer.deserialze(parser, clazz, fieldName);
}
Object value;
lexer.nextToken();
if (lexer.token() == JSONToken.NULL) {
value = null;
lexer.nextToken();
} else {
value = parser.parseObject(valueType);
}
map.put(key, value);
parser.checkMapResolve(map, key);
parser.setContext(context, value, key);
final int tok = lexer.token();
if (tok == JSONToken.EOF || tok == JSONToken.RBRACKET) {
return map;
}
if (tok == JSONToken.RBRACE) {
lexer.nextToken();
return map;
}
}
} finally {
parser.setContext(context);
}
}
public int getFastMatchToken() {
return fieldValueDeserilizer.getFastMatchToken();
}
public static Object parseMap(
DefaultJSONParser parser,
Map<Object, Object> map,
Type keyType,
Type valueType,
Object fieldName) {
JSONLexer lexer = parser.getLexer();
if (lexer.token() != JSONToken.LBRACE && lexer.token() != JSONToken.COMMA) {
throw new JSONException("syntax error, expect {, actual " + lexer.tokenName());
}
ObjectDeserializer keyDeserializer = parser.getConfig().getDeserializer(keyType);
ObjectDeserializer valueDeserializer = parser.getConfig().getDeserializer(valueType);
lexer.nextToken(keyDeserializer.getFastMatchToken());
ParseContext context = parser.getContext();
try {
for (; ; ) {
if (lexer.token() == JSONToken.RBRACE) {
lexer.nextToken(JSONToken.COMMA);
break;
}
if (lexer.token() == JSONToken.LITERAL_STRING && lexer.isRef()) {
Object object = null;
lexer.nextTokenWithColon(JSONToken.LITERAL_STRING);
if (lexer.token() == JSONToken.LITERAL_STRING) {
String ref = lexer.stringVal();
if ("..".equals(ref)) {
ParseContext parentContext = context.getParentContext();
object = parentContext.getObject();
} else if ("$".equals(ref)) {
ParseContext rootContext = context;
while (rootContext.getParentContext() != null) {
rootContext = rootContext.getParentContext();
}
object = rootContext.getObject();
} else {
parser.addResolveTask(new ResolveTask(context, ref));
parser.setResolveStatus(DefaultJSONParser.NeedToResolve);
}
} else {
throw new JSONException("illegal ref, " + JSONToken.name(lexer.token()));
}
lexer.nextToken(JSONToken.RBRACE);
if (lexer.token() != JSONToken.RBRACE) {
throw new JSONException("illegal ref");
}
lexer.nextToken(JSONToken.COMMA);
// parser.setContext(context, map, fieldName);
// parser.setContext(context);
return object;
}
if (map.size() == 0 //
&& lexer.token() == JSONToken.LITERAL_STRING //
&& JSON.DEFAULT_TYPE_KEY.equals(lexer.stringVal())) {
lexer.nextTokenWithColon(JSONToken.LITERAL_STRING);
lexer.nextToken(JSONToken.COMMA);
if (lexer.token() == JSONToken.RBRACE) {
lexer.nextToken();
return map;
}
lexer.nextToken(keyDeserializer.getFastMatchToken());
}
Object key = keyDeserializer.deserialze(parser, keyType, null);
if (lexer.token() != JSONToken.COLON) {
throw new JSONException("syntax error, expect :, actual " + lexer.token());
}
lexer.nextToken(valueDeserializer.getFastMatchToken());
Object value = valueDeserializer.deserialze(parser, valueType, key);
map.put(key, value);
if (lexer.token() == JSONToken.COMMA) {
lexer.nextToken(keyDeserializer.getFastMatchToken());
}
}
} finally {
parser.setContext(context);
}
return map;
}
@SuppressWarnings({"unchecked", "rawtypes"})
public final void parseArray(PBDeserializer parser, Type objectType, Collection array) {
Type itemType = this.itemType;
;
if (itemType instanceof TypeVariable && objectType instanceof ParameterizedType) {
TypeVariable typeVar = (TypeVariable) itemType;
ParameterizedType paramType = (ParameterizedType) objectType;
Class<?> objectClass = null;
if (paramType.getRawType() instanceof Class) {
objectClass = (Class<?>) paramType.getRawType();
}
int paramIndex = -1;
if (objectClass != null) {
for (int i = 0, size = objectClass.getTypeParameters().length; i < size; ++i) {
TypeVariable item = objectClass.getTypeParameters()[i];
if (item.getName().equals(typeVar.getName())) {
paramIndex = i;
break;
}
}
}
if (paramIndex != -1) {
itemType = paramType.getActualTypeArguments()[paramIndex];
}
}
if (deserializer == null) {
deserializer = parser.getDeserializer(itemType);
}
try {
// int tmpTag = parser.getTheCodedInputStream().readTag();
int tmpListItemCnt = parser.getTheCodedInputStream().readInt32();
for (int i = 0; i < tmpListItemCnt; i++) {
byte tmpIsNull = parser.getTheCodedInputStream().readRawByte();
if (tmpIsNull == 0) {
if (deserializer instanceof JavaObjectDeserializer) {
} else {
byte tmpType = parser.getTheCodedInputStream().readRawByte();
if (com.jd.glowworm.asm.Type.OBJECT == tmpType) {
if (deserializer
.getClass()
.getName()
.startsWith(ASMDeserializerFactory.DeserializerClassName_prefix)) {
parser.getTheCodedInputStream().readString();
}
}
}
Object val = deserializer.deserialze(parser, itemType, null);
array.add(val);
} else {
array.add(null);
}
}
} catch (Exception ex) {
ex.printStackTrace();
}
}
