Example #1
0
  @Override
  public void parseField(
      DefaultJSONParser parser, Object object, Type objectType, Map<String, Object> fieldValues) {
    Integer value;

    final JSONLexer lexer = parser.getLexer();
    if (lexer.token() == JSONToken.LITERAL_INT) {
      int val = lexer.intValue();
      lexer.nextToken(JSONToken.COMMA);
      if (object == null) {
        fieldValues.put(fieldInfo.getName(), val);
      } else {
        setValue(object, val);
      }
      return;
    } else if (lexer.token() == JSONToken.NULL) {
      value = null;
      lexer.nextToken(JSONToken.COMMA);
    } else {
      Object obj = parser.parse();

      value = TypeUtils.castToInt(obj);
    }

    if (value == null && getFieldClass() == int.class) {
      // skip
      return;
    }

    if (object == null) {
      fieldValues.put(fieldInfo.getName(), value);
    } else {
      setValue(object, value);
    }
  }
Example #2
0
  public static JSONArray parseArray(String text) {
    if (text == null) {
      return null;
    }

    DefaultJSONParser parser = new DefaultJSONParser(text, ParserConfig.getGlobalInstance());

    JSONArray array;

    JSONLexer lexer = parser.getLexer();
    if (lexer.token() == JSONToken.NULL) {
      lexer.nextToken();
      array = null;
    } else if (lexer.token() == JSONToken.EOF) {
      array = null;
    } else {
      array = new JSONArray();
      parser.parseArray(array);

      parser.handleResovleTask(array);
    }

    parser.close();

    return array;
  }
  public void test_0() throws Exception {
    DefaultJSONParser parser =
        new DefaultJSONParser("{\"id\":3, \"name\":\"xx\"}", ParserConfig.getGlobalInstance());

    Entity entity = new Entity();
    parser.parseObject(entity);
  }
 public void test_error_4() throws Exception {
   JSONException error = null;
   try {
     DefaultJSONParser parser = new DefaultJSONParser("{\"a\"3}");
     parser.parseObject(A.class);
   } catch (JSONException e) {
     error = e;
   }
   Assert.assertNotNull(error);
 }
Example #5
0
  @SuppressWarnings("unchecked")
  public <T> T deserialze(DefaultJSONParser parser, Type clazz, Object fieldName) {
    JSONLexer lexer = parser.getLexer();

    if (lexer.token() == JSONToken.COMMA) {
      lexer.nextToken(JSONToken.LITERAL_STRING);

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

      lexer.nextTokenWithColon(JSONToken.LITERAL_INT);

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

      long time = lexer.longValue();
      lexer.nextToken(JSONToken.RBRACE);
      if (lexer.token() != JSONToken.RBRACE) {
        throw new JSONException("syntax error");
      }
      lexer.nextToken(JSONToken.COMMA);

      return (T) new java.sql.Time(time);
    }

    Object val = parser.parse();

    if (val == null) {
      return null;
    }

    if (val instanceof java.sql.Time) {
      return (T) val;
    } else if (val instanceof Number) {
      return (T) new java.sql.Time(((Number) val).longValue());
    } else if (val instanceof String) {
      String strVal = (String) val;
      if (strVal.length() == 0) {
        return null;
      }

      long longVal;
      JSONScanner dateLexer = new JSONScanner(strVal);
      if (dateLexer.scanISO8601DateIfMatch()) {
        longVal = dateLexer.getCalendar().getTimeInMillis();
      } else {
        longVal = Long.parseLong(strVal);
      }
      return (T) new java.sql.Time(longVal);
    }

    throw new JSONException("parse error");
  }
 public void test_error_6() throws Exception {
   JSONException error = null;
   try {
     DefaultJSONParser parser = new DefaultJSONParser("{'a':3}");
     parser.config(Feature.AllowSingleQuotes, false);
     parser.parseObject(A.class);
   } catch (JSONException e) {
     error = e;
   }
   Assert.assertNotNull(error);
 }
 public void test_error_0() throws Exception {
   Exception error = null;
   try {
     String text = "[{\"old\":false,\"name\":\"æ ¡é•¿\",\"age\":3,\"salary\":123456789.0123]";
     DefaultJSONParser parser = new DefaultJSONParser(text);
     parser.parseArray(User.class);
   } catch (Exception ex) {
     error = ex;
   }
   Assert.assertNotNull(error);
 }
 public void test_error_3() throws Exception {
   JSONException error = null;
   try {
     DefaultJSONParser parser = new DefaultJSONParser("{");
     parser.config(Feature.AllowUnQuotedFieldNames, true);
     parser.parseObject(A.class);
   } catch (JSONException e) {
     error = e;
   }
   Assert.assertNotNull(error);
 }
  public void test_getInput() {
    String text = "{,,}";
    char[] chars = text.toCharArray();
    DefaultJSONParser parser =
        new DefaultJSONParser(chars, chars.length, ParserConfig.getGlobalInstance(), 0);

    JSONException error = null;
    try {
      parser.parseObject();
    } catch (JSONException ex) {
      error = ex;
    }
    Assert.assertNotNull(error);
  }
