Java 类com.fasterxml.jackson.core.ObjectCodec 实例源码

@Override
public X509CertificateCredential deserialize(final JsonParser jp, 
                                             final DeserializationContext deserializationContext) 
        throws IOException {
    final ObjectCodec oc = jp.getCodec();
    final JsonNode node = oc.readTree(jp);

    final List<X509Certificate> certs = new ArrayList<>();
    node.findValues("certificates").forEach(n -> {
        final String cert = n.get(0).textValue();
        final byte[] data = EncodingUtils.decodeBase64(cert);
        certs.add(CertUtils.readCertificate(new InputStreamResource(new ByteArrayInputStream(data))));
    });
    final X509CertificateCredential c = new X509CertificateCredential(certs.toArray(new X509Certificate[] {}));
    return c;
}

/**
 * Десериализатор Gson Map в Map<String, String> значение
 * 
 * @param parser
 *            Gson строка
 * @throws IOException
 *             исключение парсера
 * @return карта
 */
public static Map<String, String> gsonMap2Map(JsonParser parser) throws IOException {
    ObjectCodec codec = parser.getCodec();
    TreeNode node = codec.readTree(parser);
    Map<String, String> ret = new HashMap<String, String>();
    if (node.isObject()) {
        for (Iterator<String> iter = node.fieldNames(); iter.hasNext();) {
            String fieldName = iter.next();
            TreeNode field = node.get(fieldName);
            if (field != null) {
                ret.put(fieldName, field.toString());
            } else {
                ret.put(fieldName, "null");
            }
        }
    }
    return ret;
}

@Override
public Object deserialize(JsonParser jsonParser, DeserializationContext deserializationContext)
    throws IOException, JsonProcessingException {
  ObjectCodec oc = jsonParser.getCodec();
  JsonNode node = oc.readTree(jsonParser);
  if (node instanceof ArrayNode) {
    ArrayNode arrayNode = (ArrayNode) node;
    ArrayList<String> ret = new ArrayList<>();
    for (int i = 0; i < arrayNode.size(); i++) {
      ret.add(arrayNode.get(i).textValue());
    }
    return ret;
  } else {
    return Arrays.asList(node.textValue());
  }
}

@Override
public Object deserialize(JsonParser jsonParser, DeserializationContext deserializationContext)
    throws IOException, JsonProcessingException {
  ObjectCodec oc = jsonParser.getCodec();
  JsonNode node = oc.readTree(jsonParser);
  if (node instanceof ArrayNode) {
    ArrayNode arrayNode = (ArrayNode) node;
    ArrayList<String> ret = new ArrayList<>();
    for (int i = 0; i < arrayNode.size(); i++) {
      ret.add(arrayNode.get(i).textValue());
    }
    return ret.toArray(new String[0]);
  } else {
    return new String[]{node.textValue()};
  }

}

@Override
public T deserialize(JsonParser jsonParser,
                     DeserializationContext deserializationContext) throws IOException,
        JsonProcessingException {
    ObjectCodec objectCodec = jsonParser.getCodec();
    JsonNode node = objectCodec.readTree(jsonParser);
    Class<? extends T> typeClass = null;
    if (node.isObject() && node.has("type")) {
        JsonNode type = node.get("type");
        if (type != null && type.isTextual()) {
            typeClass = registry.get(type.textValue());
        }
    }

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

    StringWriter writer = new StringWriter();
    objectMapper.writeValue(writer, node);
    writer.close();
    String json = writer.toString();
    return objectMapper.readValue(json, typeClass);
}

@Override
public final Bijhoudingsautorisatie deserialize(final JsonParser jp, final DeserializationContext ctxt) throws IOException {
    final ObjectCodec oc = jp.getCodec();
    final JsonNode node = oc.readTree(jp);

    final Boolean indicatieModelautorisatie =
            JsonUtils.getAsBoolean(
                    node,
                    BijhoudingsautorisatieModule.INDICATIE_MODEL_AUTORISATIE,
                    BijhoudingsautorisatieModule.WAARDE_JA,
                    Boolean.TRUE,
                    Boolean.FALSE);
    final Bijhoudingsautorisatie bijhoudingsautorisatie = new Bijhoudingsautorisatie(indicatieModelautorisatie);

    bijhoudingsautorisatie.setId(JsonUtils.getAsInteger(node, BijhoudingsautorisatieModule.ID));
    bijhoudingsautorisatie.setNaam(JsonUtils.getAsString(node, BijhoudingsautorisatieModule.NAAM));
    bijhoudingsautorisatie.setDatumIngang(JsonUtils.getAsInteger(node, BijhoudingsautorisatieModule.DATUM_INGANG));
    bijhoudingsautorisatie.setDatumEinde(JsonUtils.getAsInteger(node, BijhoudingsautorisatieModule.DATUM_EINDE));
    bijhoudingsautorisatie.setIndicatieGeblokkeerd(
            JsonUtils.getAsBoolean(node, BijhoudingsautorisatieModule.INDICATIE_GEBLOKKEERD, BijhoudingsautorisatieModule.WAARDE_JA, Boolean.TRUE, null));

    return bijhoudingsautorisatie;
}

