/** Unit test to check for regression of [JACKSON-18]. */
  public void testSmallNumbers() throws Exception {
    ObjectMapper mapper = new ObjectMapper();
    ArrayNode root = mapper.createArrayNode();
    for (int i = -20; i <= 20; ++i) {
      JsonNode n = root.numberNode(i);
      root.add(n);
      // Hmmh. Not sure why toString() won't be triggered otherwise...
      assertEquals(String.valueOf(i), n.toString());
    }

    // Loop over 2 different serialization methods
    for (int type = 0; type < 2; ++type) {
      StringWriter sw = new StringWriter();
      if (type == 0) {
        JsonGenerator gen = new JsonFactory().createGenerator(sw);
        root.serialize(gen, null);
        gen.close();
      } else {
        mapper.writeValue(sw, root);
      }

      String doc = sw.toString();
      JsonParser p = new JsonFactory().createParser(new StringReader(doc));

      assertEquals(JsonToken.START_ARRAY, p.nextToken());
      for (int i = -20; i <= 20; ++i) {
        assertEquals(JsonToken.VALUE_NUMBER_INT, p.nextToken());
        assertEquals(i, p.getIntValue());
        assertEquals("" + i, p.getText());
      }
      assertEquals(JsonToken.END_ARRAY, p.nextToken());
      p.close();
    }
  }
  /*
   * (non-Javadoc)
   *
   * @see
   * org.codehaus.jackson.map.JsonDeserializer#deserialize(org.codehaus.jackson
   * .JsonParser, org.codehaus.jackson.map.DeserializationContext)
   */
  @Override
  public NamedErlangFunction deserialize(JsonParser jp, DeserializationContext ctxt)
      throws IOException, JsonProcessingException {

    JsonToken token = jp.getCurrentToken();

    if (JsonToken.START_OBJECT.equals(token)) {

      String mod = null;
      String fun = null;

      while (!JsonToken.END_OBJECT.equals(token)) {
        String field = jp.getCurrentName();

        if (Constants.FL_SCHEMA_FUN_MOD.equals(field)) {
          jp.nextToken();
          mod = jp.getText();
        } else if (Constants.FL_SCHEMA_FUN_FUN.equals(field)) {
          jp.nextToken();
          fun = jp.getText();
        }
        token = jp.nextToken();
      }
      if (mod != null && fun != null) {
        return new NamedErlangFunction(mod, fun);
      } else {
        return null;
      }
    }
    throw ctxt.mappingException(NamedErlangFunction.class);
  }
  /** @param bioID */
  private boolean setBioID(String bioID) {
    boolean toRet = false;
    try {
      JsonFactory factory = new JsonFactory();
      JsonParser jparser = factory.createParser(bioID);

      String key = "";
      // Get StartObject for JSON, after first {
      jparser.nextToken();
      while (jparser.nextToken() != JsonToken.END_OBJECT) {
        key = jparser.getText();

        if (key.equals("id")) {
          key = jparser.nextTextValue();

          // Set bioID in Experiment
          selExp.setBioID(key);

          toRet = true;
        } else {
          jparser.skipChildren();
        }
      }
      jparser.close();

    } catch (JsonParseException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    } catch (IOException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }

    return toRet;
  }
  public void testUtf8Issue462() throws Exception {
    ByteArrayOutputStream bytes = new ByteArrayOutputStream();
    IOContext ioc = new IOContext(new BufferRecycler(), bytes, true);
    JsonGenerator gen = new UTF8JsonGenerator(ioc, 0, null, bytes);
    String str = "Natuurlijk is alles gelukt en weer een tevreden klant\uD83D\uDE04";
    int length = 4000 - 38;

    for (int i = 1; i <= length; ++i) {
      gen.writeNumber(1);
    }
    gen.writeString(str);
    gen.flush();
    gen.close();

    // Also verify it's parsable?
    JsonFactory f = new JsonFactory();
    JsonParser p = f.createParser(bytes.toByteArray());
    for (int i = 1; i <= length; ++i) {
      assertToken(JsonToken.VALUE_NUMBER_INT, p.nextToken());
      assertEquals(1, p.getIntValue());
    }
    assertToken(JsonToken.VALUE_STRING, p.nextToken());
    assertEquals(str, p.getText());
    assertNull(p.nextToken());
    p.close();
  }
  @Override
  protected void read(ImpExt.Builder ext, JsonParser par) throws IOException {
    switch (getCurrentName(par)) {
      case "billing_id":
        for (startArray(par); endArray(par); par.nextToken()) {
          ext.addBillingId(par.getLongValue());
        }
        break;

      case "publisher_settings_list_id":
        for (startArray(par); endArray(par); par.nextToken()) {
          ext.addPublisherSettingsListId(par.getLongValue());
        }
        break;

      case "allowed_vendor_type":
        for (startArray(par); endArray(par); par.nextToken()) {
          ext.addAllowedVendorType(par.getIntValue());
        }
        break;

      case "publisher_parameter":
        for (startArray(par); endArray(par); par.nextToken()) {
          ext.addPublisherParameter(par.getText());
        }
        break;
    }
  }
  /**
   * Constructs a configuration file from a past configuration file that was saved to the disk.
   *
   * @param fileName - the path to the file on disk
   * @throws IOException - if there is any problem reading the file
   */
  public Configuration(final String fileName) throws IOException {
    final JsonFactory jf = new JsonFactory();
    final JsonParser jp = jf.createParser(new File(fileName));
    jp.nextToken();

    while (jp.nextToken() != JsonToken.END_OBJECT) {
      final String fieldName = jp.getCurrentName();
      jp.nextToken();
      switch (fieldName) {
        case IN_FILE_KEY:
          this.inputFileName = jp.getText();
          break;
        case IN_FILE_DIR_KEY:
          this.inputFileDirName = jp.getText();
          break;
        case SPLIT_PATTERN_KEY:
          this.splitPattern = jp.getText();
          break;
        case OUT_FILE_KEY:
          this.outDirName = jp.getText();
          break;
        case EXEC_LOC_KEY:
          this.execPath = jp.getText();
          break;
        case NUM_PROCESSES_KEY:
          this.numberOfThreads = jp.getIntValue();
          break;
        case STATS_KEY:
          this.makeStats = jp.getBooleanValue();
          break;
        case NUM_HEADER_KEY:
          this.numberOfHeaderLines = jp.getIntValue();
          break;
        case DEFAULT_MERGE_KEY:
          if (jp.getBooleanValue()) {
            this.mergeMethod = 0;
          }
          break;
        case CUSTOM_MERGE_KEY:
          if (jp.getBooleanValue()) {
            this.mergeMethod = 1;
          }
          break;
        case EXTERNAL_MERGE_KEY:
          if (jp.getBooleanValue()) {
            this.mergeMethod = 2;
          }
          break;
        case ARGUMENT_KEY:
          this.argument = jp.getText();
          break;
        case OUTPUT_FMT_KEY:
          this.outputFmt = jp.getBooleanValue();
          break;
        default:
          assert (false);
      }
    }
    jp.close();
  }
 private <T> String processData(
     final CrestApiProcessor<T> processor, final CrestContainer<T> container, final String data) {
   String next = null;
   try {
     final JsonFactory parserFactory = new JsonFactory();
     final JsonParser jsonParser = parserFactory.createParser(data);
     jsonParser.nextToken();
     while (jsonParser.nextToken() != JsonToken.END_OBJECT) {
       final String fieldname = jsonParser.getCurrentName();
       jsonParser.nextToken();
       switch (fieldname) {
         case "totalCount":
           container.setTotalCount(jsonParser.getIntValue());
           break;
         case "pageCount":
           container.setPageCount(jsonParser.getIntValue());
           break;
         case "items":
           processItems(processor, container, jsonParser);
           break;
         case "next":
           next = processNext(jsonParser);
           break;
         default:
           break;
       }
     }
   } catch (final IOException e) {
     if (LOGGER.isWarnEnabled()) {
       LOGGER.warn("Problems while parsing json data: " + e.getMessage(), e);
     }
   }
   return next;
 }