Example #10
0
  public static Object parse(String text, int features) {
    if (text == null) {
      return null;
    }

    DefaultJSONParser parser =
        new DefaultJSONParser(text, ParserConfig.getGlobalInstance(), features);
    Object value = parser.parse();

    parser.handleResovleTask(value);

    parser.close();

    return value;
  }
Example #11
0
  @SuppressWarnings("unchecked")
  public <T> T deserialze(DefaultJSONParser parser, Type type, Object fieldName) {
    final JSONLexer lexer = parser.getLexer();
    if (lexer.token() == JSONToken.NULL) {
      lexer.nextToken(JSONToken.COMMA);
      return null;
    }

    Map<Object, Object> map = createMap(type);

    ParseContext context = parser.getContext();

    try {
      parser.setContext(context, map, fieldName);
      return (T) deserialze(parser, type, fieldName, map);
    } finally {
      parser.setContext(context);
    }
  }
Example #12
0
  @SuppressWarnings("unchecked")
  public static <T> T parseObject(char[] input, int length, Type clazz, Feature... features) {
    if (input == null || input.length == 0) {
      return null;
    }

    int featureValues = DEFAULT_PARSER_FEATURE;
    for (Feature feature : features) {
      featureValues = Feature.config(featureValues, feature, true);
    }

    DefaultJSONParser parser =
        new DefaultJSONParser(input, length, ParserConfig.getGlobalInstance(), featureValues);
    T value = (T) parser.parseObject(clazz);

    parser.handleResovleTask(value);

    parser.close();

    return (T) value;
  }
Example #13
0
  @SuppressWarnings("unchecked")
  public static <T> T parseObject(
      String input, Type clazz, int featureValues, Feature... features) {
    if (input == null) {
      return null;
    }

    for (Feature feature : features) {
      featureValues = Feature.config(featureValues, feature, true);
    }

    DefaultJSONParser parser =
        new DefaultJSONParser(input, ParserConfig.getGlobalInstance(), featureValues);
    T value = (T) parser.parseObject(clazz);

    parser.handleResovleTask(value);

    parser.close();

    return (T) value;
  }
Example #14
0
  public static List<Object> parseArray(String text, Type[] types) {
    if (text == null) {
      return null;
    }

    List<Object> list;

    DefaultJSONParser parser = new DefaultJSONParser(text, ParserConfig.getGlobalInstance());
    Object[] objectArray = parser.parseArray(types);
    if (objectArray == null) {
      list = null;
    } else {
      list = Arrays.asList(objectArray);
    }

    parser.handleResovleTask(list);

    parser.close();

    return list;
  }
