Java Examples for com.fasterxml.jackson.core.JsonProcessingException

@Override
public Response toResponse(SessionHandlingException e) {
    String json = null;
    ObjectMapper mapper = new ObjectMapper();
    try {
        json = mapper.writeValueAsString(new ErrorJson(e.getError()));
    } catch (JsonProcessingException e1) {
        e1.printStackTrace();
    }
    return Response.status(Response.Status.BAD_REQUEST).type(MediaType.APPLICATION_JSON).entity(json).build();
}

public void testSourceModel() throws JsonProcessingException, JSONException {
    SourceModel model = SourceBlueprint.create();
    FilterProvider filterProvider = new SimpleFilterProvider().addFilter("sourceModelFilter", SimpleBeanPropertyFilter.filterOutAllExcept("source", "source_id", "source_url", "service", "import_id", "import_url"));
    String result = JsonUtil.getMapper().writer(filterProvider).writeValueAsString(model);
    String expected = TestUtil.readResourceAsString("model/SourceModel.json");
    assertTrue(JsonTestUtil.compare(expected, result));
}

public String generateAction(int deviceId, String button) {
    try {
        return OBJECT_MAPPER.writeValueAsString(//
        ImmutableMap.<String, Object>builder().put("type", "IRCommand").put("deviceId", Integer.valueOf(deviceId).toString()).put("command", button).build()).replaceAll(":", "::");
    } catch (JsonProcessingException e) {
        throw new RuntimeException(e);
    }
}

@Test
public void shouldCreateDeepCloneOfTheInvoice() throws JsonProcessingException {
    //given:
    InputStream xml = getClass().getResourceAsStream("/ZUGFeRD_Invoice_with_discounts_and_charges.xml");
    InvoiceTransformer transformer = new InvoiceTransformer();
    Invoice invoice = transformer.toModel(xml);
    //when:
    Invoice clone = Invoices.clone(invoice);
    //then:
    assertThat(transformer.fromModel(invoice)).isEqualTo(transformer.fromModel(clone));
}

@Override
public Boolean deserialize(final JsonParser jsonParser, final DeserializationContext deserializationContext) throws IOException, JsonProcessingException {
    final String val = jsonParser.getValueAsString();
    if (val.equals("0")) {
        return false;
    }
    if (val.equals("1")) {
        return true;
    }
    if (val.toLowerCase().equals("false")) {
        return false;
    }
    if (val.toLowerCase().equals("true")) {
        return true;
    }
    return false;
}

public TargetClassifier build(Path basePath, ObjectMapper yaml, JsonNode parameters) throws JsonProcessingException {
    TitleRegexClassifierConfig params = yaml.treeToValue(parameters, TitleRegexClassifierConfig.class);
    if (params.regular_expression != null && !params.regular_expression.trim().isEmpty()) {
        return new TitleRegexTargetClassifier(params.regular_expression.trim());
    } else {
        return null;
    }
}

@Override
protected AbstractPolicy deserializeAfterRead(JsonParser jp, DeserializationContext ctxt, ObjectMapper mapper, ObjectNode root) throws JsonProcessingException {
    AbstractPolicy result = super.deserializeAfterRead(jp, ctxt, mapper, root);
    if (result != null)
        return result;
    // treat anything else as generic policy
    // all data is stored in the field data so extract that
    Map data = mapper.treeToValue(root, Map.class);
    if (data.containsKey("data"))
        data = (Map) data.get("data");
    return new GenericPolicy(data);
}

@Override
public ECKey deserialize(JsonParser p, DeserializationContext ctxt) throws IOException, JsonProcessingException {
    JsonToken token = p.getCurrentToken();
    switch(token) {
        case VALUE_STRING:
            try {
                return DumpedPrivateKey.fromBase58(null, p.getValueAsString()).getKey();
            } catch (AddressFormatException e) {
                throw new InvalidFormatException(p, "Invalid Key", p.getValueAsString(), ECKey.class);
            }
        default:
            return (ECKey) ctxt.handleUnexpectedToken(ECKey.class, p);
    }
}

@Override
public Date deserialize(final JsonParser jp, final DeserializationContext ctxt) throws IOException, JsonProcessingException {
    String dateString = jp.getText();
    try {
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss");
        return format.parse(dateString);
    } catch (ParseException e) {
        throw new IllegalStateException("parse exception occured when trying to deserialize date, date string was: ", e);
    }
}

@Override
public DateTime deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException, JsonProcessingException {
    JsonToken t = jp.getCurrentToken();
    if (t == JsonToken.VALUE_STRING) {
        String str = jp.getText().trim();
        return ISODateTimeFormat.dateTimeParser().parseDateTime(str);
    }
    if (t == JsonToken.VALUE_NUMBER_INT) {
        return new DateTime(jp.getLongValue());
    }
    throw ctxt.mappingException(handledType());
}

public String toJson() {
    CeeqlMessageDTO m = new CeeqlMessageDTO();
    m.setMessageType("error");
    if (!errorType.equals("")) {
        m.setMessageSubType(errorType);
    }
    m.setTimestamp(timestamp);
    m.setMessage(message);
    ArrayList<CeeqlMessageDTO> l = new ArrayList<>();
    l.add(m);
    ObjectMapper mapper = new ObjectMapper();
    try {
        return mapper.writeValueAsString(l);
    } catch (JsonProcessingException e) {
        return "[{\"message\":\"no results\"}]";
    }
}

private static Player createPlayer(String username, String pbfId) throws JsonProcessingException {
    //The Player object should be cached and retrieved from cache
    Player player = new Player();
    player.setUsername(username);
    player.setPassword(DigestUtils.sha1Hex("foo"));
    player.getGameIds().add(pbfId);
    WriteResult<Player, String> writeResult = getApp().playerCollection.insert(player);
    System.out.println("Saved player " + writeResult.toString());
    assertNotNull(writeResult.getSavedId());
    return player;
}

public <O> String render(OutPutType outPutType, O object, String... headers) throws JsonProcessingException {
    outPutType = outPutType == null ? OutPutType.RAW : outPutType;
    if (OutPutType.JSON.equals(outPutType)) {
        return jsonRenderer.render(object);
    } else if (OutPutType.RAW.equals(outPutType)) {
        if (object instanceof Map) {
            Map<?, ?> map = (Map<?, ?>) object;
            if (!map.values().isEmpty()) {
                Object value = map.values().stream().filter( e -> e != null).findAny().orElse(null);
                if (value instanceof Collection) {
                    return tableRenderer.renderMultiValueMap((Map<String, List<String>>) object, true, headers);
                } else if (value instanceof String) {
                    return tableRenderer.renderSingleMapWithSortedColumn((Map<Object, String>) object, headers);
                } else {
                    return tableRenderer.renderObjectValueMap((Map<String, Object>) object, headers[0]);
                }
            } else {
                return "No available entity";
            }
        } else {
            return "No available entity";
        }
    } else {
        throw new NotSupportedException("Output type not supported.");
    }
}

@Override
public void serialize(final Map<String, Object> map, final JsonGenerator jgen, final SerializerProvider provider) throws IOException, JsonProcessingException {
    // Start
    jgen.writeStartObject();
    // Write properties
    for (final Entry<String, Object> entry : map.entrySet()) {
        final String key = entry.getKey();
        final Object value = entry.getValue();
        if (key != null && value != null) {
            if (value.getClass().isArray()) {
                int length = Array.getLength(value);
                jgen.writeArrayFieldStart(key);
                for (int i = 0; i < length; i++) jgen.writeObject(Array.get(value, i));
                jgen.writeEndArray();
            } else if (value instanceof Collection) {
                jgen.writeArrayFieldStart(key);
                for (final Object v : (Collection<?>) value) jgen.writeObject(v);
                jgen.writeEndArray();
            } else {
                jgen.writeFieldName(key);
                jgen.writeObject(value);
            }
        }
    }
    // End
    jgen.writeEndObject();
}

@Test
public void testXML() throws JsonProcessingException {
    TextualReference ctx = new TextualReference("a b c d e f", "FOOBAR!", "v w x y z", "doc1", "pattern", "ref");
    assertEquals(SerializationUtils.toXML(ctx).replaceAll("\\s", ""), ctx.toXML().replaceAll("\\s", ""));
    String x = SerializationUtils.jacksonMapper.writeValueAsString(ctx);
    log.debug(x);
    log.debug(SerializationUtils.toJSON(ctx));
}