@Override
public final DienstbundelLo3RubriekView deserialize(final JsonParser jp, final DeserializationContext ctxt) throws IOException {
    final ObjectCodec oc = jp.getCodec();
    final JsonNode node = oc.readTree(jp);

    final Dienstbundel dienstbundel =
            entityManager.getReference(Dienstbundel.class, JsonUtils.getAsInteger(node, DienstbundelLo3RubriekModule.DIENSTBUNDEL));
    final Lo3Rubriek rubriek = entityManager.getReference(Lo3Rubriek.class, JsonUtils.getAsInteger(node, DienstbundelLo3RubriekModule.RUBRIEK));
    final nl.bzk.algemeenbrp.dal.domein.brp.entity.DienstbundelLo3Rubriek dienstbundelLO3Rubriek;
    if (JsonUtils.getAsInteger(node, DienstbundelLo3RubriekModule.ID) != null) {
        dienstbundelLO3Rubriek =
                entityManager.getReference(
                    nl.bzk.algemeenbrp.dal.domein.brp.entity.DienstbundelLo3Rubriek.class,
                    JsonUtils.getAsInteger(node, DienstbundelLo3RubriekModule.ID));

    } else {
        dienstbundelLO3Rubriek = new nl.bzk.algemeenbrp.dal.domein.brp.entity.DienstbundelLo3Rubriek(dienstbundel, rubriek);
    }
    final Boolean actief = JsonUtils.getAsBoolean(node, DienstbundelLo3RubriekModule.ACTIEF, "Ja", Boolean.TRUE, Boolean.FALSE);
    final DienstbundelLo3RubriekView viewRubriek = new DienstbundelLo3RubriekView(dienstbundelLO3Rubriek, actief);
    dienstbundelLO3Rubriek.setId(JsonUtils.getAsInteger(node, DienstbundelLo3RubriekModule.ID));

    return viewRubriek;

}

@Override
public final SoortActieBrongebruik deserialize(final JsonParser jp, final DeserializationContext ctxt) throws IOException {
    final ObjectCodec oc = jp.getCodec();
    final JsonNode node = oc.readTree(jp);

    final SoortActie soortActie = EnumUtils.getAsEnum(SoortActie.class, JsonUtils.getAsInteger(node, SoortActieBrongebruikModule.SOORT_ACTIE));
    final SoortAdministratieveHandeling soortAdministratieveHandeling =
            EnumUtils.getAsEnum(
                    SoortAdministratieveHandeling.class,
                    JsonUtils.getAsInteger(node, SoortActieBrongebruikModule.SOORT_ADMINISTRATIEVE_HANDELING));
    final SoortDocument soortDocument =
            entityManager.find(SoortDocument.class, JsonUtils.getAsShort(node, SoortActieBrongebruikModule.SOORT_DOCUMENT));

    final SoortActieBrongebruikSleutel soortActieBrongebruikSleutel =
            new SoortActieBrongebruikSleutel(soortActie, soortAdministratieveHandeling, soortDocument);

    final SoortActieBrongebruik soortActieBrongebruik = new SoortActieBrongebruik(soortActieBrongebruikSleutel);

    soortActieBrongebruik.setId(JsonUtils.getAsShort(node, SoortActieBrongebruikModule.ID));
    soortActieBrongebruik.setDatumAanvangGeldigheid(JsonUtils.getAsInteger(node, SoortActieBrongebruikModule.DATUM_AANVANG_GELDIGHEID));
    soortActieBrongebruik.setDatumEindeGeldigheid(JsonUtils.getAsInteger(node, SoortActieBrongebruikModule.DATUM_EINDE_GELDIGHEID));

    return soortActieBrongebruik;
}