Example #15
0
  @SuppressWarnings("unchecked")
  public static <T> T parseObject(
      String input,
      Type clazz,
      ParserConfig config,
      ParseProcess processor,
      int featureValues,
      Feature... features) {
    if (input == null) {
      return null;
    }

    for (Feature feature : features) {
      featureValues = Feature.config(featureValues, feature, true);
    }

    DefaultJSONParser parser = new DefaultJSONParser(input, config, featureValues);

    if (processor instanceof ExtraTypeProvider) {
      parser.getExtraTypeProviders().add((ExtraTypeProvider) processor);
    }

    if (processor instanceof ExtraProcessor) {
      parser.getExtraProcessors().add((ExtraProcessor) processor);
    }

    T value = (T) parser.parseObject(clazz);

    parser.handleResovleTask(value);

    parser.close();

    return (T) value;
  }
  public void test_1() throws Exception {
    JSONObject res = new JSONObject();
    res.put("a", 1);
    res.put("b", 2);
    res.put("c", 3);

    String[] tests = {
      "{ 'a':1, 'b':2, 'c':3 }",
      "{ 'a':1,,'b':2, 'c':3 }",
      "{,'a':1, 'b':2, 'c':3 }",
      "{'a':1, 'b':2, 'c':3,,}",
      "{,,'a':1,,,,'b':2,'c':3,,,,,}",
    };

    for (String t : tests) {
      DefaultJSONParser ext = new DefaultJSONParser(t);
      ext.config(Feature.AllowArbitraryCommas, true);

      JSONObject extRes = ext.parseObject();
      Assert.assertEquals(res, extRes);

      DefaultJSONParser basic = new DefaultJSONParser(t);
      basic.config(Feature.AllowArbitraryCommas, true);
      JSONObject basicRes = basic.parseObject();
      Assert.assertEquals(res, basicRes);
    }
  }
  public void test_2() throws Exception {
    A res = new A();
    res.setA(1);
    res.setB(2);
    res.setC(3);

    String[] tests = {
      "{ 'a':1, 'b':2, 'c':3 }",
      "{ 'a':1,,'b':2, 'c':3 }",
      "{,'a':1, 'b':2, 'c':3 }",
      "{'a':1, 'b':2, 'c':3,,}",
      "{,,'a':1,,,,'b':2,,'c':3,,,,,}",
    };

    for (String t : tests) {
      DefaultJSONParser ext = new DefaultJSONParser(t);
      ext.config(Feature.AllowArbitraryCommas, true);

      A extRes = ext.parseObject(A.class);
      Assert.assertEquals(res, extRes);
    }
  }
Example #18
0
  @SuppressWarnings("unchecked")
  public static <T> T deserialze(DefaultJSONParser parser) {
    final JSONLexer lexer = parser.getLexer();
    if (lexer.token() == JSONToken.LITERAL_INT) {
      long val = lexer.longValue();
      lexer.nextToken(JSONToken.COMMA);
      return (T) new BigDecimal(val);
    }

    if (lexer.token() == JSONToken.LITERAL_FLOAT) {
      BigDecimal val = lexer.decimalValue();
      lexer.nextToken(JSONToken.COMMA);
      return (T) val;
    }

    Object value = parser.parse();

    if (value == null) {
      return null;
    }

    return (T) TypeUtils.castToBigDecimal(value);
  }
Example #19
0
  public static Object parse(
      byte[] input, int off, int len, CharsetDecoder charsetDecoder, int features) {
    charsetDecoder.reset();

    int scaleLength = (int) (len * (double) charsetDecoder.maxCharsPerByte());
    char[] chars = ThreadLocalCache.getChars(scaleLength);

    ByteBuffer byteBuf = ByteBuffer.wrap(input, off, len);
    CharBuffer charBuf = CharBuffer.wrap(chars);
    IOUtils.decode(charsetDecoder, byteBuf, charBuf);

    int position = charBuf.position();

    DefaultJSONParser parser =
        new DefaultJSONParser(chars, position, ParserConfig.getGlobalInstance(), features);
    Object value = parser.parse();

    parser.handleResovleTask(value);

    parser.close();

    return value;
  }
Example #20
0
  public static <T> List<T> parseArray(String text, Class<T> clazz) {
    if (text == null) {
      return null;
    }

    List<T> list;

    DefaultJSONParser parser = new DefaultJSONParser(text, ParserConfig.getGlobalInstance());
    JSONLexer lexer = parser.getLexer();
    if (lexer.token() == JSONToken.NULL) {
      lexer.nextToken();
      list = null;
    } else {
      list = new ArrayList<T>();
      parser.parseArray(clazz, list);

      parser.handleResovleTask(list);
    }

    parser.close();

    return list;
  }
Example #21
0
  @SuppressWarnings({"rawtypes", "unchecked"})
  protected Object deserialze(DefaultJSONParser parser, Type type, Object fieldName, Map map) {
    if (type instanceof ParameterizedType) {
      ParameterizedType parameterizedType = (ParameterizedType) type;
      Type keyType = parameterizedType.getActualTypeArguments()[0];
      Type valueType = parameterizedType.getActualTypeArguments()[1];

      if (String.class == keyType) {
        return parseMap(parser, (Map<String, Object>) map, valueType, fieldName);
      } else {
        return parseMap(parser, map, keyType, valueType, fieldName);
      }
    } else {
      return parser.parseObject(map, fieldName);
    }
  }