public void testDeserialization() throws Exception {
    // Actually, let's support both old style and new style
    // old:
    HostAndPort result = MAPPER.readValue(aposToQuotes("{'hostText':'localhost','port':9090}"), HostAndPort.class);
    assertEquals("localhost", result.getHostText());
    assertEquals(9090, result.getPort());
    // and new:
    result = MAPPER.readValue(quote("localhost:7070"), HostAndPort.class);
    assertEquals("localhost", result.getHostText());
    assertEquals(7070, result.getPort());
    // and ... error (note: numbers, booleans may all be fine)
    try {
        result = MAPPER.readValue("[ ]", HostAndPort.class);
        fail("Should not deserialize from boolean: got " + result);
    } catch (JsonProcessingException e) {
        verifyException(e, "Can not deserialize");
    }
}

@Override
public void serialize(ZonedDateTime value, JsonGenerator gen, SerializerProvider serializers) throws IOException, JsonProcessingException {
    /*
         * Serialization of timezone data is unwanted (not ISO). Offset is kept, timezone info is thrown away here.
         *
         * Keeping timezone info is a new feature which needs to be implemented.
         */
    gen.writeFieldName(DateTimeFormatter.ISO_OFFSET_DATE_TIME.format(value));
}

@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 void serialize(ReleaseFile value, JsonGenerator jgen, SerializerProvider provider) throws IOException, JsonProcessingException {
    jgen.writeStartObject();
    jgen.writeObjectField("releaseFileId", value.getReleaseFileId());
    jgen.writeObjectField("label", value.getLabel());
    jgen.writeObjectField("createdAt", value.getCreatedAt());
    jgen.writeObjectField("clientDownloadUrl", calculateClientDownloadUrl(value));
    if (isToSeeRawDownloadUrl()) {
        jgen.writeObjectField("downloadUrl", value.getDownloadUrl());
    }
    jgen.writeEndObject();
}

@Override
public DateTime deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException, JsonProcessingException {
    JsonToken t = jp.getCurrentToken();
    if (t == JsonToken.VALUE_STRING) {
        String str = jp.getText().trim();
        return ISODateTimeFormat.dateTimeParser().parseDateTime(str);
    }
    if (t == JsonToken.VALUE_NUMBER_INT) {
        return new DateTime(jp.getLongValue());
    }
    throw ctxt.mappingException(handledType());
}

@Override
public Object deserializeKey(String key, DeserializationContext ctxt) throws IOException, JsonProcessingException {
    if (key.startsWith(KeyAsJsonSerializer.URIPrefix)) {
        key = key.substring(KeyAsJsonSerializer.URIPrefix.length());
        try {
            return new URI(key);
        } catch (URISyntaxException e) {
            e.printStackTrace();
            return null;
        }
    }
    return mapper.readValue(key, Object.class);
}

@Override
public String toString() {
    ObjectWriter ow = new ObjectMapper().writer().withDefaultPrettyPrinter();
    String json = null;
    try {
        json = ow.writeValueAsString(this);
    } catch (JsonProcessingException e) {
        System.err.println(String.format("Error while transforming user %s to JSON String.", email));
        e.printStackTrace();
    }
    return json;
}

@Override
public List<DateTime> deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException, JsonProcessingException {
    List<DateTime> dateTimes = new ArrayList<>();
    String dateTimesString = jp.getText();
    dateTimesString = dateTimesString.substring(1, dateTimesString.length() - 1);
    String[] tokens = dateTimesString.split(",");
    for (String token : tokens) {
        dateTimes.add(DateTime.parse(token.trim()));
    }
    return dateTimes;
}

@Override
public void serialize(Set<Proposicao> values, JsonGenerator jgen, SerializerProvider provider) throws IOException, JsonProcessingException {
    CompactProposicaoSerializer propCompact = new CompactProposicaoSerializer();
    jgen.writeStartArray();
    for (Iterator<Proposicao> iterator = values.iterator(); iterator.hasNext(); ) {
        Proposicao proposicao = (Proposicao) iterator.next();
        propCompact.serialize(proposicao, jgen, provider);
    }
    jgen.writeEndArray();
}

@Override
public DateTime deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException, JsonProcessingException {
    JsonToken t = jp.getCurrentToken();
    if (t == JsonToken.VALUE_STRING) {
        String str = jp.getText().trim();
        return ISODateTimeFormat.dateTimeParser().parseDateTime(str);
    }
    if (t == JsonToken.VALUE_NUMBER_INT) {
        return new DateTime(jp.getLongValue());
    }
    throw ctxt.mappingException(handledType());
}

@Override
public TumblrResponse deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException, JsonProcessingException {
    JsonNode root = jp.readValueAsTree();
    TumblrResponse response = new TumblrResponse();
    JsonNode meta = root.get("meta");
    response.setStatus(meta.get("status").intValue());
    response.setMessage(meta.get("msg").textValue());
    response.setResponseJson(root.get("response").toString());
    return response;
}

@Override
public void serialize(final Map<Integer, Integer> value, final JsonGenerator jgen, final SerializerProvider provider) throws IOException, JsonProcessingException {
    jgen.writeStartArray();
    final Set<Integer> keySet = value.keySet();
    final Iterator<Integer> iterator = keySet.iterator();
    while (iterator.hasNext()) {
        final Integer keyValue = iterator.next();
        jgen.writeStartArray();
        jgen.writeNumber(keyValue);
        jgen.writeNumber(value.get(keyValue));
        jgen.writeEndArray();
    }
    jgen.writeEndArray();
}

@Override
public BigDecimal deserialize(JsonParser jsonParser, DeserializationContext ctx) throws IOException, JsonProcessingException {
    try {
        NumberFormat numberFormatter = NumberFormat.getInstance(LocaleContextHolder.getLocale());
        String numberText = jsonParser.getText();
        if (numberText == null || "".equals(numberText)) {
            return null;
        }
        return new BigDecimal(numberFormatter.parse(numberText).doubleValue());
    } catch (ParseException e) {
        throw new JsonParseException(null, null, e);
    }
}

@Override
public void serialize(TileLayerOptions value, JsonGenerator gen, SerializerProvider serializers) throws IOException, JsonProcessingException {
    gen.writeStartObject();
    gen.writeObjectField("attribution", value.getAttribution());
    gen.writeObjectField("bounds", value.getBounds());
    gen.writeObjectField("errorTileUrl", value.getErrorTileUrl());
    gen.writeObjectField("maxNativeZoom", value.getMaxNativeZoom());
    gen.writeObjectField("maxZoom", value.getMaxZoom());
    gen.writeObjectField("minZoom", value.getMinZoom());
    gen.writeObjectField("opacity", value.getOpacity());
    //        gen.writeObjectField("subdomains", value.getSubdomains());
    gen.writeObjectField("tileSize", value.getTileSize());
    gen.writeObjectField("unloadInvisibleTiles", value.getUnloadInvisibleTiles());
    gen.writeObjectField("updateWhenIdle", value.getUpdateWhenIdle());
    gen.writeObjectField("zIndex", value.getZIndex());
    gen.writeObjectField("zoomOffset", value.getZoomOffset());
    for (Map.Entry<String, String> e : value.getExtraParameters().entrySet()) {
        gen.writeObjectField(e.getKey(), e.getValue());
    }
    gen.writeEndObject();
}

@Nonnull
@Override
public BitSet deserialize(@Nonnull JsonParser deserializeFrom, @Nonnull Version formatVersion) throws IOException, VersionException, SerializationException, JsonProcessingException {
    BitSet bitSet = new BitSet();
    JacksonParserWrapper parserWrapper = new JacksonParserWrapper(deserializeFrom);
    while (parserWrapper.nextToken() != JsonToken.END_ARRAY) {
        Number value = parserWrapper.getNumberValue();
        bitSet.set(value.intValue());
    }
    return bitSet;
}

@Override
public void serialize(IVesselPositionMessage pos, JsonGenerator jg, SerializerProvider serializerProvider) throws IOException, JsonProcessingException {
    jg.useDefaultPrettyPrinter();
    jg.writeStartObject();
    if (pos instanceof AisMessage) {
        IProprietarySourceTag src = ((AisMessage) pos).getSourceTag();
        if (src != null) {
            jg.writeObjectField("src.clk", src.getTimestamp());
            jg.writeObjectField("src.id", src.getBaseMmsi());
            jg.writeObjectField("src.reg", src.getRegion());
            if (src.getCountry() != null)
                jg.writeObjectField("src.cty", src.getCountry().getTwoLetter());
        }
    }
    jg.writeObjectField("lat", pos.getPos().getGeoLocation().getLatitude());
    jg.writeObjectField("lon", pos.getPos().getGeoLocation().getLongitude());
    jg.writeObjectField("acc", pos.getPosAcc());
    jg.writeObjectField("hdg", pos.getTrueHeading());
    jg.writeObjectField("sog", pos.getSog() / 10f);
    jg.writeObjectField("cog", pos.getCog() / 10f);
    jg.writeEndObject();
}