Example #8
0
  private void parseItemIdList(Reader in, IItemIdListHandler handler)
      throws JsonParseException, IOException, RemoteException {
    JsonFactory f = new JsonFactory();
    JsonParser jp = f.createParser(in);

    String currName;

    List<String> idList = new ArrayList<String>();

    jp.nextToken(); // will return JsonToken.START_OBJECT (verify?)
    while (jp.nextToken() != JsonToken.END_OBJECT) {
      currName = jp.getCurrentName();
      jp.nextToken(); // move to value, or START_OBJECT/START_ARRAY
      if (currName.equals("itemRefs")) { // contains an object
        // start items
        while (jp.nextToken() != JsonToken.END_ARRAY) {
          currName = jp.getCurrentName();
          if (currName == null) continue;
          jp.nextToken();
          if (currName.equals("id")) {
            idList.add(Utils.dec2Hex(jp.getText())); // convert dec to hex
          } else {
            jp.skipChildren();
          }
        }

        handler.items(idList);

      } else {
        jp.skipChildren();
      }
    }
  }
  @Override
  public LocalDate deserialize(JsonParser parser, DeserializationContext context)
      throws IOException {
    switch (parser.getCurrentToken()) {
      case START_ARRAY:
        if (parser.nextToken() == JsonToken.END_ARRAY) {
          return null;
        }
        int year = parser.getIntValue();

        parser.nextToken();
        int month = parser.getIntValue();

        parser.nextToken();
        int day = parser.getIntValue();

        if (parser.nextToken() != JsonToken.END_ARRAY) {
          throw context.wrongTokenException(parser, JsonToken.END_ARRAY, "Expected array to end.");
        }
        return LocalDate.of(year, month, day);

      case VALUE_STRING:
        String string = parser.getText().trim();
        if (string.length() == 0) {
          return null;
        }
        return LocalDate.parse(string, ISO_DATE_OPTIONAL_TIME);
    }
    throw context.wrongTokenException(parser, JsonToken.START_ARRAY, "Expected array or string.");
  }
  /**
   * Method for copying contents of the current event <b>and following events that it encloses</b>
   * the given parser instance points to.
   *
   * <p>So what constitutes enclosing? Here is the list of events that have associated enclosed
   * events that will get copied:
   *
   * <ul>
   *   <li>{@link JsonToken#START_OBJECT}: all events up to and including matching (closing) {@link
   *       JsonToken#END_OBJECT} will be copied
   *   <li>{@link JsonToken#START_ARRAY} all events up to and including matching (closing) {@link
   *       JsonToken#END_ARRAY} will be copied
   *   <li>{@link JsonToken#FIELD_NAME} the logical value (which can consist of a single scalar
   *       value; or a sequence of related events for structured types (Json Arrays, Objects)) will
   *       be copied along with the name itself. So essentially the whole <b>field entry</b> (name
   *       and value) will be copied.
   * </ul>
   *
   * <p>After calling this method, parser will point to the <b>last event</b> that was copied. This
   * will either be the event parser already pointed to (if there were no enclosed events), or the
   * last enclosed event copied.
   */
  @Override
  public void copyCurrentStructure(JsonParser jp) throws IOException, JsonProcessingException {
    JsonToken t = jp.getCurrentToken();

    // Let's handle field-name separately first
    if (t == JsonToken.FIELD_NAME) {
      writeFieldName(jp.getCurrentName());
      t = jp.nextToken();
      // fall-through to copy the associated value
    }

    switch (t) {
      case START_ARRAY:
        writeStartArray();
        while (jp.nextToken() != JsonToken.END_ARRAY) {
          copyCurrentStructure(jp);
        }
        writeEndArray();
        break;
      case START_OBJECT:
        writeStartObject();
        while (jp.nextToken() != JsonToken.END_OBJECT) {
          copyCurrentStructure(jp);
        }
        writeEndObject();
        break;
      default: // others are simple:
        copyCurrentEvent(jp);
    }
  }