Example #22
0
  @SuppressWarnings("unchecked")
  public static <T> T deserialze(DefaultJSONParser parser) {
    final JSONLexer lexer = parser.lexer;
    if (lexer.token() == JSONToken.LITERAL_INT) {
      String val = lexer.numberString();
      lexer.nextToken(JSONToken.COMMA);
      return (T) Float.valueOf(Float.parseFloat(val));
    }

    if (lexer.token() == JSONToken.LITERAL_FLOAT) {
      float val = lexer.floatValue();
      lexer.nextToken(JSONToken.COMMA);
      return (T) Float.valueOf(val);
    }

    Object value = parser.parse();

    if (value == null) {
      return null;
    }

    return (T) TypeUtils.castToFloat(value);
  }
  public void test_0() throws Exception {
    List<?> res = Arrays.asList(1, 2, 3);
    String[] tests = {
      "[1,2,3]", "[1,,2,3]", "[1,2,,,3]", "[1 2,,,3]", "[1 2 3]", "[1, 2, 3,,]", "[,,1, 2, 3,,]",
    };

    for (String t : tests) {
      DefaultJSONParser ext = new DefaultJSONParser(t);
      ext.config(Feature.AllowArbitraryCommas, true);
      List<Object> extRes = ext.parseArray(Object.class);
      Assert.assertEquals(res, extRes);

      DefaultJSONParser basic = new DefaultJSONParser(t);
      basic.config(Feature.AllowArbitraryCommas, true);
      List<Object> basicRes = new ArrayList<Object>();
      basic.parseArray(basicRes);
      Assert.assertEquals(res, basicRes);
    }
  }