public String getValue() {
    Map<String, String> values = new HashMap<>();
    if (name != null) {
        values.put(NAME_KEY, name);
    }
    if (version != null) {
        values.put(VERSION_KEY, version);
    }
    if (values.isEmpty()) {
        return null;
    }
    String urlSafe = null;
    try {
        String json = new ObjectMapper().writeValueAsString(values);
        urlSafe = Base64.encodeBase64URLSafeString(json.getBytes());
    } catch (JsonProcessingException e) {
        e.printStackTrace();
    }
    return urlSafe;
}

@Override
public Argument build(Class<?> expectedType, final TenacityConfiguration value, StatementContext ctx) {
    return new Argument() {

        @Override
        public void apply(int position, PreparedStatement statement, StatementContext ctx) throws SQLException {
            try {
                statement.setObject(position, objectMapper.writeValueAsString(value));
            } catch (JsonProcessingException err) {
                LOGGER.warn("Could not write as json: {}", value, err);
                throw new IllegalArgumentException(err);
            }
        }
    };
}

@Override
public String toBlueprint(String brooklynCatalogId, String location, CreateServiceInstanceRequest request) {
    ObjectWriter writer = new ObjectMapper().writer();
    Map<String, Object> metadata = MutableMap.copyOf(getMetadata());
    String name = (appName + " (CF Service)").trim();
    try {
        if (metadata.containsKey("location")) {
            location = writer.writeValueAsString(metadata.remove("location"));
        } else {
            location = writer.writeValueAsString(location);
        }
    } catch (JsonProcessingException e) {
        LOG.error("unable to make location: {}", e.getMessage());
        Exceptions.propagateIfFatal(e);
    }
    Map<Object, Object> config = MutableMap.of();
    // add parameters
    // TODO sanitize this input from user
    Map<?, ?> parameters = request.getParameters();
    if (parameters != null) {
        config.putAll(parameters);
    }
    config.putAll(metadata);
    String blueprint = "";
    if (config.keySet().size() > 0) {
        String configJson = null;
        try {
            configJson = writer.writeValueAsString(config);
            blueprint = String.format("{\"name\":\"%s\", \"services\":[{\"type\": \"%s\"}], \"locations\": [%s], \"brooklyn.config\":%s}", name, brooklynCatalogId, location, configJson);
        } catch (JsonProcessingException e) {
            LOG.error("unable to add config: {}", e.getMessage());
            Exceptions.propagateIfFatal(e);
        }
    } else {
        blueprint = String.format("{\"name\":\"%s\", \"services\":[{\"type\": \"%s\"}], \"locations\": [%s]}", name, brooklynCatalogId, location);
    }
    return blueprint;
}

@RequestMapping(value = "config.js", method = RequestMethod.GET)
public ResponseEntity<String> getConfigJs() throws JsonProcessingException {
    Map<String, String> config = configService.findAll().stream().collect(Collectors.toMap(Config::getConfigName, Config::getConfigValue));
    return ResponseEntity.ok().contentType(MediaType.parseMediaType("application/javascript")).body("window.Config = " + objectMapper.writeValueAsString(config) + ";");
}

@Override
public void serialize(final CyGroup group, JsonGenerator jgen, SerializerProvider provider) throws IOException, JsonProcessingException {
    jgen.useDefaultPrettyPrinter();
    jgen.writeStartObject();
    final CyNode groupNode = group.getGroupNode();
    final List<CyNode> memberNodes = group.getNodeList();
    final List<CyEdge> internalEdges = group.getInternalEdgeList();
    final Set<CyEdge> externalEdges = group.getExternalEdgeList();
    jgen.writeNumberField(CyIdentifiable.SUID, groupNode.getSUID());
    // TODO: Bug?  Always false
    //		jgen.writeBooleanField("collapsed", group.isCollapsed(group.getRootNetwork()));
    jgen.writeArrayFieldStart("nodes");
    for (final CyNode node : memberNodes) {
        jgen.writeNumber(node.getSUID());
    }
    jgen.writeEndArray();
    jgen.writeArrayFieldStart("internal_edges");
    for (final CyEdge edge : internalEdges) {
        jgen.writeNumber(edge.getSUID());
    }
    jgen.writeEndArray();
    jgen.writeArrayFieldStart("external_edges");
    for (final CyEdge edge : externalEdges) {
        jgen.writeNumber(edge.getSUID());
    }
    jgen.writeEndArray();
    jgen.writeEndObject();
}

public void serializeBody(Object value, JsonGenerator jgen, SerializerProvider provider) throws IOException, JsonProcessingException {
    int ref = this.debugger.getReferenceManager().getReference(value);
    jgen.writeNumberField("ref", ref);
    if (value == Types.UNDEFINED) {
        jgen.writeStringField("type", "undefined");
    } else if (value == Types.NULL) {
        jgen.writeStringField("type", "null");
    } else if (value instanceof Boolean) {
        jgen.writeStringField("type", "boolean");
        jgen.writeBooleanField("value", (Boolean) value);
    } else if (value instanceof Double) {
        jgen.writeStringField("type", "number");
        jgen.writeNumberField("value", (Double) value);
    } else if (value instanceof Long) {
        jgen.writeStringField("type", "number");
        jgen.writeNumberField("value", (Long) value);
    } else if (value instanceof String) {
        jgen.writeStringField("type", "string");
        jgen.writeStringField("value", (String) value);
    } else if (value instanceof JSObject) {
        jgen.writeStringField("type", "object");
    }
}

public String stringify(Object object) {
    if (object == null) {
        return "null";
    }
    try {
        return objectMapper.writeValueAsString(object);
    } catch (JsonProcessingException e) {
        try {
            return object.toString();
        } catch (Exception e1) {
            return "sorry but your object is not stringifyable";
        }
    }
}

@Override
public Chapter deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException, JsonProcessingException {
    JsonNode node = jp.getCodec().readTree(jp);
    String _id = null;
    JsonNode _idNode = node.get("_id");
    if (_idNode != null && !(_idNode instanceof NullNode)) {
        _id = _idNode.get("$oid").asText();
    }
    Integer number = null;
    JsonNode numberNode = node.get("number");
    if (numberNode != null && !(numberNode instanceof NullNode)) {
        number = numberNode.asInt();
    }
    Date created_at = null;
    JsonNode created_atNode = node.get("created_at");
    if (created_atNode != null && !(created_atNode instanceof NullNode)) {
        try {
            created_at = Dates.sdf.parse(created_atNode.asText());
        } catch (ParseException e) {
            e.printStackTrace();
        }
    }
    Chapter chapter = new Chapter(_id, number, created_at, null);
    JsonNode pagesNode = node.get("pages");
    if (pagesNode != null && !(pagesNode instanceof NullNode)) {
        chapter.pages = App.getInstance().mMapper.readValue(pagesNode.toString(), new TypeReference<Collection<Page>>() {
        });
        if (chapter.pages != null) {
            Iterator<Page> it = chapter.pages.iterator();
            while (it.hasNext()) {
                it.next().chapter = chapter;
            }
        }
    }
    return chapter;
}

/**
	 * Load.
	 * 
	 * @param is
	 *            the is
	 * @return the config
	 */
public static Config load(final InputStream is) {
    final ObjectMapper mapper = new ObjectMapper(new YAMLFactory());
    try {
        return Config.decorate((ObjectNode) mapper.readTree(is));
    } catch (final JsonProcessingException e) {
        LOG.log(Level.WARNING, "Couldn't parse Yaml file", e);
    } catch (final IOException e) {
        LOG.log(Level.WARNING, "Couldn't read Yaml file", e);
    }
    return null;
}

@Override
public void serialize(VirtualNetwork vNet, JsonGenerator jGen, SerializerProvider serializer) throws IOException, JsonProcessingException {
    jGen.writeStartObject();
    jGen.writeStringField("name", vNet.name);
    jGen.writeStringField("guid", vNet.guid);
    jGen.writeStringField("gateway", vNet.gateway);
    jGen.writeArrayFieldStart("portMac");
    Iterator<Entry<String, MacAddress>> entries = vNet.portToMac.entrySet().iterator();
    while (entries.hasNext()) {
        jGen.writeStartObject();
        Entry<String, MacAddress> entry = entries.next();
        jGen.writeStringField("port", entry.getKey().toString());
        jGen.writeStringField("mac", entry.getValue().toString());
        jGen.writeEndObject();
    }
    jGen.writeEndArray();
    jGen.writeEndObject();
}