Example #11
0
  @Override
  public void parse(T translator, JsonParser jsonParser) throws IOException {
    JsonParserWrapper wrapper = new JsonParserWrapper(jsonParser);
    wrapper.setShouldThrowExceptions(shouldThrowFieldExceptions());
    if (jsonParser.getCurrentToken() == null) {
      jsonParser.nextToken();
    }

    if (jsonParser.getCurrentToken() != JsonToken.START_OBJECT) {
      jsonParser.skipChildren();
    } else {
      if (translator instanceof ParseStatusListener) {
        ((ParseStatusListener) translator).onPreParse();
      }

      while (jsonParser.nextToken() != JsonToken.END_OBJECT) {
        String key = jsonParser.getCurrentName();
        jsonParser.nextToken();
        handleParse(translator, wrapper, jsonParser, key);
        jsonParser.skipChildren();
      }

      if (translator instanceof ParseStatusListener) {
        ((ParseStatusListener) translator).onParseComplete();
      }
    }
  }
 protected final String _locateTypeId(
     JsonParser paramJsonParser, DeserializationContext paramDeserializationContext)
     throws IOException {
   if (!paramJsonParser.isExpectedStartArrayToken()) {
     if (this._defaultImpl != null) {
       return this._idResolver.idFromBaseType();
     }
     throw paramDeserializationContext.wrongTokenException(
         paramJsonParser,
         JsonToken.START_ARRAY,
         "need JSON Array to contain As.WRAPPER_ARRAY type information for class "
             + baseTypeName());
   }
   if (paramJsonParser.nextToken() == JsonToken.VALUE_STRING) {
     paramDeserializationContext = paramJsonParser.getText();
     paramJsonParser.nextToken();
     return paramDeserializationContext;
   }
   if (this._defaultImpl != null) {
     return this._idResolver.idFromBaseType();
   }
   throw paramDeserializationContext.wrongTokenException(
       paramJsonParser,
       JsonToken.VALUE_STRING,
       "need JSON String that contains type id (for subtype of " + baseTypeName() + ")");
 }
 /** Sends a POST request to obtain an access token. */
 private void obtainAccessToken() {
   try {
     token = new OAuth2Token();
     error = new OAuth2Error();
     /* build the request and send it to the token server */
     CloseableHttpClient client = HttpClients.createDefault();
     HttpPost request = new HttpPost(tokenServer);
     request.setEntity(new UrlEncodedFormEntity(Utils.mapToList(tokenParams)));
     CloseableHttpResponse response = client.execute(request);
     HttpEntity entity = response.getEntity();
     /* get the response and parse it */
     JsonParser jp = json.getFactory().createParser(entity.getContent());
     while (jp.nextToken() != null) {
       JsonToken jsonToken = jp.getCurrentToken();
       switch (jsonToken) {
         case FIELD_NAME:
           String name = jp.getCurrentName();
           jsonToken = jp.nextToken();
           if (name.equals("access_token")) {
             token.setAccessToken(jp.getValueAsString());
           } else if (name.equals("token_type")) {
             token.setType(OAuth2TokenType.valueOf(jp.getValueAsString().toUpperCase()));
           } else if (name.equals("expires_in")) {
             token.setExpiresIn(jp.getValueAsInt());
           } else if (name.equals("refresh_token")) {
             token.setRefreshToken(jp.getValueAsString());
           } else if (name.equals("kid")) {
             token.setKeyId(jp.getValueAsString());
           } else if (name.equals("mac_key")) {
             token.setMacKey(jp.getValueAsString());
           } else if (name.equals("mac_algorithm")) {
             token.setMacAlgorithm(jp.getValueAsString());
           } else if (name.equals("error")) {
             error.setType(OAuth2ErrorType.valueOf(jp.getValueAsString().toUpperCase()));
           } else if (name.equals("error_description")) {
             error.setDescription(jp.getValueAsString());
           } else if (name.equals("error_uri")) {
             error.setUri(jp.getValueAsString());
           }
           ready = true;
           break;
         default:
           break;
       }
     }
     jp.close();
     response.close();
     client.close();
   } catch (IOException e) {
     error.setType(OAuth2ErrorType.SERVER_ERROR);
     error.setDescription("Failed to obtain access token from the server.");
   }
   /* notify all waiting objects */
   synchronized (waitObject) {
     ready = true;
     waitObject.notifyAll();
   }
 }
  @Override
  public ScimGroup deserialize(JsonParser jp, DeserializationContext ctxt)
      throws IOException, JsonProcessingException {
    ScimGroup group = new ScimGroup();

    Map<ScimGroupMember.Role, List<ScimGroupMember>> roles =
        new HashMap<ScimGroupMember.Role, List<ScimGroupMember>>();
    for (ScimGroupMember.Role role : ScimGroupMember.Role.values()) {
      roles.put(role, new ArrayList<ScimGroupMember>());
    }
    Set<ScimGroupMember> allMembers = new HashSet<ScimGroupMember>();

    while (jp.nextToken() != JsonToken.END_OBJECT) {
      if (jp.getCurrentToken() == JsonToken.FIELD_NAME) {
        String fieldName = jp.getCurrentName();
        jp.nextToken();

        if ("id".equalsIgnoreCase(fieldName)) {
          group.setId(jp.readValueAs(String.class));
        } else if ("displayname".equalsIgnoreCase(fieldName)) {
          group.setDisplayName(jp.readValueAs(String.class));
        } else if ("meta".equalsIgnoreCase(fieldName)) {
          group.setMeta(jp.readValueAs(ScimMeta.class));
        } else if ("schemas".equalsIgnoreCase(fieldName)) {
          group.setSchemas(jp.readValueAs(String[].class));
        } else {
          String value = fieldName.substring(0, fieldName.length() - 1);
          ScimGroupMember.Role role;
          try {
            role = ScimGroupMember.Role.valueOf(value.toUpperCase());
          } catch (IllegalArgumentException ex) {
            role = null;
          }
          if (role != null) {
            ScimGroupMember[] members = jp.readValueAs(ScimGroupMember[].class);
            for (ScimGroupMember member : members) {
              member.setRoles(new ArrayList<ScimGroupMember.Role>());
            }
            roles.get(role).addAll(Arrays.asList(members));
            allMembers.addAll(Arrays.asList(members));
          }
        }
      }
    }

    for (ScimGroupMember member : allMembers) {
      for (ScimGroupMember.Role role : roles.keySet()) {
        if (roles.get(role).contains(member)) {
          member.getRoles().add(role);
        }
      }
    }
    group.setMembers(new ArrayList<ScimGroupMember>(allMembers));

    return group;
  }
 private Map<String, Object> readHeaders(JsonParser parser, String jsonMessage) throws Exception {
   Map<String, Object> headers = new LinkedHashMap<String, Object>();
   while (JsonToken.END_OBJECT != parser.nextToken()) {
     String headerName = parser.getCurrentName();
     parser.nextToken();
     Object headerValue = this.readHeader(parser, headerName, jsonMessage);
     headers.put(headerName, headerValue);
   }
   return headers;
 }
 private String processNext(final JsonParser jsonParser) throws IOException {
   String next = null;
   jsonParser.nextToken();
   if (JsonPaths.HREF.equals(jsonParser.getCurrentName())) {
     jsonParser.nextToken();
     next = jsonParser.getText();
     jsonParser.nextToken();
   }
   return next;
 }
  public void testEmptyArrayWrite() throws Exception {
    StringWriter sw = new StringWriter();
    JsonGenerator gen = new JsonFactory().createGenerator(sw);

    JsonStreamContext ctxt = gen.getOutputContext();
    assertTrue(ctxt.inRoot());
    assertFalse(ctxt.inArray());
    assertFalse(ctxt.inObject());
    assertEquals(0, ctxt.getEntryCount());
    assertEquals(0, ctxt.getCurrentIndex());

    gen.writeStartArray();

    ctxt = gen.getOutputContext();
    assertFalse(ctxt.inRoot());
    assertTrue(ctxt.inArray());
    assertFalse(ctxt.inObject());
    assertEquals(0, ctxt.getEntryCount());
    assertEquals(0, ctxt.getCurrentIndex());

    gen.writeEndArray();

    ctxt = gen.getOutputContext();
    assertTrue("Should be in root, was " + ctxt.getTypeDesc(), ctxt.inRoot());
    assertFalse(ctxt.inArray());
    assertFalse(ctxt.inObject());
    assertEquals(1, ctxt.getEntryCount());
    // Index won't yet move
    assertEquals(0, ctxt.getCurrentIndex());

    gen.close();
    String docStr = sw.toString();
    JsonParser jp = createParserUsingReader(docStr);
    assertEquals(JsonToken.START_ARRAY, jp.nextToken());
    assertEquals(JsonToken.END_ARRAY, jp.nextToken());
    jp.close();

    // Ok, then array with nested empty array
    sw = new StringWriter();
    gen = new JsonFactory().createGenerator(sw);
    gen.writeStartArray();
    gen.writeStartArray();
    gen.writeEndArray();
    gen.writeEndArray();
    gen.close();
    docStr = sw.toString();
    jp = createParserUsingReader(docStr);
    assertEquals(JsonToken.START_ARRAY, jp.nextToken());
    assertEquals(JsonToken.START_ARRAY, jp.nextToken());
    assertEquals(JsonToken.END_ARRAY, jp.nextToken());
    assertEquals(JsonToken.END_ARRAY, jp.nextToken());
    assertEquals(null, jp.nextToken());
    jp.close();
  }
 private List<Image> readImages(JsonParser parser) throws IOException {
   if (parser.nextToken() != JsonToken.START_ARRAY) {
     reportIllegal(parser, JsonToken.START_ARRAY);
   }
   List<Image> images = new ArrayList<Image>();
   while (parser.nextToken() == JsonToken.START_OBJECT) {
     images.add(readImage(parser));
   }
   verifyCurrent(parser, JsonToken.END_ARRAY);
   return images;
 }