@Override
public Room deserialize(JsonParser jp, DeserializationContext context) throws IOException,
        JsonProcessingException {

    ObjectCodec oc = jp.getCodec();
    JsonNode node = oc.readTree(jp);

    String roomId = node.get("id").asText();
    String name = node.get("name").asText();
    String topic = node.get("topic").get("value").asText();

    DateTime creationDate = new DateTime(node.get("created").asLong() * 1000L);
    String ownerUserId = node.get("creator").asText();
    boolean archived = node.get("is_archived").asBoolean();
    boolean privateRoom = roomId.startsWith("G");
    return new Room(roomId, name, topic, null, creationDate, ownerUserId, archived,
                    privateRoom, null, null);
}

@Override
public User deserialize(JsonParser jp, DeserializationContext context)
        throws IOException, JsonProcessingException {

    ObjectCodec oc = jp.getCodec();
    JsonNode node = oc.readTree(jp);

    String userId = node.get("id").asText();
    String mentionName = node.get("name").asText();
    boolean deleted = node.get("deleted").asBoolean();
    boolean groupAdmin = getAsBooleanOrFalse(node.get("is_admin"));
    String statusMessage = getAsTextOrNull(node.get("status"));
    String timezone = getAsTextOrNull(node.get("tz"));

    JsonNode profileNode = node.get("profile");
    String name = profileNode.get("real_name").asText();
    String title = getAsTextOrNull(profileNode.get("title"));
    String email = getAsTextOrNull(profileNode.get("email"));
    String photoUrl = profileNode.get("image_32").asText();

    return new User(userId, email, deleted, groupAdmin, false, name, mentionName, photoUrl,
                    null, null, null, statusMessage, timezone, title);
}

@Override
public Room deserialize(JsonParser jp, DeserializationContext context) throws IOException,
        JsonProcessingException {

    ObjectCodec oc = jp.getCodec();
    JsonNode node = oc.readTree(jp);

    int roomId = node.get("room_id").asInt();
    String name = node.get("name").asText();
    String topic = node.get("topic").asText();

    DateTime lastActiveDate = new DateTime(node.get("last_active").asLong() * 1000L);
    DateTime creationDate = new DateTime(node.get("created").asLong() * 1000L);
    int ownerUserId = node.get("owner_user_id").asInt();
    boolean archived = node.get("is_archived").asBoolean();
    boolean privateRoom = node.get("is_private").asBoolean();
    String guestAccessURL = getAsTextOrNull(node.get("guest_access_url"));
    String xmppJid = node.get("xmpp_jid").asText();
    return new Room(String.valueOf(roomId), name, topic, lastActiveDate, creationDate,
                    String.valueOf(ownerUserId), archived, privateRoom, guestAccessURL,
                    xmppJid);
}

@Override
public User deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException,
        JsonProcessingException {

    ObjectCodec oc = jp.getCodec();
    JsonNode node = oc.readTree(jp);
    int userId = node.get("user_id").asInt();
    String email = node.get("email").asText();
    boolean deleted = node.get("is_deleted").asBoolean();
    boolean groupAdmin = node.get("is_group_admin").asBoolean();
    String name = node.get("name").asText();
    String mentionName = node.get("mention_name").asText();
    String photoUrl = node.get("photo_url").asText();
    DateTime lastActiveDate = new DateTime(node.get("last_active").asLong() * 1000L);
    DateTime creationDate = new DateTime(node.get("created").asLong() * 1000L);
    String status = node.get("status").asText();
    String statusMessage = node.get("status_message").asText();
    String timezone = node.get("timezone").asText();
    String title = node.get("title").asText();

    return new User(String.valueOf(userId), email, deleted, groupAdmin, false, name,
                    mentionName, photoUrl, lastActiveDate, creationDate, status, statusMessage,
                    timezone, title);
}

@Override
public ChatAlyticsEvent deserialize(JsonParser jp, DeserializationContext ctxt)
        throws IOException, JsonProcessingException {

    ObjectCodec oc = jp.getCodec();
    JsonNode node = oc.readTree(jp);

    JsonParser eventTimeParser = node.get("event_time").traverse();
    DateTime eventTime = oc.readValue(eventTimeParser, DateTime.class);

    String type = node.get("type").asText();

    Class<?> clazz;
    String classStr = node.get("clazz").asText();
    try {
        clazz = Class.forName(classStr);
    } catch (ClassNotFoundException e) {
        throw new IOException("Can't load class for " + classStr, e);
    }

    JsonParser eventParser = node.get("event").traverse();
    Object event = oc.readValue(eventParser, clazz);

    return new ChatAlyticsEvent(eventTime, type, event);
}