public Object nullValue(DeserializationContext ctxt) throws JsonProcessingException {
    if (_isPrimitive && ctxt.isEnabled(DeserializationFeature.FAIL_ON_NULL_FOR_PRIMITIVES)) {
        throw ctxt.mappingException("Can not map JSON null into type " + _rawType.getName() + " (set DeserializationConfig.DeserializationFeature.FAIL_ON_NULL_FOR_PRIMITIVES to 'false' to allow)");
    }
    return _nullValue;
}

/*
     /**********************************************************
     /* Helper methods
     /**********************************************************
      */
public void testDisabling() throws Exception {
    final ObjectMapper mapper = objectMapper();
    // first, non-problematic case
    NonConflictingCreators value = mapper.readValue(quote("abc"), NonConflictingCreators.class);
    assertNotNull(value);
    assertEquals("abc", value._value);
    // then something that ought to fail
    try {
        /*ConflictingCreators value =*/
        mapper.readValue(quote("abc"), ConflictingCreators.class);
        fail("Should have failed with JsonCreator conflict");
    } catch (JsonProcessingException e) {
        verifyException(e, "Conflicting property-based creators");
    }
}

/**
     * Actually runs the test method.
     */
protected void invokeTestMethod(final FrameworkMethod method, final Object test, ResponseContext ctx) throws Throwable, SAXException, IOException, ParserConfigurationException, JsonProcessingException {
    HttpResponse response = ctx.getResponse();
    Class<?>[] methodParameters = method.getMethod().getParameterTypes();
    if (methodParameters.length == 1) {
        method.invokeExplosively(test, response);
    } else if (methodParameters.length == 2) {
        if (DoctestContext.class.isAssignableFrom(methodParameters[1])) {
            method.invokeExplosively(test, response, store);
        } else {
            method.invokeExplosively(test, response, ctx.getEntity());
        }
    } else if (methodParameters.length == 3) {
        if (DoctestContext.class.isAssignableFrom(methodParameters[1])) {
            method.invokeExplosively(test, response, store, ctx.getEntity());
        } else {
            method.invokeExplosively(test, response, ctx.getEntity(), store);
        }
    }
}

@Override
public ColumnDef deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException, JsonProcessingException {
    JsonNode node = jp.getCodec().readTree(jp);
    String type = node.get("type").asText();
    String name = node.get("name").asText();
    String charset = node.path("charset").asText();
    boolean signed = node.path("signed").asBoolean(false);
    String[] enumValues = null;
    JsonNode enumValueNode = node.get("enum-values");
    if (enumValueNode != null) {
        ArrayList<String> values = new ArrayList<>();
        for (JsonNode n : enumValueNode) values.add(n.asText());
        enumValues = (String[]) values.toArray(new String[0]);
    }
    Long columnLength = null;
    JsonNode columnLengthNode = node.get("column-length");
    if (columnLengthNode != null) {
        columnLength = columnLengthNode.asLong();
    }
    return ColumnDef.build(name, charset, type, 0, signed, enumValues, columnLength);
}

@Override
public NodeValue deserialize(JsonParser jp, DeserializationContext context) throws IOException, JsonProcessingException {
    byte[] value = null;
    long timestamp = 0;
    UUID uuid = null;
    boolean skip = false;
    JsonToken token = jp.nextToken();
    if (token != JsonToken.START_OBJECT) {
        skip = true;
    }
    while (skip || (token = jp.nextToken()) != JsonToken.END_OBJECT) {
        skip = false;
        String fieldName = jp.getCurrentName();
        jp.nextToken();
        if (fieldName.equals("value")) {
            value = jp.getBinaryValue();
        }
        if (fieldName.equals("idString")) {
            uuid = new UUID(jp.getText());
        }
        if (fieldName.equals("timestamp_long")) {
            timestamp = jp.getLongValue();
        }
    }
    try {
        return new NodeValue(uuid, value, timestamp);
    } catch (Exception e) {
        throw new IOException("Something went wrong deserializing nodeValues:" + e.getLocalizedMessage());
    }
}

@Override
public void serializeWithType(PolyString value, JsonGenerator jgen, SerializerProvider provider, TypeSerializer typeSer) throws IOException, JsonProcessingException {
    // TODO Auto-generated method stub
    //System.out.println("polystring serialization with type");
    //		typeSer.writeCustomTypePrefixForScalar(value, jgen, "poluStr");
    serialize(value, jgen, provider);
//		typeSer.writeCustomTypeSuffixForScalar(value, jgen, "tra");
//		jgen.writeStartObject();
//		jgen.writeString(value.getOrig());
//		jgen.writeTypeId("polyStirng");
//		jgen.writeStringField("norm", value.getNorm());
//		jgen.writeEndObject();
}

@Test
public void shouldSerializeJsonBody() throws JsonProcessingException {
    assertThat(ObjectMapperFactory.createObjectMapper().writeValueAsString(new JsonSchemaBody("{\"type\": \"object\", \"properties\": {\"id\": {\"type\": \"integer\"}}, \"required\": [\"id\"]}")), is("{\"type\":\"JSON_SCHEMA\",\"jsonSchema\":\"{\\\"type\\\": \\\"object\\\", \\\"properties\\\": {\\\"id\\\": {\\\"type\\\": \\\"integer\\\"}}, \\\"required\\\": [\\\"id\\\"]}\"}"));
}

@Override
public void serialize(Platform platform, JsonGenerator jsonGenerator, SerializerProvider serializerProvider) throws IOException, JsonProcessingException {
    switch(platform) {
        case WINDOWS:
            jsonGenerator.writeString("windows");
            break;
        case MAC_OS_X:
            jsonGenerator.writeString("osx");
            break;
        case LINUX:
            jsonGenerator.writeString("linux");
            break;
        case SOLARIS:
            jsonGenerator.writeString("solaris");
            break;
        case UNKNOWN:
            jsonGenerator.writeNull();
            break;
    }
}

@Override
public void serialize(Ref value, JsonGenerator jgen, SerializerProvider provider) throws IOException, JsonProcessingException {
    Object obj = value.getValue();
    if (obj != null) {
        // writeObject() abandons the serialization context and breaks @JsonView
        //jgen.writeObject(obj);
        // Tatu says that this is better:
        provider.defaultSerializeValue(value.getValue(), jgen);
    } else {
        jgen.writeString(value.key().getString());
    }
}

@Override
public void serialize(UUID value, JsonGenerator generator, SerializerProvider provider) throws IOException, JsonProcessingException {
    generator.writeStartArray();
    try {
        java.util.UUID.fromString(value.toString());
        generator.writeString("uuid");
    } catch (IllegalArgumentException ex) {
        generator.writeString("named-uuid");
    }
    generator.writeString(value.toString());
    generator.writeEndArray();
}

public String toJson(boolean pretty) {
    ObjectMapper mapper = new ObjectMapper();
    mapper.setVisibility(mapper.getSerializationConfig().getDefaultVisibilityChecker().withFieldVisibility(JsonAutoDetect.Visibility.ANY).withGetterVisibility(JsonAutoDetect.Visibility.NONE).withSetterVisibility(JsonAutoDetect.Visibility.NONE).withCreatorVisibility(JsonAutoDetect.Visibility.NONE));
    String toret = "";
    if (pretty) {
        mapper.enable(SerializationFeature.INDENT_OUTPUT);
    }
    try {
        toret = mapper.writeValueAsString(this);
    } catch (JsonProcessingException e) {
        e.printStackTrace();
    }
    return toret;
}

@GET("/@/api-docs/schemas/{fqcn}")
@RolesAllowed(AdminModule.RESTX_ADMIN_ROLE)
public String getJsonSchema(String fqcn) {
    SchemaFactoryWrapper visitor = new SchemaFactoryWrapper();
    try {
        mapper.acceptJsonFormatVisitor(mapper.constructType(Class.forName(fqcn)), visitor);
    } catch (JsonMappingException e) {
        throw new IllegalStateException(e);
    } catch (ClassNotFoundException e) {
        throw new WebException(HttpStatus.NOT_FOUND);
    }
    try {
        return mapper.writerWithDefaultPrettyPrinter().writeValueAsString(visitor.finalSchema());
    } catch (JsonProcessingException e) {
        throw new RuntimeException(e);
    }
}