Example #19
0
  private void parseTagList(Reader in, ITagListHandler handler)
      throws JsonParseException, IOException, RemoteException {
    JsonFactory f = new JsonFactory();
    JsonParser jp = f.createParser(in);

    String currName;

    ITag tag = null;
    List<ITag> tagList = new ArrayList<ITag>();

    jp.nextToken(); // will return JsonToken.START_OBJECT (verify?)
    while (jp.nextToken() != JsonToken.END_OBJECT) {
      currName = jp.getCurrentName();
      jp.nextToken(); // move to value, or START_OBJECT/START_ARRAY
      if (currName.equals("tags")) { // contains an object
        // start items
        while (jp.nextToken() != JsonToken.END_ARRAY) {
          if (jp.getCurrentToken() == JsonToken.START_OBJECT) {
            tag = new ITag();
          } else if (jp.getCurrentToken() == JsonToken.END_OBJECT) {
            tagList.add(tag);
            tag = null;
          }

          currName = jp.getCurrentName();
          if (currName == null) continue;
          jp.nextToken();
          if (currName.equals("id")) {
            tag.uid = jp.getText();
            int i = tag.uid.indexOf("/label/");
            if (i != -1) {
              tag.label = tag.uid.substring(i + "/label/".length());
              // NOTE: @see ReaderManager#updateTagTypes
              tag.type = ITag.TYPE_TAG_LABEL;
            } else if (tag.uid.endsWith("state/com.google/starred")) {
              tag.label = "state/com.google/starred";
              tag.type = ITag.TYPE_TAG_STARRED;
            }
          } else if (currName.equals("sortid")) {
            tag.sortid = jp.getText();
          } else {
            jp.skipChildren();
          }
        }

        handler.tags(tagList);

      } else {
        jp.skipChildren();
      }
    }
  }