@Override
public List<String> deserialize(JsonParser p, DeserializationContext ctxt)
        throws IOException, JsonProcessingException {       
    List<String> result;

     ObjectCodec codec = p.getCodec();


    if (p.getCurrentToken().equals(JsonToken.START_ARRAY)) {
        result = codec.readValue(p, new TypeReference<List<String>>() { });
    } else {
        LinkedHashMap<Integer, String> map = codec.readValue(p,
                new TypeReference<LinkedHashMap<Integer, String>>() { });

        result = new ArrayList<String>(map.values());
    }
    return result;
}

@Override
public LinkedHashMap<String, String> deserialize(JsonParser jp,
        DeserializationContext ctxt) throws IOException,
        JsonProcessingException {

    LinkedHashMap<String, String> result = null;

    // Is the alias broken, i.e., it starts with '['
    if (jp.getCurrentToken().equals(JsonToken.START_ARRAY)) {
        result = new LinkedHashMap<String, String>();
        jp.nextToken();
        if (!jp.getCurrentToken().equals(JsonToken.END_ARRAY)) {
            logger.warn("Token " + JsonToken.END_ARRAY + " expected");
        }           
    } else {
        ObjectCodec mapper = jp.getCodec();
        result = mapper.readValue(jp,
                new TypeReference<LinkedHashMap<String, String>>() { });
    }

    return result;
}

@Override
public LinkedHashMap<String, OldJacksonSiteLink> deserialize(JsonParser jp,
        DeserializationContext ctxt) throws IOException,
        JsonProcessingException {

    LinkedHashMap<String, OldJacksonSiteLink> result = null;

    // Is the alias broken, i.e., it starts with '['
    if (jp.getCurrentToken().equals(JsonToken.START_ARRAY)) {
        result = new LinkedHashMap<String, OldJacksonSiteLink>();
        jp.nextToken();
        if (!jp.getCurrentToken().equals(JsonToken.END_ARRAY)) {
            logger.warn("Token " + JsonToken.END_ARRAY + " expected");
        }           
    } else {
        ObjectCodec mapper = jp.getCodec();
        result = mapper.readValue(jp,
                new TypeReference<LinkedHashMap<String, OldJacksonSiteLink>>() { });
    }

    return result;
}

@Override
public LinkedHashMap<String, List<String>> deserialize(
        JsonParser jp, DeserializationContext ctxt) throws IOException,
        JsonProcessingException {

    LinkedHashMap<String, List<String>> result =
            new LinkedHashMap<String, List<String>>();

    // Is the alias broken, i.e., it starts with '['
    if (jp.getCurrentToken().equals(JsonToken.START_ARRAY)) {
        jp.nextToken();
        if (!jp.getCurrentToken().equals(JsonToken.END_ARRAY)) {
            logger.warn("Token " + JsonToken.END_ARRAY + " expected");
        }           
    } else {
            ObjectCodec mapper = jp.getCodec();
            result = mapper.readValue(jp,
                    new TypeReference<LinkedHashMap<String, OldAliasList>>() { });
    }

    return result;
}

@Override
public Link deserialize(JsonParser jsonParser, DeserializationContext ctx) throws IOException, JsonProcessingException {

  final ObjectCodec oc = jsonParser.getCodec();
  final JsonNode node = oc.readTree(jsonParser);

  final JsonNode href = node.get("href");
  if (href == null) {
    return null;
  }

  final Builder linkBuilder = Link.fromUri(href.asText());
  final JsonNode rel = node.get("rel");
  if (rel != null) {
    linkBuilder.rel(rel.asText());
  }
  return linkBuilder.build();
}

@Override
public ExposedPorts deserialize(JsonParser jsonParser, DeserializationContext deserializationContext)
        throws IOException {

    List<ExposedPort> exposedPorts = new ArrayList<>();
    ObjectCodec oc = jsonParser.getCodec();
    JsonNode node = oc.readTree(jsonParser);
    for (Iterator<Map.Entry<String, JsonNode>> it = node.fields(); it.hasNext(); ) {

        Map.Entry<String, JsonNode> field = it.next();
        if (!field.getValue().equals(NullNode.getInstance())) {
            exposedPorts.add(ExposedPort.parse(field.getKey()));
        }
    }
    return new ExposedPorts(exposedPorts.toArray(new ExposedPort[0]));
}