@Override
public void serialize(Object value, JsonGenerator jgen, SerializerProvider provider) throws IOException, JsonProcessingException {
    if (value instanceof Optional) {
        if (((Optional<?>) value).isPresent()) {
            jgen.writeString(obfuscateValue(((Optional<?>) value).get().toString()));
        } else {
            jgen.writeNull();
        }
    } else {
        jgen.writeString(obfuscateValue(value.toString()));
    }
}

@Override
public Set<String> deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException, JsonProcessingException {
    JsonToken token = jp.getCurrentToken();
    if (token.isScalarValue()) {
        String list = jp.getText();
        list = list.replaceAll("\\s+", ",");
        return new LinkedHashSet<String>(Arrays.asList(StringUtils.commaDelimitedListToStringArray(list)));
    }
    return jp.readValueAs(new TypeReference<Set<String>>() {
    });
}

public void start() {
    logger.info("start.");
    vertx.eventBus().consumer("eb.sqltemplate",  message -> {
        logger.info("Received a message: " + message.body());
        List<Emp> emps = this.sqlTemplateService.findAll();
        try {
            String json = this.jsonMapper.writeValueAsString(emps);
            message.reply(json);
        } catch (JsonProcessingException e) {
            logger.error("convert error.", e);
        }
    });
}

@Async
@Override
public void publish(ProductRawEvent event) {
    if (event == null) {
        return;
    }
    try {
        final String sendMessage = objectMapper.writeValueAsString(event);
        kafkaTemplate.send(productKafkaTopic, sendMessage);
        log.debug("{} 전송 완료  - {}", this.productKafkaTopic, sendMessage);
    } catch (final JsonProcessingException e) {
        log.error(e.getMessage(), e);
    }
}

@Override
public SecuritySchemeDefinition deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException, JsonProcessingException {
    SecuritySchemeDefinition result = null;
    JsonNode node = jp.getCodec().readTree(jp);
    JsonNode inNode = node.get("type");
    if (inNode != null) {
        String type = inNode.asText();
        if ("basic".equals(type)) {
            result = Json.mapper().convertValue(node, BasicAuthDefinition.class);
        } else if ("apiKey".equals(type)) {
            result = Json.mapper().convertValue(node, ApiKeyAuthDefinition.class);
        } else if ("oauth2".equals(type)) {
            result = Json.mapper().convertValue(node, OAuth2Definition.class);
        }
    }
    return result;
}

protected static void sendAll(Object data) throws JsonProcessingException {
    String msg = new ObjectMapper().writer().withDefaultPrettyPrinter().writeValueAsString(data);
    try {
        Collection<Session> closedSessions = new ArrayList<>();
        for (Session session : CURRENT_CLIENTS) {
            if (!session.isOpen()) {
                closedSessions.add(session);
            } else {
                session.getBasicRemote().sendText(msg);
            }
        }
        CURRENT_CLIENTS.removeAll(closedSessions);
    } catch (Throwable e) {
        e.printStackTrace();
    }
}

@Override
public void appendArguments(StringBuilder dockerfileStringBuilder) {
    Set<Map.Entry<String, String>> entries = this.entries.entrySet();
    Iterator<Map.Entry<String, String>> iterator = entries.iterator();
    while (iterator.hasNext()) {
        Map.Entry<String, String> entry = iterator.next();
        try {
            dockerfileStringBuilder.append(objectMapper.writeValueAsString(entry.getKey()));
            dockerfileStringBuilder.append("=");
            dockerfileStringBuilder.append(objectMapper.writeValueAsString(entry.getValue()));
        } catch (JsonProcessingException e) {
            throw new RuntimeException("Can't serialize entry: " + entry, e);
        }
        if (iterator.hasNext()) {
            dockerfileStringBuilder.append(" \\\n\t");
        }
    }
}

//THIS IS NOT NEEDED for now, will refactor to make it to work later if we have the case
@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 void serialize(ExpressionValue value, JsonGenerator jgen, SerializerProvider provider) throws IOException, JsonProcessingException {
    switch(value.getType()) {
        case CHAR:
            jgen.writeString(Character.toString(value.getCharValue()));
            break;
        case STRING:
            jgen.writeString(value.getStringValue());
            break;
        case ADDRESS:
            jgen.writeString("0x" + Long.toHexString(value.getAddressValue()));
            break;
        case NUMBER:
            jgen.writeString(value.toString());
            break;
    }
}

@Test
public void test() throws UnRAVLException, JsonProcessingException, IOException {
    UnRAVLRuntime rt = new UnRAVLRuntime();
    assertFalse(rt.isCanceled());
    rt.execute(mockJson("{ 'env' : { 'shouldBeSet' : true }  }"), mockJson("{ 'bind' : { 'groovy' :  { 'canceledScript' : 'unravlScript.cancel(); true' }}}"), mockJson("{ 'env' : { 'shouldNotBeSet' : true }  }"));
    assertTrue(rt.isCanceled());
    assertEquals(Boolean.TRUE, rt.binding("shouldBeSet"));
    assertEquals(Boolean.TRUE, rt.binding("canceledScript"));
    assertFalse(rt.bound("shouldNotBeSet"));
}

@Override
public String deserialize(JsonParser jsonParser, DeserializationContext deserializationContext) throws IOException, JsonProcessingException {
    ObjectCodec oc = jsonParser.getCodec();
    JsonNode node = oc.readTree(jsonParser);
    if (node.isTextual()) {
        return node.textValue();
    } else if (node.isObject()) {
        JsonNode allNode = node.get("__all__");
        if (allNode != null && allNode.isArray()) {
            StringBuffer buf = new StringBuffer();
            for (JsonNode msgNode : allNode) {
                buf.append(msgNode.textValue());
                buf.append(",");
            }
            return buf.length() > 0 ? buf.substring(0, buf.length() - 1) : buf.toString();
        }
        return node.toString();
    }
    return null;
}

@SuppressWarnings("unchecked")
@Override
public List<Tag> deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException, JsonProcessingException {
    ObjectMapper mapper = BeanResolver.getInstance().resolve(ObjectMapper.class);
    jp.setCodec(mapper);
    if (jp.hasCurrentToken()) {
        JsonNode dataNode = (JsonNode) jp.readValueAs(JsonNode.class).get("data");
        return (List<Tag>) mapper.reader(new TypeReference<List<Tag>>() {
        }).readValue(dataNode);
    }
    return null;
}

@Override
public List<Recommendation> deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException, JsonProcessingException {
    ObjectMapper mapper = BeanResolver.getInstance().resolve(ObjectMapper.class);
    jp.setCodec(mapper);
    if (jp.hasCurrentToken()) {
        JsonNode dataNode = jp.readValueAs(JsonNode.class).get("values");
        if (dataNode != null) {
            return mapper.reader(new TypeReference<List<Recommendation>>() {
            }).readValue(dataNode);
        }
    }
    return null;
}

@Override
public SimilarPlacesResponse deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException, JsonProcessingException {
    ObjectMapper mapper = BeanResolver.getInstance().resolve(ObjectMapper.class);
    jp.setCodec(mapper);
    JsonNode node = jp.readValueAs(JsonNode.class);
    JsonNode resultNode = node.get("result");
    String token = resultNode.get("token").textValue();
    JsonNode placesNode = resultNode.get("places");
    @SuppressWarnings("unchecked") List<Place> places = (List<Place>) mapper.reader(new TypeReference<List<Place>>() {
    }).readValue(placesNode);
    return new SimilarPlacesResponse(places, token);
}

/**
     * {@inheritDoc}
     */
@Override
public Response toResponse(JsonProcessingException exception) {
    Throwable throwable = exception;
    while (throwable != null) {
        if (throwable instanceof PersistenceException) {
            return exceptionMappers.get().findMapping(throwable).toResponse(throwable);
        }
        throwable = throwable.getCause();
    }
    logger.debug("Json Processing error", exception);
    String message = exception.getOriginalMessage();
    String desc = null;
    String source = null;
    if (mode.isDev()) {
        desc = IOUtils.getStackTrace(exception);
        JsonLocation location = exception.getLocation();
        if (location != null) {
            source = "line: " + location.getLineNr() + ", column: " + location.getColumnNr();
        } else {
            source = exception.getStackTrace()[0].toString();
        }
    }
    ErrorMessage errorMessage = ErrorMessage.fromStatus(Response.Status.BAD_REQUEST.getStatusCode());
    errorMessage.setThrowable(exception);
    errorMessage.setCode(Hashing.murmur3_32().hashUnencodedChars(exception.getClass().getName()).toString());
    errorMessage.addError(new Result.Error(errorMessage.getCode(), message != null ? message : exception.getMessage(), desc, source));
    return Response.status(errorMessage.getStatus()).entity(errorMessage).type(ExceptionMapperUtils.getResponseType()).build();
}