Example #20
0
  public void parseList(List<T> translatorTypes, JsonParser jsonParser) throws IOException {
    JsonParserWrapper wrapper = new JsonParserWrapper(jsonParser);

    if (jsonParser.getCurrentToken() == null) {
      jsonParser.nextToken();
    }

    if (jsonParser.getCurrentToken() == JsonToken.START_ARRAY) {
      while (jsonParser.nextToken() != JsonToken.END_ARRAY) {
        translatorTypes.add(wrapper.getCurrentValue(getType(), null));
      }
    }
  }
  @Override
  public EnumMap<?, ?> deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException {
    // Ok: must point to START_OBJECT
    if (jp.getCurrentToken() != JsonToken.START_OBJECT) {
      return _deserializeFromEmpty(jp, ctxt);
    }
    EnumMap result = constructMap();
    final JsonDeserializer<Object> valueDes = _valueDeserializer;
    final TypeDeserializer typeDeser = _valueTypeDeserializer;

    while ((jp.nextToken()) == JsonToken.FIELD_NAME) {
      String keyName = jp.getCurrentName(); // just for error message
      // but we need to let key deserializer handle it separately, nonetheless
      Enum<?> key = (Enum<?>) _keyDeserializer.deserializeKey(keyName, ctxt);
      if (key == null) {
        if (!ctxt.isEnabled(DeserializationFeature.READ_UNKNOWN_ENUM_VALUES_AS_NULL)) {
          throw ctxt.weirdStringException(
              keyName,
              _enumClass,
              "value not one of declared Enum instance names for " + _mapType.getKeyType());
        }
        /* 24-Mar-2012, tatu: Null won't work as a key anyway, so let's
         *  just skip the entry then. But we must skip the value as well, if so.
         */
        jp.nextToken();
        jp.skipChildren();
        continue;
      }
      // And then the value...
      JsonToken t = jp.nextToken();
      /* note: MUST check for nulls separately: deserializers will
       * not handle them (and maybe fail or return bogus data)
       */
      Object value;

      try {
        if (t == JsonToken.VALUE_NULL) {
          value = valueDes.getNullValue(ctxt);
        } else if (typeDeser == null) {
          value = valueDes.deserialize(jp, ctxt);
        } else {
          value = valueDes.deserializeWithType(jp, ctxt, typeDeser);
        }
      } catch (Exception e) {
        wrapAndThrow(e, result, keyName);
        return null;
      }
      result.put(key, value);
    }
    return result;
  }
 /**
  * reads until the next json object
  *
  * @return json object wrapper
  * @throws JsonParseException
  * @throws IOException
  */
 public JsonObjectReader next() throws JsonParseException, IOException {
   JsonToken tk = parser.nextToken();
   if (isObject) {
     if (tk == JsonToken.END_OBJECT) return null;
   } else {
     if (tk == JsonToken.END_ARRAY) return null;
   }
   if (lastObject != null && !lastObject.isParsed()) {
     throw new IllegalStateException(
         "The last object must be read complete before the next object can be parsed.");
   }
   parser.nextToken(); // { Token
   return lastObject = new JsonObjectReader(parser);
 }