@Override
public Ports deserialize(JsonParser jsonParser, DeserializationContext deserializationContext)
        throws IOException {

    Ports out = new Ports();
    ObjectCodec oc = jsonParser.getCodec();
    JsonNode node = oc.readTree(jsonParser);
    for (Iterator<Map.Entry<String, JsonNode>> it = node.fields(); it.hasNext(); ) {

        Map.Entry<String, JsonNode> portNode = it.next();
        JsonNode bindingsArray = portNode.getValue();
        if (bindingsArray.equals(NullNode.getInstance())) {
            out.bind(ExposedPort.parse(portNode.getKey()), null);
        } else {
            for (int i = 0; i < bindingsArray.size(); i++) {
                JsonNode bindingNode = bindingsArray.get(i);
                if (!bindingNode.equals(NullNode.getInstance())) {
                    String hostIp = bindingNode.get("HostIp").textValue();
                    String hostPort = bindingNode.get("HostPort").textValue();
                    out.bind(ExposedPort.parse(portNode.getKey()), new Binding(hostIp, hostPort));
                }
            }
        }
    }
    return out;
}

@Override
public AbstractRestException deserialize(JsonParser jsonParser, DeserializationContext ctxt) throws IOException, JsonProcessingException {
    ObjectCodec oc = jsonParser.getCodec();
    JsonNode node = oc.readTree(jsonParser);
    ObjectMapper mapper = (ObjectMapper) jsonParser.getCodec();
    if (node.get("type") != null) {
        String type = node.get("type")
                .textValue();
        Errors et = Errors.valueByName(type);
        if (et == null) {
            log.error("Could not find matching error type for type id {" + type + "}");
            throw new MeshJsonException("Invalid error type {" + type + "}");
        }
        return (AbstractRestException) mapper.convertValue(node, et.getClazz());
    }
    return null;
}

@Override
public T deserialize(JsonParser jsonParser, DeserializationContext ctxt) throws IOException, JsonProcessingException {
    ObjectCodec oc = jsonParser.getCodec();
    JsonNode node = oc.readTree(jsonParser);
    ObjectMapper mapper = (ObjectMapper) jsonParser.getCodec();
    if (node.get("type") != null) {
        String type = node.get("type")
                .textValue();
        FieldTypes ft = FieldTypes.valueByName(type);
        return (T) mapper.convertValue(node, ft.getSchemaImplementationClazz());
    } else {
        JsonNode nameField = node.get("name");
        String fieldName = "unknown";
        if (nameField != null) {
            fieldName = nameField.textValue();
        }
        log.error("Schema type not found for field with name {" + fieldName + "}");
        throw new JsonMappingException("Missing type property for field {" + fieldName + "}", jsonParser.getCurrentLocation());
    }
}

/**
 * Deserialize the node field list item.
 * 
 * @param jsonNode
 *            Node which represents the node field list item.
 * @param jsonParser
 * @return Deserialized field list item.
 * @throws JsonProcessingException
 */
public NodeFieldListItem deserialize(JsonNode jsonNode, JsonParser jsonParser) throws JsonProcessingException {
    ObjectCodec oc = jsonParser.getCodec();

    NodeResponse nodeItem = null;
    try {
        // Try to deserialize the node response in the expanded form.
        nodeItem = JsonUtil.readValue(jsonNode.toString(), NodeResponse.class);
    } catch (GenericRestException e) {
        // Fallback and deseralize the element using the collapsed form.
        NodeFieldListItemImpl collapsedItem = oc.treeToValue(jsonNode, NodeFieldListItemImpl.class);
        nodeItem = new NodeResponse();
        nodeItem.setUuid(collapsedItem.getUuid());
    }
    return nodeItem;
}