/**
     * @see com.fasterxml.jackson.databind.JsonDeserializer#deserialize(com.fasterxml.jackson.core.JsonParser, com.fasterxml.jackson.databind.DeserializationContext)
     */
@Override
public HeaderMap deserialize(JsonParser p, DeserializationContext ctxt) throws IOException, JsonProcessingException {
    HeaderMap map = new HeaderMap();
    List<Entry<String, String>> entries = p.readValueAs(new TypeReference<List<Entry<String, String>>>() {
    });
    for (Entry<String, String> entry : entries) {
        String key = entry.getKey();
        String val = entry.getValue();
        map.add(key, val);
    }
    return map;
}

public String getJson() {
    Map<String, Object> myJson = new LinkedHashMap<String, Object>();
    myJson.put("orderId", orderId);
    myJson.put("packageName", packageName);
    myJson.put("productId", productId);
    myJson.put("purchaseTime", purchaseTime);
    myJson.put("purchaseToken", purchaseToken);
    if (developerPayload != null)
        myJson.put("developerPayload", developerPayload);
    ObjectMapper mapper = new ObjectMapper();
    mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
    try {
        return mapper.writeValueAsString(myJson);
    } catch (JsonProcessingException e) {
        e.printStackTrace();
    }
    return null;
}

public Answer prettyPrintAnswer() throws JsonProcessingException {
    Answer answer = new Answer();
    answer.setQuestion(_question);
    answer.setStatus(_status);
    for (AnswerElement ae : _answerElements) {
        String aePrettyStr = ae.prettyPrint();
        AnswerElement prettyAnswerElement = new StringAnswerElement(aePrettyStr);
        answer.addAnswerElement(prettyAnswerElement);
    }
    return answer;
}

@Override
public void serialize(ValueHighlighter value, JsonGenerator jgen, SerializerProvider provider) throws IOException, JsonProcessingException {
    synchronized (value) {
        jgen.writeStartObject();
        jgen.writeObjectField("type", value.getClass().getSimpleName());
        jgen.writeObjectField("colName", value.getColName());
        jgen.writeObjectField("colors", value.getColors());
        jgen.writeEndObject();
    }
}

public static String toJson(Object obj) {
    ObjectWriter writer = new ObjectMapper().writer().withDefaultPrettyPrinter();
    String result = null;
    try {
        result = writer.writeValueAsString(obj);
    } catch (JsonProcessingException e) {
        Assert.fail("Cannot serialize the object to JSON");
    }
    return result;
}

public BuildConfigDiscoveryResult discover(GitInfo branch) throws IOException {
    GHRepository repository = gitHubHelper.repositoryFor(branch);
    GHTree tree = gitHubHelper.treeFor(repository, branch);
    Set<String> buildConfigFilePaths = new HashSet<>();
    for (GHTreeEntry entry : tree.getTree()) {
        if (isBuildConfig(entry.getPath())) {
            buildConfigFilePaths.add(entry.getPath());
        }
    }
    Set<DiscoveredBuildConfig> discoveredBuildConfigs = new HashSet<>();
    Set<MalformedFile> malformedFiles = new HashSet<>();
    for (String buildConfigFilePath : buildConfigFilePaths) {
        final BuildConfig buildConfig;
        try {
            buildConfig = gitHubHelper.configFor(buildConfigFilePath, repository, branch).get();
        } catch (JsonProcessingException e) {
            LOG.warn("Error parsing config at path {} for repository {}@{}", buildConfigFilePath, branch.getFullRepositoryName(), branch.getBranch());
            malformedFiles.add(new MalformedFile(branch.getId().get(), "config", buildConfigFilePath, Throwables.getStackTraceAsString(e)));
            continue;
        }
        String glob = (buildConfigFilePath.contains("/") ? buildConfigFilePath.substring(0, buildConfigFilePath.lastIndexOf('/') + 1) : "") + "**";
        discoveredBuildConfigs.add(new DiscoveredBuildConfig(buildConfig, buildConfigFilePath, glob));
    }
    return new BuildConfigDiscoveryResult(discoveredBuildConfigs, malformedFiles);
}

@Override
public void serialize(final TimerEventTriggerInstance timerEventTriggerInstance, final JsonGenerator jgen, final SerializerProvider provider) throws IOException, JsonProcessingException {
    jgen.writeStartObject();
    jgen.writeObjectField("eventInstanceName", timerEventTriggerInstance.getEventInstanceName());
    jgen.writeObjectField("executionDate", timerEventTriggerInstance.getExecutionDate());
    jacksonSerializerHelper.writeNumberField(jgen, "id", timerEventTriggerInstance.getId());
    jacksonSerializerHelper.writeNumberField(jgen, "eventInstanceId", timerEventTriggerInstance.getEventInstanceId());
    jgen.writeEndObject();
}

@Override
public String toString() {
    ObjectMapper mapper = new ObjectMapper();
    mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
    try {
        return mapper.writeValueAsString(this);
    } catch (JsonProcessingException e) {
        throw new RuntimeException("Failed while parsing JSON response", e);
    }
}

@Override
public Location deserialize(JsonParser jp, DeserializationContext dc) throws IOException, JsonProcessingException {
    JsonNode node = jp.getCodec().readTree(jp);
    int id = (Integer) ((IntNode) node.get("locationId")).numberValue();
    String countryCode = node.get("countryCode").asText();
    String defaultLanguage = node.get("defaultLanguage").asText();
    Locale locale = new Locale.Builder().setLanguage(defaultLanguage).setRegion(countryCode).build();
    String name = node.get("locationName").asText();
    JsonNode mapSection = node.get("mapSection");
    Coordinates center = new Coordinates(mapSection.get("center").get("latitude").asDouble(), mapSection.get("center").get("longitude").asDouble());
    Coordinates lowerRight = new Coordinates(mapSection.get("lowerRight").get("latitude").asDouble(), mapSection.get("lowerRight").get("longitude").asDouble());
    Coordinates upperLeft = new Coordinates(mapSection.get("upperLeft").get("latitude").asDouble(), mapSection.get("upperLeft").get("longitude").asDouble());
    TimeZone timezone = TimeZone.getTimeZone(node.get("timezone").asText());
    return new Location(id, locale, name, center, lowerRight, upperLeft, timezone);
}

@Override
public void serialize(Map<String, String> map, JsonGenerator generator, SerializerProvider provider) throws IOException, JsonProcessingException {
    generator.writeStartArray();
    if (map != null && !map.isEmpty()) {
        for (Map.Entry<String, String> entry : map.entrySet()) {
            String key = entry.getKey();
            String value = entry.getValue();
            if (key != null && !key.isEmpty()) {
                generator.writeStartObject();
                generator.writeObjectField("name", key);
                generator.writeObjectField("value", value);
                generator.writeEndObject();
            }
        }
    }
    generator.writeEndArray();
}

@Override
public void serialize(Entity value, JsonGenerator jgen, SerializerProvider provider) throws IOException, JsonProcessingException {
    jgen.writeStartObject();
    ECSResourceMap map = value.getComponent(ECSResourceMap.class);
    if (map != null) {
        List<ECSResourceData> ress = map.getResources().collect(Collectors.toList());
        for (ECSResourceData res : ress) {
            jgen.writeObjectField(res.getResource().toString(), res.get());
        }
    }
    ECSAttributeMap attributes = value.getComponent(ECSAttributeMap.class);
    if (attributes != null) {
        List<ECSAttributeData> attribs = attributes.getAttributes().collect(Collectors.toList());
        for (ECSAttributeData attr : attribs) {
            jgen.writeObjectField(attr.getAttribute().toString(), attr.get());
        }
    }
    EffectComponent effect = value.getComponent(EffectComponent.class);
    if (effect != null) {
        jgen.writeObjectField("description", effect.getDescription());
    }
    ComponentRetriever<CreatureTypeComponent> creatureType = Retrievers.component(CreatureTypeComponent.class);
    if (creatureType.has(value)) {
        jgen.writeObjectField("type", creatureType.get(value).getAllTypes());
    }
    jgen.writeEndObject();
}