Example #23
0
  // [core#191]: similarly, but for "short" symbols:
  public void testShortNameCollisionsViaParser() throws Exception {
    JsonFactory f = new JsonFactory();
    String json = _shortDoc191();
    JsonParser p;

    // First: ensure that char-based is fine
    p = f.createParser(json);
    while (p.nextToken() != null) {}
    p.close();

    // and then that byte-based
    p = f.createParser(json.getBytes("UTF-8"));
    while (p.nextToken() != null) {}
    p.close();
  }
Example #24
0
 private void _testSurrogates(JsonFactory f, boolean checkText) throws IOException {
   byte[] json = "{\"text\":\"\uD83D\uDE03\"}".getBytes("UTF-8");
   // first
   JsonParser jp = f.createParser(json);
   assertToken(JsonToken.START_OBJECT, jp.nextToken());
   assertToken(JsonToken.FIELD_NAME, jp.nextToken());
   if (checkText) {
     assertEquals("text", jp.getText());
   }
   assertToken(JsonToken.VALUE_STRING, jp.nextToken());
   if (checkText) {
     assertEquals("\uD83D\uDE03", jp.getText());
   }
   assertToken(JsonToken.END_OBJECT, jp.nextToken());
 }
Example #25
0
  public void parseArray(T[] translatorTypes, JsonParser jsonParser) throws IOException {
    JsonParserWrapper wrapper = new JsonParserWrapper(jsonParser);

    if (jsonParser.getCurrentToken() == null) {
      jsonParser.nextToken();
    }

    if (jsonParser.getCurrentToken() == JsonToken.START_ARRAY) {
      int count = 0;
      while (jsonParser.nextToken() != JsonToken.END_ARRAY) {
        translatorTypes[count] = wrapper.getCurrentValue(getType(), null);
        count++;
      }
    }
  }