@Override
public ResultSet deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException {

    ObjectCodec objectCodec = jp.getCodec();
    JsonNode node = objectCodec.readTree(jp);
    long resultSize = node.get("resultSize").asLong();
    long startOffset = node.get("startOffset").asLong();
    List results = new ArrayList<>();
    if (node.get("results").isArray() && node.get("results").size() > 0) {
        JsonNode first = node.get("results").get(0);
        boolean resourceNode = first.get("children") != null;
        boolean resourceWithType = first.get("type") != null;
        Iterator<JsonNode> elements = node.get("results").elements();
        while (elements.hasNext()) {
            JsonNode element = elements.next();
            if (resourceNode) {
                results.add(objectCodec.treeToValue(element, ResourceNode.class));
            } else if (resourceWithType) {
                results.add(objectCodec.treeToValue(element, Resource.class));
            } else {
                results.add(objectCodec.treeToValue(element, ResourceType.class));
            }
        }
    }
    return new ResultSet(results, resultSize, startOffset);
}

@Override
public TalkListResponse deserialize(JsonParser jsonParser, DeserializationContext ctxt) throws IOException, JsonProcessingException {

    ObjectCodec oc = jsonParser.getCodec();
    JsonNode node = oc.readTree(jsonParser);
    TalkListResponse responseData = new TalkListResponse();
    if (node.has("results")) {
        String nodeAsString = node.get("results").toString();
        ArrayList<Talk> talks = new ObjectMapper().readValue(nodeAsString , new TypeReference<ArrayList<Talk>>() {
        });
        responseData.setTalkList(talks);
    } else {
        responseData.setResponseError(new WrappedError(new Exception("Error while deserializing response result")));
    }
    return responseData;
}

@Override
public Quote deserialize(JsonParser p, DeserializationContext ctxt) throws IOException, JsonProcessingException {
    ObjectCodec oc = p.getCodec();
    JsonNode node = ((ObjectMapper) oc).readTree(p);

    Quote quote = new Quote(
            FORMAT.parseDateTime(node.get(0).asText()),
            node.get(1).asDouble(),
            node.get(2).asDouble(),
            node.get(3).asDouble(),
            node.get(4).asDouble(),
            node.get(5).asLong()
    );

    // If we're deserializing from the API this field won't exist
    if (node.size() >= 7) {
        quote.setPreviousClose(node.get(6).asDouble());
    }

    return quote;
}

@Override
public TeamTagMap deserialize(JsonParser jsonParser, DeserializationContext deserializationContext)
        throws IOException {
    final Map<TagId,Integer> tagToTeam = new HashMap<>();
    ObjectCodec oc = jsonParser.getCodec();
    JsonNode node = oc.readTree(jsonParser);
    node.fields().forEachRemaining((entry) -> {
        int team = Integer.parseInt(entry.getKey(), 10);
        entry.getValue().elements().forEachRemaining((tagNode) -> {
            String tagStr = tagNode.asText();
            try {
                tagToTeam.put(new TagId(tagStr), team);
            } catch (IllegalArgumentException e) {
                // TODO: Handle this exception!!!!
                LOG.error("Error decoding tag id: {}", tagStr, e);
            }
        });
    });
    return new TeamTagMap(ImmutableMap.<TagId,Integer>builder()
        .putAll(tagToTeam).build());
}

@Override
public TeamState deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException {
    ObjectCodec oc = jp.getCodec();
    JsonNode node = oc.readTree(jp);
    Iterator<Map.Entry<String, JsonNode>> it = node.fields();
    Optional<TagSeenEvent> lastTagSeenEvent = Optional.empty();
    int tagFragmentCount = 0;
    double speed = Double.NaN;
    double predictedSpeed = Double.NaN;
    while (it.hasNext()) {
        Map.Entry<String, JsonNode> entry = it.next();
        if (entry.getKey().equals("lastTagSeenEvent")) {
            TagSeenEvent event = oc.treeAsTokens(entry.getValue()).readValueAs(TagSeenEvent.class);
            lastTagSeenEvent = Optional.of(event);
        } else if (entry.getKey().equals("tagFragmentCount")) {
            tagFragmentCount = oc.treeAsTokens(entry.getValue()).getIntValue();
        } else if (entry.getKey().equals("speed")) {
            speed = oc.treeAsTokens(entry.getValue()).getDoubleValue();
        } else if (entry.getKey().equals("predictedSpeed")) {
            predictedSpeed = oc.treeAsTokens(entry.getValue()).getDoubleValue();
        }
    }
    return new TeamState(lastTagSeenEvent, tagFragmentCount, speed, predictedSpeed);
}