@Override
protected void writeInternal(Object object, HttpOutputMessage outputMessage) throws IOException, HttpMessageNotWritableException {
    outputMessage.getHeaders().setContentType(MediaType.parseMediaType("text/javascript"));
    JsonEncoding encoding = getJsonEncoding(outputMessage.getHeaders().getContentType());
    JsonGenerator jsonGenerator = this.getObjectMapper().getFactory().createGenerator(outputMessage.getBody(), encoding);
    // https://github.com/FasterXML/jackson-databind/issues/12
    if (this.getObjectMapper().isEnabled(SerializationFeature.INDENT_OUTPUT)) {
        jsonGenerator.useDefaultPrettyPrinter();
    }
    List<String> values = outputMessage.getHeaders().get("callback");
    String callBack = null;
    if (values != null && values.size() > 0)
        callBack = values.get(0);
    try {
        if (StringUtils.hasText(callBack)) {
            String json = this.getObjectMapper().writeValueAsString(object);
            json = callBack + "( " + json + " )";
            outputMessage.getBody().write(json.getBytes(Charset.forName("UTF-8")));
            outputMessage.getBody().flush();
        } else {
            this.getObjectMapper().writeValue(jsonGenerator, object);
        }
    } catch (JsonProcessingException ex) {
        throw new HttpMessageNotWritableException("Could not write JSON: " + ex.getMessage(), ex);
    }
}

/**
	 * @throws JsonProcessingException on error
	 */
@Test
public void singleObjects() throws JsonProcessingException {
    SSHKey key = new SSHKey("akey", "aowner");
    System.out.println(this.mapper.writeValueAsString(key));
    Set<SSHKey> keys = new HashSet<>();
    keys.add(key);
    System.out.println(this.mapper.writeValueAsString(keys));
    System.out.println(this.mapper.writeValueAsString(keys.toArray(new SSHKey[0])));
    HashSet<Dependency> hashSet = new HashSet<Dependency>();
    hashSet.add(new Dependency("moep", "moep", "<", DependencyType.PROVIDES.toString()));
    PackageVersion v = new PackageVersion("test", "test", hashSet);
    System.out.println(this.mapper.writeValueAsString(v));
}

@Transient
public default String toJSON() {
    ObjectMapper mapper = new ObjectMapper();
    mapper.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);
    mapper.configure(SerializationFeature.INDENT_OUTPUT, true);
    mapper.configure(DeserializationFeature.ACCEPT_SINGLE_VALUE_AS_ARRAY, true);
    mapper.setSerializationInclusion(Include.NON_NULL);
    String json = "";
    try {
        json = mapper.writeValueAsString(this);
    } catch (JsonProcessingException e) {
        json = "{ error : Error: it's not possible processing JSON }";
        LoggerFactory.getLogger(JSON.class).error("Error: it's not possible processing JSON", e);
    }
    return json;
}

@Override
public void serialize(ImageStatistics imageStatistics, JsonGenerator jsonGen, SerializerProvider serializerProvider) throws IOException, JsonProcessingException {
    jsonGen.writeStartObject();
    jsonGen.writeArrayFieldStart("bands");
    ImageStatistics.Band[] bands = imageStatistics.getBands();
    for (int i = 0; i < bands.length; i++) {
        final ImageStatistics.Band band = bands[i];
        jsonGen.writeStartObject();
        jsonGen.writeNumberField("index", band.getBandIndex());
        if (band.getName() != null) {
            jsonGen.writeStringField("name", band.getName());
        }
        if (band.getDataType() != null) {
            jsonGen.writeStringField("dataType", band.getDataType().name());
        }
        jsonGen.writeNumberField("min", band.getMin());
        jsonGen.writeNumberField("max", band.getMax());
        jsonGen.writeNumberField("mean", band.getMean());
        jsonGen.writeNumberField("std", band.getStd());
        if (band.getNoData() != null) {
            jsonGen.writeArrayFieldStart("noData");
            for (int j = 0; j < band.getNoData().length; j++) {
                jsonGen.writeNumber(band.getNoData()[j]);
            }
            //noData
            jsonGen.writeEndArray();
        }
        if (band.getHistogram() != null) {
            final long[] distrib = band.tightenHistogram(255);
            jsonGen.writeArrayFieldStart("histogram");
            for (int j = 0; j < distrib.length; j++) {
                jsonGen.writeNumber(distrib[j]);
            }
            //histogram
            jsonGen.writeEndArray();
        }
        //end band
        jsonGen.writeEndObject();
    }
    jsonGen.writeEndArray();
    jsonGen.writeEndObject();
}

@Override
public void serialize(PackedCoordinateSequence value, JsonGenerator jgen, SerializerProvider provider) throws IOException, JsonProcessingException {
    jgen.writeStartArray();
    for (int i = 0; i < value.size(); ++i) {
        jgen.writeStartArray();
        for (int j = 0; j < value.getDimension(); j++) {
            double ordinate = value.getOrdinate(i, j);
            if (!Double.isNaN(ordinate)) {
                if (precision == -1) {
                    jgen.writeObject(ordinate);
                } else {
                    jgen.writeRawValue(String.format("%." + precision + "f", ordinate));
                }
            }
        }
        jgen.writeEndArray();
    }
    jgen.writeEndArray();
}

@Test
public void testBooksStreamIsReturnedFromLastEventId() throws JsonProcessingException {
    Response r = createWebClient("/rest/api/bookstore/sse/100").header(HttpHeaders.LAST_EVENT_ID_HEADER, 150).get();
    assertEquals(Status.OK.getStatusCode(), r.getStatus());
    final String response = r.readEntity(String.class);
    assertThat(response, containsString("id: 151"));
    assertThat(response, containsString("data: " + toJson("New Book #151", 151)));
    assertThat(response, containsString("id: 152"));
    assertThat(response, containsString("data: " + toJson("New Book #152", 152)));
    assertThat(response, containsString("id: 152"));
    assertThat(response, containsString("data: " + toJson("New Book #153", 153)));
    assertThat(response, containsString("id: 152"));
    assertThat(response, containsString("data: " + toJson("New Book #154", 154)));
    r.close();
}

@Override
public Date deserialize(final JsonParser parser, final DeserializationContext ctxt) throws IOException, JsonProcessingException {
    final JsonToken token = parser.getCurrentToken();
    if (token == JsonToken.VALUE_STRING) {
        final String str = parser.getText().trim();
        return toDate(Long.parseLong(str));
    } else if (token == JsonToken.VALUE_NUMBER_INT) {
        return toDate(parser.getLongValue());
    }
    throw ctxt.wrongTokenException(parser, JsonToken.VALUE_STRING, "Expected a string or numeric value");
}

@Override
public Binds deserialize(JsonParser jsonParser, DeserializationContext deserializationContext) throws IOException, JsonProcessingException {
    List<Bind> binds = new ArrayList<Bind>();
    ObjectCodec oc = jsonParser.getCodec();
    JsonNode node = oc.readTree(jsonParser);
    for (Iterator<JsonNode> it = node.elements(); it.hasNext(); ) {
        JsonNode field = it.next();
        binds.add(Bind.parse(field.asText()));
    }
    return new Binds(binds.toArray(new Bind[0]));
}

@Override
public void serialize(OAuth2Exception value, JsonGenerator jgen, SerializerProvider provider) throws IOException, JsonProcessingException {
    jgen.writeStartObject();
    jgen.writeStringField("error", value.getOAuth2ErrorCode());
    jgen.writeStringField("error_description", value.getMessage());
    if (value.getAdditionalInformation() != null) {
        for (Entry<String, String> entry : value.getAdditionalInformation().entrySet()) {
            String key = entry.getKey();
            String add = entry.getValue();
            jgen.writeStringField(key, add);
        }
    }
    jgen.writeEndObject();
}

@Override
public Object deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException, JsonProcessingException {
    if (formatString != null && !formatString.isEmpty() && jp.getCurrentToken() == JsonToken.VALUE_STRING) {
        String str = jp.getText().trim();
        if (str.length() == 0) {
            return null;
        }
        return Joda.forPattern(formatString).parser().parseDateTime(str).toDate();
    }
    return super._parseDate(jp, ctxt);
}

private String toJson(Resource resource) throws JsonProcessingException {
    final ObjectMapper mapper = new ObjectMapper();
    final JacksonOptions jacksonOptions = JacksonOptions.from(options);
    mapper.registerModule(new EMFModule(resource.getResourceSet(), jacksonOptions));
    final JsonNode contents = mapper.valueToTree(resource);
    final ObjectNode resourceNode = mapper.createObjectNode();
    final String id = uri.segment(2);
    resourceNode.put(MongoHandler.ID_FIELD, id);
    resourceNode.put(MongoHandler.TYPE_FIELD, "resource");
    resourceNode.set(MongoHandler.CONTENTS_FIELD, contents);
    return mapper.writeValueAsString(resourceNode);
}