Example #26
0
  private Map<String, Long> parseUnreadCountList(Reader in) throws JsonParseException, IOException {
    JsonFactory f = new JsonFactory();
    JsonParser jp = f.createParser(in);

    String currName;

    String uid = null;
    Long timestamp = null;
    int len;
    String text = null;
    Map<String, Long> unreadList = new HashMap<String, Long>();

    jp.nextToken(); // will return JsonToken.START_OBJECT (verify?)
    while (jp.nextToken() != JsonToken.END_OBJECT) {
      currName = jp.getCurrentName();
      jp.nextToken(); // move to value, or START_OBJECT/START_ARRAY
      if (currName.equals("unreadcounts")) { // contains an object
        // start items
        while (jp.nextToken() != JsonToken.END_ARRAY) {
          if (jp.getCurrentToken() == JsonToken.START_OBJECT) {
            // do nothing
          } else if (jp.getCurrentToken() == JsonToken.END_OBJECT) {
            if (!unreadList.containsKey(uid)) unreadList.put(uid, timestamp);
          }

          currName = jp.getCurrentName();
          if (currName == null) continue;

          jp.nextToken();
          if (currName.equals("id")) {
            uid = jp.getText();
          } else if (currName.equals("newestItemTimestampUsec")) {
            text = jp.getText();
            len = text.length();
            if (len > 13) text = jp.getText().substring(0, jp.getText().length() - 6);
            else if (len > 10) text = jp.getText().substring(0, jp.getText().length() - 3);
            timestamp = Utils.asLong(text); // millis -> unixtime
          } else {
            jp.skipChildren();
          }
        }
      } else {
        jp.skipChildren();
      }
    }

    return unreadList;
  }
 @Override
 public JSONObject deserialize(JsonParser jp, DeserializationContext ctxt)
     throws IOException, JsonProcessingException {
   JSONObject ob = new JSONObject();
   JsonToken t = jp.getCurrentToken();
   if (t == JsonToken.START_OBJECT) {
     t = jp.nextToken();
   }
   for (; t == JsonToken.FIELD_NAME; t = jp.nextToken()) {
     String fieldName = jp.getCurrentName();
     t = jp.nextToken();
     try {
       switch (t) {
         case START_ARRAY:
           ob.put(fieldName, JSONArrayDeserializer.instance.deserialize(jp, ctxt));
           continue;
         case START_OBJECT:
           ob.put(fieldName, deserialize(jp, ctxt));
           continue;
         case VALUE_STRING:
           ob.put(fieldName, jp.getText());
           continue;
         case VALUE_NULL:
           ob.put(fieldName, JSONObject.NULL);
           continue;
         case VALUE_TRUE:
           ob.put(fieldName, Boolean.TRUE);
           continue;
         case VALUE_FALSE:
           ob.put(fieldName, Boolean.FALSE);
           continue;
         case VALUE_NUMBER_INT:
           ob.put(fieldName, jp.getNumberValue());
           continue;
         case VALUE_NUMBER_FLOAT:
           ob.put(fieldName, jp.getNumberValue());
           continue;
         case VALUE_EMBEDDED_OBJECT:
           ob.put(fieldName, jp.getEmbeddedObject());
           continue;
       }
     } catch (JSONException e) {
       throw ctxt.mappingException("Failed to construct JSONObject: " + e.getMessage());
     }
     throw ctxt.mappingException("Urecognized or unsupported JsonToken type: " + t);
   }
   return ob;
 }