@Override
public Map<String, Action> deserialize(JsonParser parser, DeserializationContext context) throws IOException {
    ObjectCodec codec = parser.getCodec();
    Map<String, Action> map = new HashMap<>();
    final JsonNode node = codec.readTree(parser);
    if (node.has(DOWNLOAD_KEY)) {
        map.put(DOWNLOAD_KEY, deserializeAction(node, DOWNLOAD_KEY, codec, DownloadAction.class));
    }
    if (node.has(UPLOAD_KEY)) {
        map.put(UPLOAD_KEY, deserializeAction(node, UPLOAD_KEY, codec, UploadAction.class)); 
    }
    if (node.has(RUN_KEY)) {
        map.put(RUN_KEY, deserializeAction(node, RUN_KEY, codec, RunAction.class));
    }
    return (map.size() == 0) ? null : map;
}

@Override
public Map<String, Route[]> deserialize(JsonParser parser, DeserializationContext context) throws IOException, JsonProcessingException {
    ObjectCodec codec = parser.getCodec();
    Map<String, Route[]> map = new HashMap<>();
    final JsonNode node = codec.readTree(parser);

    if (node.has("cf-router")) {
        deserializeRouteArray("cf-router", codec, map, node, HttpRoute.class);
    }

    if (node.has("tcp-router")) {
        deserializeRouteArray("tcp-router", codec, map, node, TcpRoute.class);
    }

    return (map.size() == 0) ? null : map;
}

public TreeTraversingParser(JsonNode paramJsonNode, ObjectCodec paramObjectCodec)
{
  super(0);
  this._objectCodec = paramObjectCodec;
  if (paramJsonNode.isArray())
  {
    this._nextToken = JsonToken.START_ARRAY;
    this._nodeCursor = new NodeCursor.Array(paramJsonNode, null);
    return;
  }
  if (paramJsonNode.isObject())
  {
    this._nextToken = JsonToken.START_OBJECT;
    this._nodeCursor = new NodeCursor.Object(paramJsonNode, null);
    return;
  }
  this._nodeCursor = new NodeCursor.RootValue(paramJsonNode, null);
}

@Override
public Event deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException {
    ObjectCodec codec = jp.getCodec();
    TreeNode treeNode = codec.readTree(jp);


    UUID id = UUID.fromString(((TextNode) treeNode.get("id")).asText());
    String typeStr = ((TextNode) treeNode.get("type")).asText();
    Type type = Type.byName(typeStr);

    TreeNode responseNode = treeNode.get("response");
    StemResponse result = mapper.treeToValue(responseNode, type.clazz);

    Event event = Event.create(type, id);
    event.setResponse(result);
    return event;
}

@Override
public CollectionURI deserialize(JsonParser jsonParser, DeserializationContext deserializationContext) throws IOException, JsonProcessingException {
    ObjectCodec oc = jsonParser.getCodec();
    JsonNode node = oc.readTree(jsonParser);
    CollectionURI collectionURI = new CollectionURI();
    if (node.has("service")) {
        String service = node.get("service").textValue();
        int id = node.get("id").intValue();
        collectionURI.setService(service);
        collectionURI.setId(id);
    } else {
        collectionURI.setCollectionURI(node.textValue());
    }

    return collectionURI;
}

@Override
public GeoLocation deserialize(JsonParser jp,
        DeserializationContext ctxt) throws
              IOException {
    ObjectCodec oc = jp.getCodec();
    JsonNode node = oc.readTree(jp);

    LatLng geo = new LatLng(node.get("latitude").asDouble(), node.get(
            "longitude").asDouble());
    DateTime timestamp = null;
    if (node.get("timestamp") != null) {
        timestamp = new DateTime(node.get("timestamp").asText());
    } else if (node.get("time") != null && node.get("timezone") != null) {
        timestamp = new DateTime(node.get("time").asLong(),
                DateTimeZone.forID(node.get("timezone").asText()));
    }
    double accuracy = node.get("accuracy").asDouble();
    String provider = node.get("provider").asText();
    return (new GeoLocation(timestamp, geo, accuracy, provider));
}

@Override
public ResendBuildAction deserialize(final JsonParser jsonParser, final DeserializationContext deserializationContext) throws IOException {

    final ObjectCodec oc = jsonParser.getCodec();
    final JsonNode node = oc.readTree(jsonParser);

    FilePath mimePath = null;
    if(node.get("mimePath") != null){
        final String serializedMimePath = node.get("mimePath").asText();
        mimePath = new FilePath(new File(serializedMimePath));
    }

    final String notificationAction = node.get("notificationAction").asText();
    final String moduleName = node.get("moduleName").asText();
    final String moduleVersion = node.get("moduleVersion").asText();

    if(mimePath == null){
        return new ResendBuildAction(GrapesNotification.NotificationType.valueOf(notificationAction),mimePath , moduleName, moduleVersion);
    }

    return new ResendBuildAction(GrapesNotification.NotificationType.valueOf(notificationAction),mimePath, moduleName, moduleVersion);

}