Example #24
0
  public Object deserialze(DefaultJSONParser parser, Type type, Object fieldName) {
    JSONLexerBase lexer = (JSONLexerBase) parser.getLexer();

    if (lexer.isEnabled(Feature.SortFeidFastMatch)) {
      return super.deserialze(parser, type, fieldName);
    }

    if (isSupportArrayToBean(lexer)) {
      // deserialzeArrayMapping
    }

    if (lexer.scanType("Department") == JSONLexerBase.NOT_MATCH) {
      return super.deserialze(parser, type, fieldName);
    }

    ParseContext mark_context = parser.getContext();
    int matchedCount = 0;
    Department instance = new Department();

    ParseContext context = parser.getContext();
    ParseContext childContext = parser.setContext(context, instance, fieldName);

    if (lexer.matchStat == JSONLexerBase.END) {
      return instance;
    }

    int matchStat = 0;
    int _asm_flag_0 = 0;
    int id_gen = 0;
    com.alibaba.json.test.codegen.Employee leader_gen = null;
    java.util.List members_gen = null;
    String name_gen;
    if (lexer.isEnabled(Feature.InitStringFieldAsEmpty)) {
      name_gen = lexer.stringDefaultValue();
      _asm_flag_0 |= 8;
    } else {
      name_gen = null;
    }
    boolean root_gen = false;
    com.alibaba.json.test.codegen.DepartmentType type_gen = null;
    boolean endFlag = false, restFlag = false;

    if ((!endFlag) && (!restFlag)) {
      id_gen = lexer.scanFieldInt(id_gen_prefix__);
      if (lexer.matchStat > 0) {
        _asm_flag_0 |= 1;
        matchedCount++;
      }
      if (lexer.matchStat == JSONLexerBase.NOT_MATCH) {
        restFlag = true;
      }
      if (lexer.matchStat == JSONLexerBase.END) {
        endFlag = true;
      }
    }
    if ((!endFlag) && (!restFlag)) {
      if (lexer.matchField(leader_gen_prefix__)) {
        _asm_flag_0 |= 2;
        matchedCount++;
        if (parser.getResolveStatus() == DefaultJSONParser.NeedToResolve) {
          ResolveTask resolveTask = parser.getLastResolveTask();
          resolveTask.ownerContext = parser.getContext();
          resolveTask.fieldDeserializer = this.getFieldDeserializer("leader");
          parser.setResolveStatus(DefaultJSONParser.NONE);
        }
      }
      if (lexer.matchStat > 0) {
        _asm_flag_0 |= 2;
        matchedCount++;
      }
      if (lexer.matchStat == JSONLexerBase.NOT_MATCH) {
        restFlag = true;
      }
      if (lexer.matchStat == JSONLexerBase.END) {
        endFlag = true;
      }
    }
    if ((!endFlag) && (!restFlag)) {
      if (lexer.matchField(members_gen_prefix__)) {
        _asm_flag_0 |= 4;
        if (lexer.token() == JSONToken.NULL) {
          lexer.nextToken(JSONToken.COMMA);
        } else {
          if (lexer.token() == JSONToken.LBRACKET) {
            if (members_gen_list_item_deser__ == null) {
              members_gen_list_item_deser__ =
                  parser.getConfig().getDeserializer(com.alibaba.json.test.codegen.Employee.class);
            }
            final int fastMatchToken = members_gen_list_item_deser__.getFastMatchToken();
            lexer.nextToken(fastMatchToken);
            members_gen = new java.util.ArrayList();
            ParseContext listContext = parser.getContext();
            parser.setContext(members_gen, "members");

            for (int i = 0; ; ++i) {
              if (lexer.token() == JSONToken.RBRACKET) {
                break;
              }
              com.alibaba.json.test.codegen.Employee itemValue =
                  members_gen_list_item_deser__.deserialze(parser, members_gen_list_item_type__, i);
              members_gen.add(itemValue);
              parser.checkListResolve(members_gen);
              if (lexer.token() == JSONToken.COMMA) {
                lexer.nextToken(fastMatchToken);
              }
            }
            parser.setContext(listContext);
            if (lexer.token() != JSONToken.RBRACKET) {
              restFlag = true;
            }
            lexer.nextToken(JSONToken.COMMA);

          } else {
            restFlag = true;
          }
        }
      }
      if (lexer.matchStat > 0) {
        _asm_flag_0 |= 4;
        matchedCount++;
      }
      if (lexer.matchStat == JSONLexerBase.NOT_MATCH) {
        restFlag = true;
      }
      if (lexer.matchStat == JSONLexerBase.END) {
        endFlag = true;
      }
    }
    if ((!endFlag) && (!restFlag)) {
      name_gen = lexer.scanFieldString(name_gen_prefix__);
      if (lexer.matchStat > 0) {
        _asm_flag_0 |= 8;
        matchedCount++;
      }
      if (lexer.matchStat == JSONLexerBase.NOT_MATCH) {
        restFlag = true;
      }
      if (lexer.matchStat == JSONLexerBase.END) {
        endFlag = true;
      }
    }
    if ((!endFlag) && (!restFlag)) {
      root_gen = lexer.scanFieldBoolean(root_gen_prefix__);
      if (lexer.matchStat > 0) {
        _asm_flag_0 |= 16;
        matchedCount++;
      }
      if (lexer.matchStat == JSONLexerBase.NOT_MATCH) {
        restFlag = true;
      }
      if (lexer.matchStat == JSONLexerBase.END) {
        endFlag = true;
      }
    }
    if ((!endFlag) && (!restFlag)) {
      String type_gen_enum_name = lexer.scanFieldSymbol(type_gen_prefix__, parser.getSymbolTable());
      if (type_gen_enum_name == null) {
        type_gen = com.alibaba.json.test.codegen.DepartmentType.valueOf(type_gen_enum_name);
      }
      if (lexer.matchStat > 0) {
        _asm_flag_0 |= 32;
        matchedCount++;
      }
      if (lexer.matchStat == JSONLexerBase.NOT_MATCH) {
        restFlag = true;
      }
      if (lexer.matchStat != JSONLexerBase.END) {
        restFlag = true;
      }
    }

    if (restFlag) {
      return super.parseRest(parser, type, fieldName, instance);
    }

    return instance;
  }
Example #25
0
 @SuppressWarnings("unchecked")
 public <T> T deserialze(DefaultJSONParser parser, Type type, Object fieldName) {
   type = TypeUtils.unwrapOptional(type);
   Object value = parser.parseObject(type);
   return (T) Optional.of(value);
 }
Example #26
0
  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;
  }
Example #27
0
  @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 void test_4() throws Exception {
   DefaultJSONParser parser = new DefaultJSONParser("{a:3}");
   parser.config(Feature.AllowUnQuotedFieldNames, true);
   LinkedHashMap a = parser.parseObject(LinkedHashMap.class);
   Assert.assertEquals(3, a.get("a"));
 }
 public void test_1() throws Exception {
   DefaultJSONParser parser = new DefaultJSONParser("{a:3}");
   parser.config(Feature.AllowUnQuotedFieldNames, true);
   A a = parser.parseObject(A.class);
   Assert.assertEquals(3, a.getA());
 }
 public void test_0() throws Exception {
   DefaultJSONParser parser = new DefaultJSONParser("{'a':3}");
   parser.config(Feature.AllowSingleQuotes, true);
   A a = parser.parseObject(A.class);
   Assert.assertEquals(3, a.getA());
 }