@Override
public Resource create(JsonNode value) throws JsonProcessingException {
    final EClass root = ModelPackage.Literals.USER;
    final JacksonOptions options = new JacksonOptions.Builder().withRoot(root).build();
    final ObjectMapper mapper = new ObjectMapper();
    mapper.registerModule(new EMFModule(resourceSet, options));
    final Resource resource = mapper.treeToValue(value, Resource.class);
    resource.setURI(uri(value.get("name").asText()));
    return resource;
}

@Override
public Application deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException, JsonProcessingException {
    String name = null;
    List<InstanceInfo> instances = new ArrayList<>();
    while (jp.nextToken() == JsonToken.FIELD_NAME) {
        String fieldName = jp.getCurrentName();
        // to point to value
        jp.nextToken();
        if ("name".equals(fieldName)) {
            name = jp.getValueAsString();
        } else if ("instance".equals(fieldName)) {
            instances.add(jp.readValueAs(InstanceInfo.class));
        } else {
            throw new JsonMappingException("Unexpected field " + fieldName, jp.getCurrentLocation());
        }
    }
    return new Application(name, instances);
}

@Test
public void testParsing() throws JsonProcessingException, IOException {
    final StatusProcessor processor = new StatusProcessor();
    final JsonNode node = loadAndParseData("Status.json");
    final Status status = processor.parseEntry(node);
    assertThat(status.getServerName(), equalTo("TRANQUILITY"));
    assertThat(status.getServerVersion(), startsWith("EVE-TRANQUILITY "));
    assertThat(status.getServiceStatusDust(), equalTo(State.ONLINE));
    assertThat(status.getServiceStatusEve(), equalTo(State.ONLINE));
    assertThat(status.getServiceStatusServer(), equalTo(State.ONLINE));
    assertThat(status.getUserCountsDust(), greaterThan(1));
    assertThat(status.getUserCountsEve(), greaterThan(1));
}

@Override
public GeoJson deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException, JsonProcessingException {
    ObjectCodec codec = jp.getCodec();
    ObjectMapper mapper = (ObjectMapper) codec;
    ObjectNode root = (ObjectNode) mapper.readTree(jp);
    JsonNode type = root.get(getTypeFieldName());
    if (type == null) {
        throw new IllegalArgumentException(this.getValueClass().getSimpleName() + " type cannot be empty.");
    }
    String sType = type.textValue();
    if (sType == null || sType.isEmpty()) {
        throw new IllegalArgumentException(this.getValueClass().getSimpleName() + " type cannot be empty.");
    }
    Class<GeoJson> clazz = (Class<GeoJson>) resolveClass(sType);
    GeoJson obj = codec.treeToValue(root, clazz);
    if (obj == null) {
        throw new IllegalArgumentException(this.getValueClass().getSimpleName() + " type deserialised as null: " + root.toString());
    }
    return obj;
}

@Override
public TypedOutput toBody(Object object) {
    try {
        String json = objectMapper.writeValueAsString(object);
        return new TypedByteArray(MIME_TYPE, json.getBytes("UTF-8"));
    } catch (JsonProcessingException e) {
        throw new AssertionError(e);
    } catch (UnsupportedEncodingException e) {
        throw new AssertionError(e);
    }
}

@Override
protected EventSet consume(ProcessingContext context, EventSet eventSet) throws ProcessingException {
    /*if(!eventSet.isAggregate()) {
            return  eventSet;
        }*/
    System.out.println("********");
    try {
        System.out.println(objectMapper.writerWithDefaultPrettyPrinter().writeValueAsString(eventSet));
        System.out.flush();
    } catch (JsonProcessingException e) {
        e.printStackTrace();
    }
    System.out.println("========");
    return eventSet;
}

/**
     * Performs the serialization of a OFFeaturesReply object
     */
@Override
public void serialize(OFFeaturesReply reply, JsonGenerator jGen, SerializerProvider serializer) throws IOException, JsonProcessingException {
    jGen.writeStartObject();
    jGen.writeNumberField("actions", reply.getActions());
    jGen.writeNumberField("buffers", reply.getBuffers());
    jGen.writeNumberField("capabilities", reply.getCapabilities());
    jGen.writeStringField("datapathId", HexString.toHexString(reply.getDatapathId()));
    jGen.writeNumberField("length", reply.getLength());
    serializer.defaultSerializeField("ports", reply.getPorts(), jGen);
    jGen.writeNumberField("tables", reply.getTables());
    jGen.writeStringField("type", reply.getType().toString());
    jGen.writeNumberField("version", reply.getVersion());
    jGen.writeNumberField("xid", reply.getXid());
    jGen.writeEndObject();
}

/**
     * Performs the serialization of a OFFeaturesReply object
     */
@Override
public void serialize(OFFeaturesReply reply, JsonGenerator jGen, SerializerProvider serializer) throws IOException, JsonProcessingException {
    jGen.writeStartObject();
    jGen.writeNumberField("actions", reply.getActions());
    jGen.writeNumberField("buffers", reply.getBuffers());
    jGen.writeNumberField("capabilities", reply.getCapabilities());
    jGen.writeStringField("datapathId", HexString.toHexString(reply.getDatapathId()));
    jGen.writeNumberField("length", reply.getLength());
    serializer.defaultSerializeField("ports", reply.getPorts(), jGen);
    jGen.writeNumberField("tables", reply.getTables());
    jGen.writeStringField("type", reply.getType().toString());
    jGen.writeNumberField("version", reply.getVersion());
    jGen.writeNumberField("xid", reply.getXid());
    jGen.writeEndObject();
}

@Override
public Response toResponse(FoxtrotException e) {
    Map<String, Object> response = e.toMap();
    response.put("code", e.getCode());
    try {
        logger.error(mapper.writeValueAsString(response), e);
    } catch (JsonProcessingException e1) {
        logger.error("exception_serialization_failed", e1);
    }
    switch(e.getCode()) {
        case DOCUMENT_NOT_FOUND:
        case TABLE_NOT_FOUND:
            return Response.status(Response.Status.NOT_FOUND).entity(response).build();
        case STORE_CONNECTION_ERROR:
        case TABLE_INITIALIZATION_ERROR:
        case TABLE_METADATA_FETCH_FAILURE:
        case DATA_CLEANUP_ERROR:
        case STORE_EXECUTION_ERROR:
        case EXECUTION_EXCEPTION:
        case ACTION_EXECUTION_ERROR:
            return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(response).build();
        case MALFORMED_QUERY:
        case ACTION_RESOLUTION_FAILURE:
        case UNRESOLVABLE_OPERATION:
        case INVALID_REQUEST:
            return Response.status(Response.Status.BAD_REQUEST).entity(response).build();
        case TABLE_ALREADY_EXISTS:
            return Response.status(Response.Status.CONFLICT).entity(response).build();
        case CONSOLE_SAVE_EXCEPTION:
        case CONSOLE_FETCH_EXCEPTION:
            return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(response).build();
        default:
            return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(response).build();
    }
}

@Override
public String convertToDatabaseColumn(final Object obj) {
    if (obj == null) {
        return null;
    }
    try {
        return objectMapper.writeValueAsString(obj);
    } catch (final JsonProcessingException e) {
        logger.info("Could not parse object metadata: {}. The value will be converted as string. Reason: {}", obj, e);
        return obj.toString();
    }
}

// TODO - See 'Can't create HyperLogLogPlus sketches in JSON'
@Override
public HyperLogLogPlus deserialize(final JsonParser jsonParser, final DeserializationContext deserializationContext) throws IOException, JsonProcessingException {
    final TreeNode treeNode = jsonParser.getCodec().readTree(jsonParser);
    final TreeNode coreHyperLogLogPlusObject = treeNode.get("hyperLogLogPlus");
    if (coreHyperLogLogPlusObject != null) {
        final TextNode jsonNodes = (TextNode) coreHyperLogLogPlusObject.get(HyperLogLogPlusJsonConstants.HYPER_LOG_LOG_PLUS_SKETCH_BYTES_FIELD);
        final byte[] nodeAsString = jsonNodes.binaryValue();
        final HyperLogLogPlus hyperLogLogPlus = HyperLogLogPlus.Builder.build(nodeAsString);
        return hyperLogLogPlus;
    } else {
        throw new IllegalArgumentException("Recieved null or empty HyperLogLogPlus sketch");
    }
}