Java JSONToken.LBRACKET属性代码示例

@SuppressWarnings("unchecked")
public <T> T deserialze(DefaultJSONParser parser, Type type, Object fieldName) {
    Image image = new Image();

    final JSONLexer lexer = parser.getLexer();
    if (lexer.token() != JSONToken.LBRACKET) {
        throw new JSONException("error");
    }
    
    int height = lexer.scanInt(',');
    int width = lexer.scanInt(',');
    String sizeName = lexer.scanSymbolWithSeperator(parser.getSymbolTable(), ',');
    String title = lexer.scanString(',');
    String uri = lexer.scanString(']');
    
    lexer.nextToken(JSONToken.COMMA);
    
    image.setHeight(height);
    image.setWidth(width);
    image.setSize(Size.valueOf(sizeName));
    image.setTitle(title);
    image.setUri(uri);
    return (T) image;
}
 

private void _quickNextToken(Context context, MethodVisitor mw, int token) {
    Label quickElse_ = new Label(), quickEnd_ = new Label();
    mw.visitVarInsn(ALOAD, context.var("lexer"));
    mw.visitMethodInsn(INVOKEVIRTUAL, JSONLexerBase, "getCurrent", "()C");
    if (token == JSONToken.LBRACE) {
        mw.visitVarInsn(BIPUSH, '{');
    } else if (token == JSONToken.LBRACKET) {
        mw.visitVarInsn(BIPUSH, '[');
    } else {
        throw new IllegalStateException();
    }

    mw.visitJumpInsn(IF_ICMPNE, quickElse_);

    mw.visitVarInsn(ALOAD, context.var("lexer"));
    mw.visitMethodInsn(INVOKEVIRTUAL, JSONLexerBase, "next", "()C");
    mw.visitInsn(POP);
    mw.visitVarInsn(ALOAD, context.var("lexer"));
    mw.visitLdcInsn(token);
    mw.visitMethodInsn(INVOKEVIRTUAL, JSONLexerBase, "setToken", "(I)V");
    mw.visitJumpInsn(GOTO, quickEnd_);

    mw.visitLabel(quickElse_);
    mw.visitVarInsn(ALOAD, context.var("lexer"));
    mw.visitLdcInsn(token);
    mw.visitMethodInsn(INVOKEVIRTUAL, JSONLexerBase, "nextToken", "(I)V");

    mw.visitLabel(quickEnd_);
}
 

@SuppressWarnings({ "unchecked", "rawtypes" })
public final void parseArray(DefaultJSONParser parser, Type objectType, Collection array) {
    Type itemType = this.itemType;
    ObjectDeserializer itemTypeDeser = this.deserializer;
    
    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 (!itemType.equals(this.itemType)) {
                itemTypeDeser = parser.getConfig().getDeserializer(itemType);
            }
        }
    }

    final JSONLexer lexer = parser.getLexer();

    if (lexer.token() != JSONToken.LBRACKET) {
        String errorMessage = "exepct '[', but " + JSONToken.name(lexer.token());
        if (objectType != null) {
            errorMessage += ", type : " + objectType;
        }
        throw new JSONException(errorMessage);
    }

    if (itemTypeDeser == null) {
        itemTypeDeser = deserializer = parser.getConfig().getDeserializer(itemType);
        itemFastMatchToken = deserializer.getFastMatchToken();
    }

    lexer.nextToken(itemFastMatchToken);

    for (int i = 0;; ++i) {
        if (lexer.isEnabled(Feature.AllowArbitraryCommas)) {
            while (lexer.token() == JSONToken.COMMA) {
                lexer.nextToken();
                continue;
            }
        }

        if (lexer.token() == JSONToken.RBRACKET) {
            break;
        }

        Object val = itemTypeDeser.deserialze(parser, itemType, i);
        array.add(val);

        parser.checkListResolve(array);

        if (lexer.token() == JSONToken.COMMA) {
            lexer.nextToken(itemFastMatchToken);
            continue;
        }
    }

    lexer.nextToken(JSONToken.COMMA);
}
 

public int getFastMatchToken() {
    return JSONToken.LBRACKET;
}
 

@SuppressWarnings({ "unchecked", "rawtypes" })
    protected static void parseArray(Collection collection, //
                              ObjectDeserializer deser, //
                              DefaultJSONParser parser, //
                              Type type, //
                              Object fieldName) {

        final JSONLexerBase lexer = (JSONLexerBase) parser.lexer;
        int token = lexer.token();
        if (token == JSONToken.NULL) {
            lexer.nextToken(JSONToken.COMMA);
            token = lexer.token();
            return;
        }

        if (token != JSONToken.LBRACKET) {
            parser.throwException(token);
        }
        char ch = lexer.getCurrent();
        if (ch == '[') {
            lexer.next();
            lexer.setToken(JSONToken.LBRACKET);
        } else {
            lexer.nextToken(JSONToken.LBRACKET);
        }
        
        if (lexer.token() == JSONToken.RBRACKET) {
            lexer.nextToken();
            return;
        }

        int index = 0;
        for (;;) {
            Object item = deser.deserialze(parser, type, index);
            collection.add(item);
            index++;
            if (lexer.token() == JSONToken.COMMA) {
                ch = lexer.getCurrent();
                if (ch == '[') {
                    lexer.next();
                    lexer.setToken(JSONToken.LBRACKET);
                } else {
                    lexer.nextToken(JSONToken.LBRACKET);
                }
            } else {
                break;
            }
        }
        
        token = lexer.token();
        if (token != JSONToken.RBRACKET) {
            parser.throwException(token);
        }
        
        ch = lexer.getCurrent();
        if (ch == ',') {
            lexer.next();
            lexer.setToken(JSONToken.COMMA);
        } else {
            lexer.nextToken(JSONToken.COMMA);
        }
//        parser.accept(JSONToken.RBRACKET, JSONToken.COMMA);
    }
 

@SuppressWarnings("unchecked")
public <T> T deserialze(DefaultJSONParser parser, Type type, Object fieldName) {
    final JSONLexer lexer = parser.getLexer();

    if (lexer.token() != JSONToken.LBRACKET) {
        throw new JSONException("error");
    }

    Media media = new Media();

    int bitrate = lexer.scanInt(',');
    int height = lexer.scanInt(',');
    int width = lexer.scanInt(',');
    String copyright = lexer.scanString(',');
    long duration = lexer.scanLong(',');
    String format = lexer.scanString(',');

    List<String> persons = new ArrayList<String>();
    lexer.scanStringArray(persons, ',');

    String playerName = lexer.scanSymbolWithSeperator(parser.getSymbolTable(), ',');
    long size = lexer.scanLong(',');
    String title = lexer.scanString(',');
    String uri = lexer.scanString(']');

    lexer.nextToken(JSONToken.COMMA);

    media.setBitrate(bitrate);
    media.setHeight(height);
    media.setWidth(width);
    media.setCopyright(copyright);
    media.setDuration(duration);
    media.setFormat(format);
    media.setPersons(persons);
    media.setPlayer(playerName == null ? null : Player.valueOf(playerName));
    media.setSize(size);
    media.setTitle(title);
    media.setUri(uri);

    return (T) media;

}