Example #28
0
 @Override
 public Visibility deserialize(JsonParser p) throws IOException, JsonParseException {
   Visibility value;
   boolean collapsed;
   String tag;
   if (p.getCurrentToken() == JsonToken.VALUE_STRING) {
     collapsed = true;
     tag = getStringValue(p);
     p.nextToken();
   } else {
     collapsed = false;
     expectStartObject(p);
     tag = readTag(p);
   }
   if (tag == null) {
     throw new JsonParseException(p, "Required field missing: " + TAG_FIELD);
   } else if ("public".equals(tag)) {
     value = Visibility.PUBLIC;
   } else if ("team_only".equals(tag)) {
     value = Visibility.TEAM_ONLY;
   } else if ("password".equals(tag)) {
     value = Visibility.PASSWORD;
   } else if ("team_and_password".equals(tag)) {
     value = Visibility.TEAM_AND_PASSWORD;
   } else if ("shared_folder_only".equals(tag)) {
     value = Visibility.SHARED_FOLDER_ONLY;
   } else {
     value = Visibility.OTHER;
     skipFields(p);
   }
   if (!collapsed) {
     expectEndObject(p);
   }
   return value;
 }
    @Override
    public Event deserialize(JsonParser jp, DeserializationContext ctxt)
        throws IOException, JsonProcessingException {
      ObjectMapper mapper = (ObjectMapper) jp.getCodec();
      String eventName = jp.nextTextValue();

      EventKey ek = new EventKey(namespaceClass.get(), eventName);
      if (!eventMapping.containsKey(ek)) {
        ek = new EventKey(Namespace.DEFAULT_NAME, eventName);
        if (!eventMapping.containsKey(ek)) {
          return new Event(eventName, Collections.emptyList());
        }
      }

      List<Object> eventArgs = new ArrayList<Object>();
      Event event = new Event(eventName, eventArgs);
      List<Class<?>> eventClasses = eventMapping.get(ek);
      int i = 0;
      while (true) {
        JsonToken token = jp.nextToken();
        if (token == JsonToken.END_ARRAY) {
          break;
        }
        if (i > eventClasses.size() - 1) {
          log.debug("Event {} has more args than declared in handler: {}", eventName, null);
          break;
        }
        Class<?> eventClass = eventClasses.get(i);
        Object arg = mapper.readValue(jp, eventClass);
        eventArgs.add(arg);
        i++;
      }
      return event;
    }
 public static void nextExpect(JsonParser jp, String name) throws IOException {
   jp.nextToken();
   String fieldName = jp.getCurrentName();
   if (!fieldName.equals(name))
     throw new IOException(
         "Expected "
             + name
             + " element, got: "
             + fieldName
             + " "
             + jp.getCurrentLocation()
             + " tokenType: ["
             + jp.getCurrentToken()
             + "]");
   jp.nextToken();
 }