@Override
public Doc deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException, JsonProcessingException {
    ObjectCodec oc = jp.getCodec();
    JsonNode jsonNode = oc.readTree(jp);
    Doc doc = new Doc();

    for (JsonNode jsonDoc : jsonNode) {

        if(jsonDoc.isTextual()){
            doc.type=jsonDoc.textValue();

        }else if(jsonDoc.isObject()){
            Iterator<Entry<String, JsonNode>> fields = jsonDoc.fields();
            while(fields.hasNext()){
                Entry<String, JsonNode> next = fields.next();
                if(next.getKey().equals("de")){
                    doc.de=next.getValue().textValue();
                }else if(next.getKey().equals("en")){
                    doc.en=next.getValue().textValue(); 
                }
            }
        }        
    }

    return doc;
}

@Override
public CustomIndicatorListResponseData deserialize(JsonParser p, DeserializationContext ctxt)
        throws IOException, JsonProcessingException {
    CustomIndicatorListResponseData result = new CustomIndicatorListResponseData();
    ObjectCodec oc = p.getCodec();
    ObjectNode rootNode = oc.readTree(p);
    Iterator<String> keys = rootNode.fieldNames();
    while (keys.hasNext()) {
        String key = (String) keys.next();
        //System.out.println("json node key="+key);
        //ignore "resultCount"
        if("resultCount".compareTo(key) != 0)
        {
            JsonNode value = rootNode.get(key);
            List<CustomIndicator> indicators =  mapper.reader(collectionType).readValue(value);
            for(CustomIndicator indicator : indicators) {
                //indicator.setType(key);
                indicator.setIndicatorType(key);
            }
            result.setCustomIndicator(indicators);
        }

    }
    return result;

}

@Override
public CustomIndicator deserialize(JsonParser p, DeserializationContext ctxt)
        throws IOException, JsonProcessingException {
    List<String> indicatorFields = getDeclaredFields();
    ObjectCodec oc = p.getCodec();
       ObjectNode node = oc.readTree(p);
       CustomIndicator obj = new CustomIndicator(oc.treeToValue(node, Indicator.class));
       Map<String, String> map = new HashMap<String, String>(); 
       //indicator specific fields
       Iterator<String> keys = node.fieldNames();
       while( keys.hasNext() ) {
           String key = (String)keys.next();
           String value = node.get(key).textValue();
           if(!indicatorFields.contains(key)) {
            map.put(key,  value);
           }
       }
       obj.setMap(map);
       return obj;

}

@Override
public GenericIndicatorResponseData deserialize(JsonParser p, DeserializationContext ctxt)
        throws IOException, JsonProcessingException {
    GenericIndicatorResponseData result = new GenericIndicatorResponseData();
    ObjectCodec oc = p.getCodec();
    ObjectNode rootNode = oc.readTree(p);
    Iterator<String> keys = rootNode.fieldNames();
    if (keys.hasNext()) {
        String key = (String) keys.next();
        //result.setType(key);
        JsonNode value = rootNode.get(key);
        CustomIndicator obj = oc.treeToValue(value, CustomIndicator.class);
        //obj.setType(key);
        obj.setIndicatorType(key);
        //result.setCustomIndicator(obj);
    }
    return result;

}

@Override
public CustomIndicatorResponseData deserialize(JsonParser p, DeserializationContext ctxt)
        throws IOException, JsonProcessingException {
    CustomIndicatorResponseData result = new CustomIndicatorResponseData();
    ObjectCodec oc = p.getCodec();
    ObjectNode rootNode = oc.readTree(p);
    Iterator<String> keys = rootNode.fieldNames();
    if (keys.hasNext()) {
        String key = (String) keys.next();
        result.setType(key);
        JsonNode value = rootNode.get(key);
        CustomIndicator obj = oc.treeToValue(value, CustomIndicator.class);
        //obj.setType(key);
        obj.setIndicatorType(key);
        result.setCustomIndicator(obj);
    }
    return result;

}