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

@Override
public void serialize(List<Tag> value, JsonGenerator jgen, SerializerProvider provider) throws IOException, JsonGenerationException {
    if (value != null && !value.isEmpty()) {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < value.size(); i++) {
            Tag tag = value.get(i);
            sb.append(tag.getTagText());
            if (i != value.size() - 1)
                sb.append(",");
        }
        jgen.writeString(sb.toString());
    } else {
        jgen.writeString("");
    }
}

@Override
protected ModelAndView doResolveException(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) {
    if (isRestServiceException(request)) {
        LOGGER.error("catch restful error:" + ex);
        RestError error = errorResolver.resolveError(request, handler, ex);
        response.setCharacterEncoding("UTF-8");
        response.setContentType("application/json");
        ObjectMapper mapper = new ObjectMapper();
        try {
            JsonGenerator jsonGenerator = mapper.getFactory().createGenerator(response.getOutputStream(), JsonEncoding.UTF8);
            mapper.writeValue(jsonGenerator, errorConverter.convert(error));
        } catch (JsonGenerationException e) {
            e.printStackTrace();
        } catch (JsonMappingException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return new ModelAndView();
    } else
        return super.doResolveException(request, response, handler, ex);
}

protected void writeProposicao(Proposicao value, JsonGenerator jgen) throws IOException, JsonGenerationException {
    if (value.getId() != null) {
        jgen.writeNumberField("id", value.getId());
    }
    jgen.writeStringField("ementa", value.getEmenta());
    jgen.writeStringField("tipo", value.getTipo());
    jgen.writeStringField("numero", value.getNumero());
    jgen.writeStringField("ano", value.getAno());
    jgen.writeStringField("sigla", value.getSigla());
    jgen.writeStringField("comissao", value.getComissao());
    jgen.writeNumberField("idProposicao", value.getIdProposicao());
    jgen.writeStringField("origem", value.getOrigem().name());
    jgen.writeStringField("linkProposicao", value.getLinkProposicao());
}

public static void main(String[] args) throws JsonGenerationException, JsonMappingException, IOException {
    //		AreaContainer container = new AreaContainer();
    //		
    //		container.setName("嘿嘿");
    //		
    //		
    //		SysSetting setting = new SysSetting();
    //		
    //		setting.setCreateperson(1231);
    //		setting.setEdittime(new Date());
    //		setting.setPropId(213111);
    //		
    //		Area area = new Area();
    //		
    //		area.setAreaName("浪费大");
    //		area.setAreaRemoteId(231);
    //		area.setId(UUIDGenerator.randomUUID());
    //		area.setLongitude(231.2);
    //		area.setRadius(200);
    //		
    //		
    //		container.setArea(area);
    //		container.setSetting(setting);
    StringWriter writer = new StringWriter();
    ObjectMapper mapper = new ObjectMapper();
    mapper.writeValue(writer, new String("hello"));
    SocketMessage message = new SocketMessage();
    message.setEventName("say");
    message.setPayload(writer.toString());
    writer = new StringWriter();
    // where 'dst' can be File, OutputStream or Writer
    mapper.writeValue(writer, message);
    System.out.println(writer.toString());
    SocketMessage newMessage = mapper.readValue(writer.toString(), SocketMessage.class);
    System.out.println(newMessage.getEventName() + "\n" + newMessage.getPayload());
}

@Override
protected void serializeFields(Object bean, JsonGenerator jgen, SerializerProvider provider) throws IOException, JsonGenerationException {
    final BeanPropertyWriter[] props;
    if (_filteredProps != null && provider.getActiveView() != null) {
        props = _filteredProps;
    } else {
        props = _props;
    }
    int i = 0;
    try {
        for (final int len = props.length; i < len; ++i) {
            if (props[i] != null) {
                // can have nulls in filtered list
                // override to use own property writer
                OsemBeanPropertyWriter prop = new OsemBeanPropertyWriter(props[i]);
                prop.serializeAsField(bean, jgen, provider);
            }
        }
        if (_anyGetterWriter != null) {
            _anyGetterWriter.getAndSerialize(bean, jgen, provider);
        }
    } catch (Exception e) {
        String name = (i == props.length) ? "[anySetter]" : props[i].getName();
        wrapAndThrow(provider, e, bean, name);
    } catch (StackOverflowError e) {
        JsonMappingException mapE = new JsonMappingException("Infinite recursion (StackOverflowError)", e);
        String name = (i == props.length) ? "[anySetter]" : props[i].getName();
        mapE.prependPath(new JsonMappingException.Reference(bean, name));
        throw mapE;
    }
}

@Override
public void writeIndentation(JsonGenerator jg, int level) throws IOException, JsonGenerationException {
    jg.writeRaw(SYS_LF);
    if (level > 0) {
        // should we err on negative values (as there's some flaw?)
        // 4 spaces per level
        level = level * 4;
        while (level > spacecount) {
            // should never happen but...
            jg.writeRaw(spaces, 0, spacecount);
            level -= spaces.length;
        }
        jg.writeRaw(spaces, 0, level);
    }
}

@Override
public void serialize(PropertyValue value, JsonGenerator jgen, SerializerProvider provider) throws IOException, JsonGenerationException {
    if (value instanceof PropertyValueSimpleImpl) {
        if (value.getValues().size() == 1) {
            jgen.writeString(value.getValues().get(0));
        } else {
            jgen.writeStartArray();
            for (String val : value.getValues()) {
                jgen.writeString(val);
            }
            jgen.writeEndArray();
        }
    } else {
        PropertyValueLocalizedImpl localized = (PropertyValueLocalizedImpl) value;
        Set<Locale> localizations = localized.getLocalizations();
        if (localizations.size() == 1 && localized.getValues().size() == 1) {
            writeSingleLocalization(jgen, localizations.iterator().next(), localized.getValues().get(0));
        } else {
            jgen.writeStartArray();
            for (Locale language : localizations) {
                for (String val : localized.getValues(language)) {
                    writeSingleLocalization(jgen, language, val);
                }
            }
            jgen.writeEndArray();
        }
    }
}

/**
     * Main serialization method that will delegate actual output to
     * configured
     * {@link BeanPropertyWriter} instances.
     */
@Override
public final void serialize(Object bean, JsonGenerator jgen, SerializerProvider provider) throws IOException, JsonGenerationException {
    // [JACKSON-805]
    if (provider.isEnabled(SerializationFeature.WRITE_SINGLE_ELEM_ARRAYS_UNWRAPPED) && hasSingleElement(provider)) {
        serializeAsArray(bean, jgen, provider);
        return;
    }
    /* note: it is assumed here that limitations (type id, object id,
         * any getter, filtering) have already been checked; so code here
         * is trivial.
         */
    jgen.writeStartArray();
    serializeAsArray(bean, jgen, provider);
    jgen.writeEndArray();
}

@Test
public void testTemplate() throws JsonGenerationException, JsonMappingException, IOException, IllegalArgumentException, IllegalAccessException, InstantiationException {
    Set<Class<?>> classes = Sets.<Class<?>>newHashSet(StackOverflowTemplateSelf.class, StackOverflowTemplateObjectOne.class, StackOverflowTemplateObjectTwo.class);
    StackOverflowTemplateSelf objectSelf = new StackOverflowTemplateSelf();
    Map<String, Object> template = JSONDocTemplateBuilder.build(objectSelf.getClass(), classes);
    System.out.println(mapper.writeValueAsString(template));
    StackOverflowTemplateObjectOne objectOne = new StackOverflowTemplateObjectOne();
    template = JSONDocTemplateBuilder.build(objectOne.getClass(), classes);
    System.out.println(mapper.writeValueAsString(template));
    StackOverflowTemplateObjectTwo objectTwo = new StackOverflowTemplateObjectTwo();
    template = JSONDocTemplateBuilder.build(objectTwo.getClass(), classes);
    System.out.println(mapper.writeValueAsString(template));
}

public String toJSON() {
    ObjectMapper mapper = new ObjectMapper();
    StringWriter sw = new StringWriter();
    String res = null;
    try {
        mapper.writeValue(sw, this);
    } catch (JsonGenerationException e) {
        e.printStackTrace();
    } catch (JsonMappingException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }
    res = sw.toString();
    return res;
}

@Override
public void serialize(final Map<String, String> map, final JsonGenerator jgen, final SerializerProvider provider) throws IOException, JsonGenerationException {
    final Set<Entry<String, String>> entrySet = map.entrySet();
    final MapEntry[] pairs = new MapEntry[entrySet.size()];
    int i = 0;
    for (final Entry<String, String> entry : entrySet) {
        pairs[i++] = new MapEntry(entry.getKey(), entry.getValue());
    }
    jgen.writeObject(pairs);
}

/**
	 * Test method for {@link com.ebiznext.sbt.sample.utils.Utils#jsonOutput(java.lang.Object)}.
	 */
@Test
public void testJsonOutput() {
    try {
        String asJSON = Utils.jsonOutput(Utils.decrypt(TOKEN));
        assertNotNull(asJSON);
        assertEquals(TOKEN_TO_JSON, asJSON);
    } catch (JsonGenerationException e) {
        fail(e.getMessage());
    } catch (JsonMappingException e) {
        fail(e.getMessage());
    } catch (IOException e) {
        fail(e.getMessage());
    }
}

@Override
protected void _writeSimpleObject(Object value) throws IOException, JsonGenerationException {
    if (value instanceof Date) {
        writeDateTime((Date) value);
    } else if (value instanceof Calendar) {
        writeDateTime(((Calendar) value).getTime());
    } else if (value instanceof ObjectId) {
        writeObjectId(ObjectIdConvertor.convert((ObjectId) value));
    } else if (value instanceof DBRef) {
        DBRef dbRef = (DBRef) value;
        writeStartObject();
        writeFieldName("$ref");
        writeString(dbRef.getCollectionName());
        writeFieldName("$id");
        writeObject(dbRef.getId());
        writeEndObject();
    } else {
        super._writeSimpleObject(value);
    }
}

/**
     * Given an object, this method will attempt to serialize it into JSON.
     * @param object Object
     * @return String - Json or empty string if failed.
     */
public static String toJson(Object object) {
    try {
        return jsonMapper.writeValueAsString(object);
    } catch (JsonGenerationException ex) {
        logger.error("Failed to generate json: " + ex.getMessage());
    } catch (JsonMappingException ex) {
        logger.error("Failed to map json: " + ex.getMessage());
    } catch (Exception ex) {
        logger.error("ObjectMapper exception: " + ex.getMessage());
    }
    return "";
}

public void testTable() {
    ObjectMapper mapper = new ObjectMapper();
    Map<String, Map<String, Integer>> t = new HashMap<String, Map<String, Integer>>();
    //		Map<Map<String,String>,String> t2 = new HashMap<Map<String,String>,String>();
    //		
    //		Pair<String,String> test = new ImmutablePair<String, String>("a", "b");
    //		
    //		class Key{
    //			
    //			public Key(String row, String col) {
    //				super();
    //				this.row = row;
    //				this.col = col;
    //			}
    //			private String row;
    //			private String col;
    //			
    //			public String getRow() {
    //				return row;
    //			}
    //			public void setRow(String row) {
    //				this.row = row;
    //			}
    //			public String getCol() {
    //				return col;
    //			}
    //			public void setCol(String col) {
    //				this.col = col;
    //			}
    //			
    //		}
    HashMap<String, Integer> row = new HashMap<String, Integer>();
    row.put("col1", 3);
    row.put("col2", 2);
    row.put("col3", 0);
    t.put("row1", row);
    t.put("row2", row);
    try {
        String value = mapper.writeValueAsString(t);
        System.out.println(value);
    } catch (JsonGenerationException e) {
        e.printStackTrace();
    } catch (JsonMappingException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }
    assertTrue(true);
}

public String formatObject(Object object) throws JsonGenerationException {
    try (ByteArrayOutputStream outputStream = new ByteArrayOutputStream()) {
        JsonGenerator generator = jsonFactory.createGenerator(outputStream);
        generator.writeObject(object);
        return outputStream.toString();
    } catch (IOException e) {
        throw new JsonGenerationException(e);
    }
}

@Test
public void getJson() throws JsonGenerationException, JsonMappingException, IOException {
    Refset r = new Refset();
    r.setUuid("700043003");
    r.setCreated(new DateTime());
    r.setCreatedBy("Junit Refset Editor");
    r.setDescription("GP/FP health issue reference set (foundation metadata concept)");
    Map<String, String> descriptor = new HashMap<String, String>();
    descriptor.put(ID, ID_DESC);
    descriptor.put(MEMBER_ID, MEMBER_ID_DESC);
    descriptor.put(LANGUAGE_CODE, LANGUAGE_CODE_DESC);
    descriptor.put(MODULE_ID, MODULE_ID_DESC);
    descriptor.put(EFFECTIVE_TIME, EFFECTIVE_TIME_DESC);
    descriptor.put(PUBLISHED, PUBLISHED_DESC);
    descriptor.put(PUBLISHED_DATE, PUBLISHED_DATE_DESC);
    descriptor.put(REFSET_SUPER_TYPE_ID, REFSET_SUPER_TYPE_ID_DESC);
    descriptor.put(REFSET_TYPE, REFSET_TYPE_DESC);
    descriptor.put(REFSET_TYPE_ID, REFSET_TYPE_ID_DESC);
    List<Member> members = new ArrayList<Member>();
    Member m = new Member();
    m.setUuid("450451007");
    m.setActive(true);
    m.setReferencedComponentId("4504511107");
    m.setModuleId("900000000000207002");
    members.add(m);
    m = new Member();
    m.setActive(true);
    m.setReferencedComponentId("4504511107");
    m.setModuleId("900000000000207002");
    m.setUuid("450451006");
    members.add(m);
    m = new Member();
    m.setActive(true);
    m.setReferencedComponentId("4504511107");
    m.setModuleId("900000000000207008");
    m.setUuid("450451005");
    members.add(m);
    m = new Member();
    m.setActive(true);
    m.setReferencedComponentId("4504511107");
    m.setModuleId("900000000000207008");
    m.setUuid("450451017");
    members.add(m);
    r.setMembers(members);
    r.setModuleId("900000000000207008");
    r.setLanguageCode("en-GB");
    r.setPublished(true);
    r.setPublishedDate(new DateTime());
    r.setTypeId("5000");
    r.setSuperRefsetTypeId("none");
    ObjectMapper mapper = new ObjectMapper();
    mapper.writeValue(new File("src/test/resources/refset.json"), r);
}

@Override
public void serialize(SecurityPolicy policy, JsonGenerator generator, SerializerProvider provider) throws IOException, JsonGenerationException {
    if (policy == null) {
        generator.writeNull();
        return;
    }
    generator.writeStartObject();
    if (policy.getNodeIds() != null && !policy.getNodeIds().isEmpty()) {
        generator.writeArrayFieldStart("nodeIds");
        // maintain node IDs in natural sort order
        Long[] ids = policy.getNodeIds().toArray(new Long[policy.getNodeIds().size()]);
        Arrays.sort(ids);
        for (Long id : ids) {
            generator.writeNumber(id);
        }
        generator.writeEndArray();
    }
    if (policy.getSourceIds() != null && !policy.getSourceIds().isEmpty()) {
        generator.writeArrayFieldStart("sourceIds");
        for (String id : policy.getSourceIds()) {
            generator.writeString(id);
        }
        generator.writeEndArray();
    }
    Set<Aggregation> aggregations = policy.getAggregations();
    if (policy.getMinAggregation() != null) {
        generator.writeStringField("minAggregation", policy.getMinAggregation().name());
    } else if (aggregations != null && !aggregations.isEmpty()) {
        generator.writeArrayFieldStart("aggregations");
        for (Aggregation val : aggregations) {
            generator.writeString(val.name());
        }
        generator.writeEndArray();
    }
    Set<LocationPrecision> locationPrecisions = policy.getLocationPrecisions();
    if (policy.getMinLocationPrecision() != null) {
        generator.writeStringField("minLocationPrecision", policy.getMinLocationPrecision().name());
    } else if (locationPrecisions != null && !locationPrecisions.isEmpty()) {
        generator.writeArrayFieldStart("locationPrecisions");
        for (LocationPrecision val : locationPrecisions) {
            generator.writeString(val.name());
        }
        generator.writeEndArray();
    }
    Set<String> nodeMetadataPaths = policy.getNodeMetadataPaths();
    if (nodeMetadataPaths != null && !nodeMetadataPaths.isEmpty()) {
        generator.writeArrayFieldStart("nodeMetadataPaths");
        for (String path : nodeMetadataPaths) {
            generator.writeString(path);
        }
        generator.writeEndArray();
    }
    Set<String> userMetadataPaths = policy.getUserMetadataPaths();
    if (userMetadataPaths != null && !userMetadataPaths.isEmpty()) {
        generator.writeArrayFieldStart("userMetadataPaths");
        for (String path : userMetadataPaths) {
            generator.writeString(path);
        }
        generator.writeEndArray();
    }
    generator.writeEndObject();
}

@Override
public void serialize(Datum datum, JsonGenerator generator, SerializerProvider provider) throws IOException, JsonGenerationException {
    generator.writeStartObject();
    generator.writeStringField("__type__", datum.getClass().getSimpleName());
    Map<String, Object> props = ClassUtils.getBeanProperties(datum, null, true);
    for (Map.Entry<String, Object> me : props.entrySet()) {
        Object val = me.getValue();
        if (val instanceof Number) {
            if (val instanceof Integer) {
                generator.writeNumberField(me.getKey(), (Integer) val);
            } else if (val instanceof Long) {
                generator.writeNumberField(me.getKey(), (Long) val);
            } else if (val instanceof Double) {
                generator.writeNumberField(me.getKey(), (Double) val);
            } else if (val instanceof Float) {
                generator.writeNumberField(me.getKey(), (Float) val);
            } else if (val instanceof BigDecimal) {
                generator.writeNumberField(me.getKey(), (BigDecimal) val);
            }
        } else if (val instanceof Date) {
            generator.writeNumberField(me.getKey(), ((Date) val).getTime());
        } else if (val instanceof String) {
            generator.writeStringField(me.getKey(), (String) val);
        }
    }
    generator.writeEndObject();
}

@Test
public void test() {
    Map<String, Object> values = new HashMap<String, Object>();
    values.put("aa", "bb");
    Event e = new Event("aaa", values);
    ObjectMapper mapper = new ObjectMapper();
    try {
        ObjectWriter writer = mapper.writerWithDefaultPrettyPrinter();
        String strValue = writer.writeValueAsString(e);
        System.out.println(strValue);
    } catch (JsonGenerationException e1) {
        e1.printStackTrace();
    } catch (JsonMappingException e1) {
        e1.printStackTrace();
    } catch (IOException e1) {
        e1.printStackTrace();
    }
}

@Override
public void serialize(JsonGenerator generator) throws JsonGenerationException, IOException {
    if (payload instanceof Integer) {
        generator.writeNumber((Integer) payload);
    } else if (payload instanceof Long) {
        generator.writeNumber((Long) payload);
    } else if (payload instanceof Short) {
        generator.writeNumber((Short) payload);
    } else if (payload instanceof Float) {
        generator.writeNumber((Float) payload);
    } else if (payload instanceof Double) {
        generator.writeNumber((Double) payload);
    } else if (payload instanceof Byte) {
        generator.writeNumber((Byte) payload);
    } else if (payload instanceof BigInteger) {
        generator.writeNumber((BigInteger) payload);
    } else if (payload instanceof BigDecimal) {
        generator.writeNumber((BigDecimal) payload);
    }
}

public static void writeValue(ObjectMapper mapper, PrintWriter out, Object data, List<?> errors, Map<String, Object> overwrite) throws JsonGenerationException, JsonMappingException, IOException {
    if (errors != null && errors.size() > 0 || overwrite != null && overwrite.size() > 0) {
        // First create a Map, then append __error__, then make json
        MapType mapType = mapper.getTypeFactory().constructMapType(LinkedHashMap.class, String.class, Object.class);
        LinkedHashMap<String, Object> map = mapper.convertValue(data, mapType);
        if (overwrite != null) {
            for (Map.Entry<String, Object> entry : overwrite.entrySet()) {
                map.put(entry.getKey(), entry.getValue());
            }
        }
        map.put(ERROR_FIELD, errors);
        map.put(HAS_ERROR_FIELD, true);
        mapper.writeValue(out, map);
    } else {
        mapper.writeValue(out, data);
    }
}

@Before
public void init() throws JsonMappingException, JsonGenerationException, IOException {
    final Condition<Boolean> condition = new Condition<Boolean>("appdomain", new Equals("1"), true);
    final Set<Condition<Boolean>> conditions = ImmutableSet.of(condition);
    configuration = new Configuration("express.feature.toggle", "Feature toggle", conditions, Boolean.FALSE);
    StringWriter writer = new StringWriter();
    mapper.writeValue(writer, configuration);
    buffer = writer.toString();
}

/**
	 * Test the serialization from  Java Objects to JSON
	 * @throws IOException 
	 * @throws JsonMappingException 
	 * @throws JsonGenerationException 
	 */
@org.junit.Test
public void testSerialToJson() throws JsonGenerationException, JsonMappingException, IOException {
    final List<RunningQuery> rQueriesOrig = deserialize(rQueryJson);
    final List<RunningQuery> rQueriesDeserial;
    final StringWriter sw = new StringWriter();
    JsonHelper.writeRunningQueryList(sw, rQueriesOrig);
    final String jsonResult = sw.toString();
    assert (jsonResult != null);
    rQueriesDeserial = deserialize(jsonResult);
    final Iterator<RunningQuery> it1 = rQueriesOrig.iterator();
    final Iterator<RunningQuery> it2 = rQueriesDeserial.iterator();
    while (it1.hasNext() && it2.hasNext()) {
        final RunningQuery r1 = it1.next();
        final RunningQuery r2 = it2.next();
        assertEquals(r1.getBegin(), r2.getBegin());
        assertEquals(r1.getQueryUuid(), r2.getQueryUuid());
        assertEquals(r1.getExtQueryId(), r2.getExtQueryId());
    }
    //They should have the same number of elements
    assert (!it1.hasNext());
    assert (!it2.hasNext());
}

public static void write(OutputStream out, Measurement measurement) {
    ObjectMapper mapper = new ObjectMapper();
    try {
        mapper.writeValue(out, measurement);
    } catch (JsonGenerationException e) {
        e.printStackTrace();
    } catch (JsonMappingException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

@Override
public void serialize(Object value, JsonGenerator jgen, SerializerProvider provider) throws IOException {
    try {
        String[] a = (String[]) value;
        final int length = a.length;
        // construct a string of form value1;value2;...
        final StringBuilder buffer = new StringBuilder();
        for (int i = 0; i < length; i++) {
            buffer.append(a[i].trim());
            if (i < (length - 1)) {
                buffer.append(';');
            }
        }
        jgen.writeString(buffer.toString());
    } catch (Exception e) {
        throw new JsonGenerationException(String.format("Exception writing pick list value %s of type %s: %s", value, value.getClass().getName(), e.getMessage()), jgen);
    }
}

private final void writeValue(final Class<?> type, Object value, JsonGenerator jgen) throws JsonGenerationException, IOException {
    if (type == String.class) {
        jgen.writeString(value.toString());
    } else if (type == Boolean.class) {
        jgen.writeBoolean((Boolean) value);
    } else if (type == Double.class) {
        jgen.writeNumber((Double) value);
    } else if (type == Integer.class) {
        jgen.writeNumber((Integer) value);
    } else if (type == Long.class) {
        jgen.writeNumber((Long) value);
    } else if (type == Float.class) {
        jgen.writeNumber((Double) value);
    }
}

private final void writeValue(final Class<?> type, Object value, JsonGenerator jgen) throws JsonGenerationException, IOException {
    if (type == String.class) {
        jgen.writeString(value.toString());
    } else if (type == Boolean.class) {
        jgen.writeBoolean((Boolean) value);
    } else if (type == Double.class) {
        jgen.writeNumber((Double) value);
    } else if (type == Integer.class) {
        jgen.writeNumber((Integer) value);
    } else if (type == Long.class) {
        jgen.writeNumber((Long) value);
    } else if (type == Float.class) {
        jgen.writeNumber((Double) value);
    }
}

/**
	 * Test the serialization from  Java Objects to JSON
	 * @throws IOException 
	 * @throws JsonMappingException 
	 * @throws JsonGenerationException 
	 */
@org.junit.Test
public void testSerialToJson() throws JsonGenerationException, JsonMappingException, IOException {
    final List<RunningQuery> rQueriesOrig = deserialize(rQueryJson);
    final List<RunningQuery> rQueriesDeserial;
    final StringWriter sw = new StringWriter();
    JsonHelper.writeRunningQueryList(sw, rQueriesOrig);
    final String jsonResult = sw.toString();
    assert (jsonResult != null);
    rQueriesDeserial = deserialize(jsonResult);
    final Iterator<RunningQuery> it1 = rQueriesOrig.iterator();
    final Iterator<RunningQuery> it2 = rQueriesDeserial.iterator();
    while (it1.hasNext() && it2.hasNext()) {
        final RunningQuery r1 = it1.next();
        final RunningQuery r2 = it2.next();
        assertEquals(r1.getBegin(), r2.getBegin());
        assertEquals(r1.getQueryUuid(), r2.getQueryUuid());
        assertEquals(r1.getExtQueryId(), r2.getExtQueryId());
    }
    //They should have the same number of elements
    assert (!it1.hasNext());
    assert (!it2.hasNext());
}

@RequestMapping(method = RequestMethod.POST, value = "/changeConfig", produces = "application/json", consumes = "application/json")
@ResponseBody
public SonarConfig changeConfig(@RequestBody final SonarConfig newSonarConfig) throws ConfigurationException, JsonGenerationException, JsonMappingException, IOException {
    String password;
    if (StringUtils.isEmpty(newSonarConfig.getActualPassword())) {
        password = sonarConfig.getActualPassword();
    } else {
        password = newSonarConfig.getActualPassword();
    }
    sonarConfig.replaceWith(newSonarConfig);
    sonarConfig.setUsername(newSonarConfig.getUsername());
    sonarConfig.setPassword(password);
    sonarJsonConfigService.saveConfigFile(sonarConfig);
    return sonarConfig;
}

@Test
public void testTypescriptGenerate() throws JsonGenerationException, JsonMappingException, IOException {
    ServiceDescriptorGenerator descGen = new ServiceDescriptorGenerator(Collections.singletonList(PeopleRestService.class));
    ObjectMapper mapper = new ObjectMapper();
    SimpleModule module = new SimpleModule("custom-mapping");
    mapper.registerModule(module);
    Module tsModule = descGen.generateTypeScript("modName");
    tsModule.write(out);
}

/**
     * Convert object to json. If object contains fields of type date, they will
     * be converted to strings using lightblue date format.
     *
     * @param obj
     * @return
     */
public static String toJson(Object obj) {
    StringWriter sw = new StringWriter();
    ObjectMapper mapper = getDefaultObjectMapper();
    try {
        JsonGenerator jg = mapper.getFactory().createGenerator(sw);
        mapper.writeValue(jg, obj);
    } catch (JsonMappingException e) {
        e.printStackTrace();
    } catch (JsonGenerationException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }
    return sw.toString();
}

@Test
public void testWriteState2() throws JsonGenerationException, JsonMappingException, IOException {
    FileState state1 = new FileState();
    state1.setDirectory("/directory1");
    state1.setFileName("file1");
    state1.setPointer(1234);
    state1.setSignature(123456);
    state1.setSignatureLength(135);
    FileState state2 = new FileState();
    state2.setDirectory("/directory2");
    state2.setFileName("file2");
    state2.setPointer(4321);
    state2.setSignature(654321);
    state2.setSignatureLength(531);
    List<FileState> stateList = new ArrayList<FileState>(2);
    stateList.add(state1);
    stateList.add(state2);
    File file = new File("state2.json");
    logger.debug("Writing to file : " + file.getCanonicalPath());
    Registrar.writeStateToJson(file, stateList);
}

public static String dump(CouchProxy client, File file, boolean omitTimestamp) {
    List<String> docIds = client.getAllDocIds();
    System.out.println("alldoc keys:" + docIds.toString());
    try {
        file.createNewFile();
    } catch (IOException e) {
        e.printStackTrace();
    }
    Indicator indicator = new Indicator(docIds.size());
    int unit = 500;
    int turn = docIds.size() / unit;
    System.out.println("Writing to " + file.getAbsolutePath() + " ...");
    for (int i = 0; i <= turn; i++) {
        int toIndex = (unit * (i + 1) > docIds.size()) ? docIds.size() : unit * (i + 1);
        List<String> keys = docIds.subList(i * unit, toIndex);
        System.out.println("subsystem keys:" + keys.toString());
        List<ObjectNode> results = client.getDocs(keys);
        List<Entry> entries = new ArrayList<Entry>();
        for (ObjectNode document : results) {
            Entry entry = new Entry();
            entry.setDocument(document);
            entry.setAttachments(client.getAttachments(document));
            entries.add(entry);
            indicator.indicate();
        }
        try {
            new ObjectMapper().writerWithDefaultPrettyPrinter().writeValue(new FileOutputStream(file, true), entries);
        } catch (JsonGenerationException e) {
            e.printStackTrace();
        } catch (JsonMappingException e) {
            e.printStackTrace();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    return file.getAbsolutePath();
}

@SuppressWarnings("deprecation")
@Override
public void serialize(Date date, JsonGenerator gen, SerializerProvider provider) throws JsonGenerationException, IOException {
    gen.writeStartObject();
    gen.writeNumberField("date", date.getDate());
    gen.writeNumberField("day", date.getDay());
    gen.writeNumberField("hours", date.getHours());
    gen.writeNumberField("minutes", date.getMinutes());
    gen.writeNumberField("month", date.getMonth());
    gen.writeNumberField("seconds", date.getSeconds());
    gen.writeNumberField("time", date.getTime());
    gen.writeNumberField("timezoneOffset", date.getTimezoneOffset());
    gen.writeNumberField("year", date.getYear());
    gen.writeEndObject();
}

public static String toJson(List<String> tags) {
    ObjectMapper objectMapper = new ObjectMapper();
    ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
    SiteTags siteTags = new SiteTags();
    siteTags.setTags(tags);
    try {
        objectMapper.writeValue(outputStream, siteTags);
    } catch (JsonGenerationException e) {
        throw new ARException(e.getMessage(), e);
    } catch (JsonMappingException e) {
        throw new ARException(e.getMessage(), e);
    } catch (IOException e) {
        throw new ARException(e.getMessage(), e);
    }
    return outputStream.toString();
}

@Override
public void serialize(final AuthenticationConfiguration value, final JsonGenerator jgen, final SerializerProvider provider) throws IOException {
    jgen.writeStartObject();
    jgen.writeStringField("type", value.getType());
    if (value instanceof UsernameAuthenticationConfiguration) {
        UsernameAuthenticationConfiguration upc = (UsernameAuthenticationConfiguration) value;
        jgen.writeStringField("username", upc.getUsername());
        jgen.writeStringField("password", passwordHelper.encrypt(upc.getPassword()));
    } else if (value instanceof NtlmAuthenticationConfiguration) {
        NtlmAuthenticationConfiguration ntc = (NtlmAuthenticationConfiguration) value;
        jgen.writeStringField("username", ntc.getUsername());
        jgen.writeStringField("password", passwordHelper.encrypt(ntc.getPassword()));
        jgen.writeStringField("domain", ntc.getDomain());
        jgen.writeStringField("host", ntc.getHost());
    } else {
        // be foolproof, if new type added but this class is not updated
        throw new JsonGenerationException("Unsupported type:" + value.getClass().getName());
    }
    jgen.writeEndObject();
}

@Deprecated
public String parseToJson(T elements) throws JAXBException {
    ObjectMapper mapper = new ObjectMapper();
    mapper.setSerializationInclusion(Include.NON_EMPTY);
    String guaranteeTermsString = null;
    try {
        guaranteeTermsString = mapper.writeValueAsString(elements);
    } catch (JsonGenerationException e) {
        throw new IllegalArgumentException("not valid json");
    } catch (JsonMappingException e) {
        throw new IllegalArgumentException("not valid json");
    } catch (IOException e) {
        throw new IllegalArgumentException("not valid json");
    }
    return guaranteeTermsString;
}

@Test
public void testOutput() throws JsonGenerationException, JsonMappingException, IOException {
    List<MetaGroup> groupList = new ArrayList<MetaGroup>();
    MetaGroup itemGrpA = new MetaGroup();
    itemGrpA.setGroup("basic");
    List<MetaItem> metaList = new ArrayList<MetaItem>();
    MetaItem meta = new MetaItem();
    meta.setName("author");
    meta.setType("text");
    meta.setDirective("input");
    meta.setMinLength(1);
    metaList.add(meta);
    itemGrpA.setMetaList(metaList);
    groupList.add(itemGrpA);
    MetaGroup itemGrpB = new MetaGroup();
    itemGrpB.setGroup("sourceData");
    List<MetaItem> metaListB = new ArrayList<MetaItem>();
    MetaItem metaB = new MetaItem();
    metaB.setName("dataPath");
    metaB.setType("text");
    metaB.setDirective("input");
    metaB.setMinLength(1);
    metaListB.add(metaB);
    itemGrpB.setMetaList(metaListB);
    groupList.add(itemGrpB);
    File file = new File("test-meta.json");
    jsonMapper.writerWithDefaultPrettyPrinter().writeValue(file, groupList);
    MetaGroup[] ga = jsonMapper.readValue(file, MetaGroup[].class);
    Assert.assertEquals(groupList.size(), ga.length);
    file.deleteOnExit();
}

/**
     * @param <T>  泛型声明
     * @param bean 类的实例
     * @return JSON字符串
     */
@Override
public <T> String toJson(T bean) {
    StringWriter sw = new StringWriter();
    try {
        JsonGenerator gen = new JsonFactory().createJsonGenerator(sw);
        mapper.writeValue(gen, bean);
        gen.close();
        return sw.toString();
    } catch (JsonGenerationException e) {
        throw new RuntimeException(e.getMessage(), e);
    } catch (JsonMappingException e) {
        throw new RuntimeException(e.getMessage(), e);
    } catch (IOException e) {
        throw new RuntimeException(e.getMessage(), e);
    }
}

@Override
public String toString() {
    ObjectMapper mapper = new ObjectMapper();
    try {
        return mapper.writeValueAsString(this);
    } catch (JsonGenerationException e) {
        throw new IllegalStateException(e);
    } catch (JsonMappingException e) {
        throw new IllegalStateException(e);
    } catch (IOException e) {
        throw new IllegalStateException(e);
    }
}

protected Path createRecord(String name, TemplateFieldConfiguration... fields) throws IOException, JsonGenerationException, JsonMappingException {
    Path definitionFile = Files.createTempFile(tempDirectory, AbstractRecordAnnotatorTest.class.getSimpleName(), ".yml");
    String precedingPath = "Paragraph:nth-of-type(1)";
    String followingPath = "Paragraph:nth-of-type(5)";
    TemplateRecordConfiguration recordDefinition = new TemplateRecordConfiguration(name, precedingPath, followingPath, Arrays.asList(fields), 0);
    YAMLMAPPER.writeValue(definitionFile.toFile(), singleton(recordDefinition));
    return definitionFile;
}

@Test
public void testJSONToDataDTOTranslation() throws JsonGenerationException, JsonMappingException, IOException {
    String json = "{\"data\":[{\"id\":1,\"quantity\":1,\"groupOperator\":\"AND\",\"groups\":[{\"id\":null,\"quantity\":null,\"groupOperator\":null,\"groups\":[],\"name\":\"category.name\",\"operator\":\"IEQUALS\",\"value\":\"merchandise\"}]}]}";
    DataWrapper expected = new DataWrapper();
    DataDTO leftSide = new DataDTO();
    leftSide.setId(1l);
    leftSide.setQuantity(1);
    leftSide.setGroupOperator("AND");
    ExpressionDTO rightSide = new ExpressionDTO();
    rightSide.setName("category.name");
    rightSide.setOperator("IEQUALS");
    rightSide.setValue("merchandise");
    leftSide.setGroups(new ArrayList<DataDTO>(Arrays.asList((DataDTO) rightSide)));
    expected.setData(new ArrayList<DataDTO>(Arrays.asList(leftSide)));
    RuleFieldExtractionUtility extractor = new RuleFieldExtractionUtility();
    DataWrapper wrapper = extractor.convertJsonToDataWrapper(json);
    assertEquals(expected, wrapper);
    // This JSON is slightly different than the JSON above since it contains the full serialization result of an ExpressionDTO
    // (as opposed to the excluded nulls above)
    String expectedJson = "{\"data\":[{\"id\":1,\"quantity\":1,\"groupOperator\":\"AND\",\"groups\":[{\"id\":null,\"quantity\":null,\"groupOperator\":null,\"groups\":[],\"name\":\"category.name\",\"operator\":\"IEQUALS\",\"value\":\"merchandise\",\"start\":null,\"end\":null}]}],\"error\":null,\"rawMvel\":null}";
    String serializedWrapperJson = wrapper.serialize();
    assertEquals(expectedJson, serializedWrapperJson);
    // ensure that serialized can go back to the original data wrapper
    DataWrapper serializedWrapper = extractor.convertJsonToDataWrapper(serializedWrapperJson);
    assertEquals(expected, serializedWrapper);
}

@Test
public void testJSONToDataDTOTranslation() throws JsonGenerationException, JsonMappingException, IOException {
    String json = "{\"data\":[{\"id\":1,\"quantity\":1,\"groupOperator\":\"AND\",\"groups\":[{\"id\":null,\"quantity\":null,\"groupOperator\":null,\"groups\":[],\"name\":\"category.name\",\"operator\":\"IEQUALS\",\"value\":\"merchandise\"}]}]}";
    DataWrapper expected = new DataWrapper();
    DataDTO leftSide = new DataDTO();
    leftSide.setId(1l);
    leftSide.setQuantity(1);
    leftSide.setGroupOperator("AND");
    ExpressionDTO rightSide = new ExpressionDTO();
    rightSide.setName("category.name");
    rightSide.setOperator("IEQUALS");
    rightSide.setValue("merchandise");
    leftSide.setGroups(new ArrayList<DataDTO>(Arrays.asList((DataDTO) rightSide)));
    expected.setData(new ArrayList<DataDTO>(Arrays.asList(leftSide)));
    RuleFieldExtractionUtility extractor = new RuleFieldExtractionUtility();
    DataWrapper wrapper = extractor.convertJsonToDataWrapper(json);
    assertEquals(expected, wrapper);
    // This JSON is slightly different than the JSON above since it contains the full serialization result of an ExpressionDTO
    // (as opposed to the excluded nulls above)
    String expectedJson = "{\"data\":[{\"id\":1,\"quantity\":1,\"groupOperator\":\"AND\",\"groups\":[{\"id\":null,\"quantity\":null,\"groupOperator\":null,\"groups\":[],\"name\":\"category.name\",\"operator\":\"IEQUALS\",\"value\":\"merchandise\",\"start\":null,\"end\":null}]}],\"error\":null,\"rawMvel\":null}";
    String serializedWrapperJson = wrapper.serialize();
    assertEquals(expectedJson, serializedWrapperJson);
    // ensure that serialized can go back to the original data wrapper
    DataWrapper serializedWrapper = extractor.convertJsonToDataWrapper(serializedWrapperJson);
    assertEquals(expected, serializedWrapper);
}

/**
	 * The result should be an Object that gets converted into JSON Return value is :
	 * {"items":[
	 * {"id":1,"description":"description","name":"name","price":1.00},{"id":2,"description"
	 * :"description2"
	 * ,"name":"name2","price":2.00}],"purchaseId":"aabf118e-abe9-4b59-88d2-0b897796c8c0"}
	 */
@Test
public void testDemonstrateJSON() throws JsonGenerationException, JsonMappingException, IOException {
    UserSelections userSelection = new UserSelections();
    String[] selections = { "1", "2" };
    userSelection.setSelection(Arrays.asList(selections));
    Item item1 = Item.getInstance(1, "name", "description", new BigDecimal("1.00"));
    when(catalogue.findItem(1)).thenReturn(item1);
    Item item2 = Item.getInstance(2, "name2", "description2", new BigDecimal("2.00"));
    when(catalogue.findItem(2)).thenReturn(item2);
    OrderForm orderForm = instance.confirmPurchases(userSelection);
    ObjectMapper mapper = new ObjectMapper();
    String result = mapper.writeValueAsString(orderForm);
    System.out.println(result);
}

/**
	 * The result should be an Object that gets converted into JSON Return value is :
	 * {"items":[
	 * {"id":1,"description":"description","name":"name","price":1.00},{"id":2,"description"
	 * :"description2"
	 * ,"name":"name2","price":2.00}],"purchaseId":"aabf118e-abe9-4b59-88d2-0b897796c8c0"}
	 */
@Test
public void testDemonstrateJSON() throws JsonGenerationException, JsonMappingException, IOException {
    UserSelections userSelection = new UserSelections();
    String[] selections = { "1", "2" };
    userSelection.setSelection(Arrays.asList(selections));
    Item item1 = Item.getInstance(1, "name", "description", new BigDecimal("1.00"));
    when(catalogue.findItem(1)).thenReturn(item1);
    Item item2 = Item.getInstance(2, "name2", "description2", new BigDecimal("2.00"));
    when(catalogue.findItem(2)).thenReturn(item2);
    OrderForm orderForm = instance.confirmPurchases(userSelection);
    ObjectMapper mapper = new ObjectMapper();
    String result = mapper.writeValueAsString(orderForm);
    System.out.println(result);
}

@Test
public void logShouldSwallowExceptions() throws JsonProcessingException {
    SystemFragment frag = SystemFragment.empty();
    Mockito.when(analyzerMock.analyzeSystem()).thenReturn(frag);
    Mockito.when(objectMapperMock.writeValueAsString(frag)).thenThrow(Mockito.mock(JsonGenerationException.class));
    logSnitch.log();
    Mockito.verify(analyzerMock).analyzeSystem();
    Mockito.verify(objectMapperMock).writeValueAsString(frag);
}

@Test
@Ignore
public void test() {
    ObjectMapper mapper = new ObjectMapper();
    JaxbAnnotationModule jaxbModule = new JaxbAnnotationModule();
    jaxbModule.setPriority(Priority.SECONDARY);
    mapper.registerModule(jaxbModule);
    mapper.registerModule(new CSJacksonAnnotationModule());
    StringWriter writer = new StringWriter();
    TestVO vo = new TestVO(1000, "name");
    vo.names = new ArrayList<String>();
    vo.names.add("name1");
    vo.names.add("name2");
    vo.values = new HashMap<String, Long>();
    vo.values.put("key1", 1000l);
    vo.values.put("key2", 2000l);
    vo.vo2.name = "testvoname2";
    vo.pods = "abcde";
    try {
        mapper.writeValue(writer, vo);
    } catch (JsonGenerationException e) {
        e.printStackTrace();
    } catch (JsonMappingException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }
    System.out.print(writer.getBuffer().toString());
}

@Test
public void testJSONToDataDTOTranslation() throws JsonGenerationException, JsonMappingException, IOException {
    String json = "{\"data\":[{\"id\":1,\"quantity\":1,\"groupOperator\":\"AND\",\"groups\":[{\"id\":null,\"quantity\":null,\"groupOperator\":null,\"groups\":[],\"name\":\"category.name\",\"operator\":\"IEQUALS\",\"value\":\"merchandise\"}]}]}";
    DataWrapper expected = new DataWrapper();
    DataDTO leftSide = new DataDTO();
    leftSide.setId(1l);
    leftSide.setQuantity(1);
    leftSide.setGroupOperator("AND");
    ExpressionDTO rightSide = new ExpressionDTO();
    rightSide.setName("category.name");
    rightSide.setOperator("IEQUALS");
    rightSide.setValue("merchandise");
    leftSide.setGroups(new ArrayList<DataDTO>(Arrays.asList((DataDTO) rightSide)));
    expected.setData(new ArrayList<DataDTO>(Arrays.asList(leftSide)));
    RuleFieldExtractionUtility extractor = new RuleFieldExtractionUtility();
    DataWrapper wrapper = extractor.convertJsonToDataWrapper(json);
    assertEquals(expected, wrapper);
    // This JSON is slightly different than the JSON above since it contains the full serialization result of an ExpressionDTO
    // (as opposed to the excluded nulls above)
    String expectedJson = "{\"data\":[{\"id\":1,\"quantity\":1,\"groupOperator\":\"AND\",\"groups\":[{\"id\":null,\"quantity\":null,\"groupOperator\":null,\"groups\":[],\"name\":\"category.name\",\"operator\":\"IEQUALS\",\"value\":\"merchandise\",\"start\":null,\"end\":null}]}],\"error\":null,\"rawMvel\":null}";
    String serializedWrapperJson = wrapper.serialize();
    assertEquals(expectedJson, serializedWrapperJson);
    // ensure that serialized can go back to the original data wrapper
    DataWrapper serializedWrapper = extractor.convertJsonToDataWrapper(serializedWrapperJson);
    assertEquals(expected, serializedWrapper);
}

@Override
protected void configure() {
    bind(new TypeLiteral<JsonSerializer<UUID>>() {
    }).toInstance(new CustomUuidSerializer() {

        @Override
        public void serialize(UUID value, JsonGenerator jgen, SerializerProvider provider) throws IOException, JsonGenerationException {
            called.set(true);
            super.serialize(value, jgen, provider);
        }
    });
}

@Override
public Response toResponse(JsonProcessingException exception) {
    /*
         * If the error is in the JSON generation, it's a server error.
         */
    if (exception instanceof JsonGenerationException) {
        // LoggingExceptionMapper will log exception
        return super.toResponse(exception);
    }
    final String message = exception.getOriginalMessage();
    /*
         * If we can't deserialize the JSON because someone forgot a no-arg
         * constructor, or it is not known how to serialize the type it's
         * a server error and we should inform the developer.
         */
    if (exception instanceof JsonMappingException) {
        final JsonMappingException ex = (JsonMappingException) exception;
        final Throwable cause = Throwables.getRootCause(ex);
        // Exceptions that denote an error on the client side
        final boolean clientCause = cause instanceof InvalidFormatException || cause instanceof PropertyBindingException;
        // Until completely foolproof mechanism can be worked out in coordination
        // with Jackson on how to communicate client vs server fault, compare
        // start of message with known server faults.
        final boolean beanError = cause.getMessage() == null || (cause.getMessage().startsWith("No suitable constructor found") || cause.getMessage().startsWith("No serializer found for class") || (cause.getMessage().startsWith("Can not construct instance") && !WRONG_TYPE_REGEX.matcher(cause.getMessage()).find()));
        if (beanError && !clientCause) {
            // LoggingExceptionMapper will log exception
            return super.toResponse(exception);
        }
    }
    /*
         * Otherwise, it's those pesky users.
         */
    LOGGER.debug("Unable to process JSON", exception);
    final ErrorMessage errorMessage = new ErrorMessage(Response.Status.BAD_REQUEST.getStatusCode(), "Unable to process JSON", showDetails ? message : null);
    return Response.status(Response.Status.BAD_REQUEST).type(MediaType.APPLICATION_JSON_TYPE).entity(errorMessage).build();
}

@Test
public void writeValueAsStringWithNullScope() throws JsonGenerationException, JsonMappingException, IOException {
    thrown.expect(JsonMappingException.class);
    thrown.expectMessage("Scopes cannot be null or empty. Got [null]");
    accessToken.getScope().clear();
    try {
        accessToken.getScope().add(null);
    } catch (NullPointerException e) {
        throw new JsonMappingException("Scopes cannot be null or empty. Got [null]");
    }
    mapper.writeValueAsString(accessToken);
}

private String tripleAsJsonLd(RdfTriple triple) throws JsonGenerationException, IOException {
    Map<String, Object> jsonValue = new HashMap<String, Object>();
    jsonValue.put("@id", triple.getSubject());
    List<Object> objectValues = new ArrayList<Object>();
    if (triple.isLiteral() || triple.getPredicate().equals("@type")) {
        objectValues.add(triple.getObject());
    } else {
        Map<String, Object> valueObject = new HashMap<String, Object>();
        valueObject.put("@id", triple.getObject());
        objectValues.add(valueObject);
    }
    jsonValue.put(triple.getPredicate(), objectValues);
    return JsonUtils.toString(jsonValue);
}

private AuditLog getAuditLog(DescriptorEvent event, String action) throws IllegalAccessException, IllegalArgumentException, SecurityException, JsonGenerationException, JsonMappingException, IOException {
    AuditLog auditLog = new AuditLog();
    auditLog.setEntityType(event.getObject().getClass().getSimpleName());
    AuditTableData auditTableData = getTableData(event);
    if (auditTableData.getColumns().size() > 0) {
        auditLog.setData(mapper.writeValueAsString(auditTableData));
        auditLog.setEntityId(getPrimaryKey(event));
        auditLog.setAction(action);
        return auditLog;
    } else {
        log.info("No Columns changed. Returning null");
        return null;
    }
}

@Override
public void serialize(T meta, JsonGenerator json, SerializerProvider serializerProvider) throws IOException, JsonGenerationException {
    json.writeStartObject();
    json.writeStringField(IInfo.JSON_PROPERTY_CLASS, meta.getClass().getName());
    json.writeStringField(IInfo.JSON_PROPERTY_NAME, meta.getName());
    json.writeStringField(IInfo.JSON_PROPERTY_DESCRIPTION, meta.getDescription());
    json.writeObjectField(JSON_PROPERTY_CREATED_DATE, meta.getCreatedDate());
    json.writeObjectField(JSON_PROPERTY_LAST_MODIFIED_DATE, meta.getModifiedDate());
    json.writeStringField(JSON_PROPERTY_CREATED_BY, meta.getCreatedUser());
    json.writeStringField(JSON_PROPERTY_LAST_MODIFIED_BY, meta.getModifiedUser());
    json.writeStringField(JSON_PROPERTY_PATH, meta.getFilename());
    if (meta.getRepository() != null) {
        json.writeStringField(JSON_PROPERTY_REPOSITORY, meta.getRepository().getName());
    }
    serializeParameters(meta, json);
    serializeVariables(meta, json);
    serializeSteps(meta, json);
    serializeConnections(meta, json);
    serializeHops(meta, json);
    json.writeEndObject();
}

@RequestMapping(value = FoUrls.CONTEXT_URL)
public ModelAndView context(final HttpServletRequest request, final HttpServletResponse response, final Model model) throws Exception {
    ModelAndViewThemeDevice modelAndView = new ModelAndViewThemeDevice(getCurrentVelocityPath(request), FoUrls.CONTEXT.getVelocityPage());
    final RequestData requestData = requestUtil.getRequestData(request);
    final VelocityPageContextDataPojo context = buildContext(requestData);
    ObjectMapper mapper = new ObjectMapper();
    try {
        String contextJson = mapper.writeValueAsString(context);
        model.addAttribute(ModelConstants.CONTEXT_JSON, contextJson);
    } catch (JsonGenerationException e) {
        logger.error(e.getMessage());
    } catch (JsonMappingException e) {
        logger.error(e.getMessage());
    } catch (IOException e) {
        logger.error(e.getMessage());
    }
    response.addHeader("Content-Type", "application/javascript;charset=UTF-8");
    return modelAndView;
}

public static String transformToJson(Object bean) throws SavingEditorException {
    String result = null;
    try {
        ObjectMapper mapper = new ObjectMapper();
        //This option exclude object with null value from the serialization
        mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
        //mapper.writeValueAsString(bean);
        result = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(bean);
    } catch (JsonGenerationException e) {
        e.printStackTrace();
    } catch (JsonMappingException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }
    return result;
}

@Test
public void writeValueAsStringWithNullScope() throws JsonGenerationException, JsonMappingException, IOException {
    thrown.expect(JsonMappingException.class);
    thrown.expectMessage("Scopes cannot be null or empty. Got [null]");
    accessToken.getScope().clear();
    try {
        accessToken.getScope().add(null);
    } catch (NullPointerException e) {
        throw new JsonMappingException("Scopes cannot be null or empty. Got [null]");
    }
    mapper.writeValueAsString(accessToken);
}

@Override
public Response toResponse(JsonProcessingException exception) {
    /*
         * If the error is in the JSON generation, it's a server error.
         */
    if (exception instanceof JsonGenerationException) {
        // LoggingExceptionMapper will log exception
        return super.toResponse(exception);
    }
    final String message = exception.getOriginalMessage();
    /*
         * If we can't deserialize the JSON because someone forgot a no-arg
         * constructor, or it is not known how to serialize the type it's
         * a server error and we should inform the developer.
         */
    if (exception instanceof JsonMappingException) {
        final JsonMappingException ex = (JsonMappingException) exception;
        final Throwable cause = Throwables.getRootCause(ex);
        // Exceptions that denote an error on the client side
        final boolean clientCause = cause instanceof InvalidFormatException || cause instanceof PropertyBindingException;
        // Until completely foolproof mechanism can be worked out in coordination
        // with Jackson on how to communicate client vs server fault, compare
        // start of message with known server faults.
        final boolean beanError = cause.getMessage() == null || (cause.getMessage().startsWith("No suitable constructor found") || cause.getMessage().startsWith("No serializer found for class") || (cause.getMessage().startsWith("Can not construct instance") && !WRONG_TYPE_REGEX.matcher(cause.getMessage()).find()));
        if (beanError && !clientCause) {
            // LoggingExceptionMapper will log exception
            return super.toResponse(exception);
        }
    }
    /*
         * Otherwise, it's those pesky users.
         */
    LOGGER.debug("Unable to process JSON", exception);
    final ErrorMessage errorMessage = new ErrorMessage(Response.Status.BAD_REQUEST.getStatusCode(), "Unable to process JSON", showDetails ? message : null);
    return Response.status(Response.Status.BAD_REQUEST).type(MediaType.APPLICATION_JSON_TYPE).entity(errorMessage).build();
}

@Override
public void serializeContents(Object value, JsonGenerator jgen, SerializerProvider provider) throws IOException, JsonGenerationException {
    JsonPropertyOrder order = value.getClass().getAnnotation(JsonPropertyOrder.class);
    String[] propOrder = (order == null) ? null : order.value();
    if (propOrder == null) {
        throw new IllegalStateException("Bean must declare JsonPropertyOrder!");
    }
    if (propOrder.length == 0) {
        return;
    }
    int i = 0;
    try {
        do {
            Field field = value.getClass().getDeclaredField(propOrder[i]);
            ReflectionUtils.makeAccessible(field);
            Object elem = field.get(value);
            if (elem == null) {
                provider.defaultSerializeNull(jgen);
            } else {
                Class<?> cc = elem.getClass();
                JsonSerializer<Object> serializer = provider.findValueSerializer(cc, null);
                serializer.serialize(elem, jgen, provider);
            }
            ++i;
        } while (i < propOrder.length);
    } catch (Exception e) {
        wrapAndThrow(provider, e, value, i);
    }
}

private TelekomJsonWebRequest createAuthenticatedJsonRequest(String uri, SendSmsRequest request) throws JsonGenerationException, JsonMappingException, IOException {
    TelekomJsonWebRequest webRequest = createAuthenticatedRequest(uri, HttpMethod.POST);
    HashMap<String, HashMap<String, Object>> jsonRequest = new HashMap<String, HashMap<String, Object>>();
    HashMap<String, Object> val = new HashMap<String, Object>();
    val.put("address", request.getAddress());
    HashMap<String, Object> helper = new HashMap<String, Object>();
    String key = "";
    String key2 = "";
    if (request.getType().equals(OutboundSMSType.TEXT)) {
        key = "outboundSMSTextMessage";
        key2 = "message";
    } else if (request.getType().equals(OutboundSMSType.BINARY)) {
        key = "outboundSMSBinaryMessage";
        key2 = "message";
    } else if (request.getType().equals(OutboundSMSType.FLASH)) {
        key = "outboundSMSFlashMessage";
        key2 = "flashMessage";
    }
    helper.put(key2, request.getMessage());
    val.put(key, helper);
    val.put("senderAddress", request.getSenderAddress());
    if (request.getSenderName() != null) {
        val.put("senderName", request.getSenderName());
    }
    if (request.getAccount() != null) {
        val.put("account", request.getAccount());
    }
    helper = new HashMap<String, Object>();
    if (request.getCallbackData() != null) {
        helper.put("callbackData", request.getCallbackData());
    }
    if (request.getNotifyURL() != null) {
        helper.put("notifyURL", request.getNotifyURL());
    }
    val.put("receiptRequest", helper);
    if (request.getEncoding() != null) {
        if (request.getEncoding().equals(OutboundEncoding.GSM)) {
            val.put("outboundEncoding", "7bitGSM");
        } else if (request.getEncoding().equals(OutboundEncoding.UCS)) {
            val.put("outboundEncoding", "16bitUCS2");
        }
    }
    if (request.getClientCorrelator() != null) {
        val.put("clientCorrelator", request.getClientCorrelator());
    }
    jsonRequest.put("outboundSMSMessageRequest", val);
    webRequest.setRawContent(JsonSerializer.serializeToBytes(jsonRequest), "application/json; charset=utf-8");
    return webRequest;
}

private void writeFilesFromDir(JsonGenerator json, Path path, File f) throws JsonGenerationException, IOException {
    if (!f.isDirectory()) {
        log.warn("Supposed to list all files from '{}' but it's not a directory", f);
        return;
    }
    //all this complicated stack in order to not write empty directories and not have an intermediate tree to store the result
    File[] files = f.listFiles();
    for (File f1 : files) {
        if (f1.isDirectory()) {
            path.push(f1.getName());
            writeFilesFromDir(json, path, f1);
            path.pop();
        } else if (f1.getName().endsWith(".uss")) {
            if (path.index < path.size()) {
                while (path.index < path.size()) {
                    json.writeStartArray();
                    json.writeString(path.get(path.index));
                    path.index++;
                }
            }
            json.writeString(f1.getName());
        }
    }
    while (path.index >= path.size()) {
        json.writeEndArray();
        path.index--;
    }
}

@Override
public void serialize(final String str, final JsonGenerator gen, final SerializerProvider provider) throws IOException {
    final int status = ((JsonWriteContext) gen.getOutputContext()).writeValue();
    switch(status) {
        case JsonWriteContext.STATUS_OK_AFTER_COLON:
            gen.writeRaw(':');
            break;
        case JsonWriteContext.STATUS_OK_AFTER_COMMA:
            gen.writeRaw(',');
            break;
        case JsonWriteContext.STATUS_EXPECT_NAME:
            throw new JsonGenerationException("Can not write string value here");
    }
    gen.writeRaw('"');
    for (char c : str.toCharArray()) {
        if (c >= 0x80) {
            writeUnicodeEscape(gen, c);
        } else {
            int code = c < ESCAPE_CODES.length ? ESCAPE_CODES[c] : 0;
            if (code == 0) {
                gen.writeRaw(c);
            } else if (code == -1) {
                writeUnicodeEscape(gen, c);
            } else {
                writeShortEscape(gen, (char) code);
            }
        }
    }
    gen.writeRaw('"');
}

public static String toJsonString(Object obj) {
    try {
        return mapper.writeValueAsString(obj);
    } catch (JsonGenerationException e) {
        throw new ClientException("Unable to generate json", e);
    } catch (JsonMappingException e) {
        throw new ClientException("Unable to map json", e);
    } catch (IOException e) {
        throw new ClientException("IO error", e);
    }
}

@Override
public void serialize(String str, JsonGenerator gen, SerializerProvider provider) throws IOException {
    int status = ((JsonWriteContext) gen.getOutputContext()).writeValue();
    switch(status) {
        case JsonWriteContext.STATUS_OK_AFTER_COLON:
            gen.writeRaw(':');
            break;
        case JsonWriteContext.STATUS_OK_AFTER_COMMA:
            gen.writeRaw(',');
            break;
        case JsonWriteContext.STATUS_EXPECT_NAME:
            throw new JsonGenerationException("Can not write string value here");
    }
    gen.writeRaw('"');
    for (char c : str.toCharArray()) {
        if (c >= 0x80)
            writeUnicodeEscape(gen, c);
        else {
            int code = (c < ESCAPE_CODES.length ? ESCAPE_CODES[c] : 0);
            if (code == 0)
                gen.writeRaw(c);
            else if (code == -1)
                writeUnicodeEscape(gen, c);
            else
                writeShortEscape(gen, (char) code);
        }
    }
    gen.writeRaw('"');
}

public void serialize(JsonGenerator jgen, BeakerObjectConverter boc) throws JsonGenerationException, IOException {
    jgen.writeStartObject();
    if (theStyle != null)
        jgen.writeStringField("thestyle", theStyle);
    if (theClass != null)
        jgen.writeStringField("theclass", theClass);
    jgen.writeArrayFieldStart("cols");
    for (dashColumn r : payload) r.serialize(jgen, boc);
    jgen.writeEndArray();
    jgen.writeEndObject();
}

private boolean sendMessage(String message) {
    StringWriter sr = new StringWriter();
    try {
        objectMapper.writeValue(sr, message);
        Message msg = factory.createMessage();
        msg.setBuffer(sr.toString().replaceAll("\"", "").getBytes());
        idmPublisher.publish(msg);
        return true;
    } catch (CSBException e) {
        LOG.error("pub sub unable to send a message. Topic: " + idmtopic + " value " + sr.toString());
    } catch (JsonGenerationException e1) {
        LOG.error("Unable to convert to string Map object representation of entity" + e1.getLocalizedMessage());
    } catch (JsonMappingException e1) {
        LOG.error("Unable to convert to string Map object representation of entity" + e1.getLocalizedMessage());
    } catch (IOException e1) {
        LOG.error("Unable to convert to string Map object representation of entity" + e1.getLocalizedMessage());
    }
    return false;
}

@Test
public void testPutCacheException() throws Exception {
    doThrow(new JsonGenerationException("TEST_EXCEPTION")).when(mapper).writeValueAsString(any());
    ActionResponse returnResponse = distributedCache.put("DUMMY_KEY_PUT", null);
    verify(mapper, times(1)).writeValueAsString(any());
    assertNull(returnResponse);
    assertNull(hazelcastInstance.getMap("TEST").get("DUMMY_KEY_PUT"));
}

@Override
protected void serializeFields(Object bean, JsonGenerator jgen, SerializerProvider provider) throws IOException, JsonGenerationException {
    super.serializeFields(bean, jgen, provider);
    if (bean instanceof SupportsExtensionAttributes) {
        serializeExtensionAttributes((SupportsExtensionAttributes) bean, jgen, provider);
    }
    if (bean instanceof SupportsExtensionElements) {
        serializeExtensionElements((SupportsExtensionElements) bean, jgen, provider);
    }
}

@Override
public void open(GungnirConfig config, GungnirContext context, OperatorContext operatorContext, Map<String, List<String>> outputFieldNames) throws ProcessorException {
    url = context.replaceVariable(url);
    this.outputFieldNames = outputFieldNames;
    client = HttpClientBuilder.create().build();
    SimpleModule module = new SimpleModule("GungnirModule", new Version(GUNGNIR_VERSION[0], GUNGNIR_VERSION[1], GUNGNIR_VERSION[2], null, null, null));
    module.addSerializer(Struct.class, new StructSerializer());
    mapper = new ObjectMapper();
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'");
    sdf.setTimeZone(TimeZone.getTimeZone("UTC"));
    mapper.setDateFormat(sdf);
    mapper.registerModule(module);
    mapper.configure(Feature.ESCAPE_NON_ASCII, true);
    if (format == Format.ES && param != null && param.containsKey("index") && param.containsKey("type")) {
        ObjectNode metadataNode = mapper.createObjectNode();
        metadataNode.put("_index", param.get("index"));
        metadataNode.put("_type", param.get("type"));
        ObjectNode actionNode = mapper.createObjectNode();
        actionNode.set("index", metadataNode);
        try {
            actionLine = mapper.writeValueAsString(actionNode) + '\n';
        } catch (JsonGenerationException e) {
            throw new ProcessorException("Failed to convert json format", e);
        } catch (JsonMappingException e) {
            throw new ProcessorException("Failed to convert json format", e);
        } catch (IOException e) {
            throw new ProcessorException("Failed to convert json format", e);
        }
    }
    LOG.info("WebEmitProcessor opened({})", this);
}

@Override
public void serialize(Number value, JsonGenerator jgen, SerializerProvider provider) throws IOException, JsonGenerationException {
    if (value instanceof Double) {
        if (value.toString().endsWith(".0")) {
            jgen.writeNumber(value.intValue());
        } else {
            jgen.writeNumber(value.doubleValue());
        }
    } else if (value instanceof Float) {
        if (value.toString().endsWith(".0")) {
            jgen.writeNumber(value.intValue());
        } else {
            jgen.writeNumber(value.floatValue());
        }
    } else {
        NumberSerializer.instance.serialize(value, jgen, provider);
    }
}

public void doMain(String[] args) throws SAXException, CmdLineException, TimeoutException, BoilerpipeProcessingException, IOException {
    CmdLineParser parser = new CmdLineParser(this);
    parser.setUsageWidth(80);
    try {
        parser.parseArgument(args);
        if (arguments.isEmpty())
            throw new CmdLineException(parser, "No arguments were given");
    } catch (final CmdLineException e) {
        System.err.println(e.getMessage());
        System.err.println("handytrowel [URL]");
        parser.printUsage(System.err);
        System.err.println();
        throw e;
    }
    String url = arguments.get(0);
    HTMLFetcher htmlFetcher = new HTMLFetcherBuilder().timeoutMillis(30 * 10000).build();
    String pageSource = null;
    try {
        pageSource = htmlFetcher.getPageSource(url);
    } catch (final TimeoutException e) {
        e.printStackTrace();
        throw e;
    }
    String extractedBody = null;
    List<String> links = null;
    try {
        final HTMLDocument htmlDoc = new HTMLDocument(pageSource);
        final TextDocument doc = new BoilerpipeSAXInput(htmlDoc.toInputSource()).getTextDocument();
        ArticleExtractor.INSTANCE.process(doc);
        final InputSource is = htmlDoc.toInputSource();
        links = LinkExtractor.INSTANCE.process(doc, is);
        /*
             * working article sentences extractor
             * !!AI do I have to call this again, or can I piggy back on LinkExtractor?
             */
        extractedBody = ArticleExtractor.INSTANCE.getText(pageSource);
    } catch (BoilerpipeProcessingException e) {
        e.printStackTrace();
        throw e;
    }
    TextAnalyzer analyzer = new TextAnalyzerBuilder().body(extractedBody).build().analyze();
    List<String> tokens = analyzer.getTokens();
    ObjectMapper mapper = new ObjectMapper();
    mapper.configure(SerializationFeature.INDENT_OUTPUT, true);
    Map<String, Object> articleData = new HashMap<>();
    articleData.put("extractedBody", extractedBody);
    articleData.put("links", links);
    articleData.put("tokens", tokens);
    try {
        mapper.writeValue(System.out, articleData);
    } catch (JsonGenerationException e) {
        e.printStackTrace();
        throw e;
    } catch (JsonMappingException e) {
        e.printStackTrace();
        throw e;
    } catch (IOException e) {
        e.printStackTrace();
        throw e;
    }
}

/**
     * java对象转�为json字符串
     * 
     * @param object
     *            Java对象
     * @return 返回字符串
     */
public static String fromObjectToJson(Object object) {
    ObjectMapper mapper = new ObjectMapper();
    mapper.setSerializationInclusion(Include.NON_NULL);
    try {
        return mapper.writeValueAsString(object);
    } catch (JsonGenerationException e) {
        logger.error("JsonGenerationException: ", e);
    } catch (JsonMappingException e) {
        logger.error("JsonMappingException: ", e);
    } catch (IOException e) {
        logger.error("IOException: ", e);
    }
    return null;
}

private void xmlDeserialize() {
    try {
        System.out.println("DataArray Deserializing: " + xmlString);
        AbstractDataComponent data = helper.deserialize(DataArrayDocument.Factory.parse(xmlString).getAbstractDataComponent());
        System.out.println("result: " + mapper.writeValueAsString(data));
    } catch (XmlException e) {
        e.printStackTrace();
    } catch (JsonGenerationException e) {
        e.printStackTrace();
    } catch (JsonMappingException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

@Override
public void serialize(OperationType value, JsonGenerator jgen, SerializerProvider provider) throws IOException, JsonGenerationException {
    if (OperationType.ONE_WAY.equals(value)) {
        jgen.writeString("ONE_WAY");
    } else if (OperationType.REQUEST_RESPONSE.equals(value)) {
        jgen.writeString("REQUEST_RESPONSE");
    } else if (OperationType.SOLICIT_RESPONSE.equals(value)) {
        jgen.writeString("SOLICIT_RESPONSE");
    } else if (OperationType.NOTIFICATION.equals(value)) {
        jgen.writeString("NOTIFICATION");
    } else {
        // unknown type
        jgen.writeString(value.toString());
    }
}

public String serialize(Object obj) {
    StringWriter writer = new StringWriter();
    JsonGenerator jsonGenerator;
    try {
        jsonGenerator = new MappingJsonFactory().createJsonGenerator(writer);
        mMapper.writeValue(jsonGenerator, obj);
        return writer.toString();
    } catch (JsonGenerationException e) {
        Log.e(TAG, e.toString());
        return getErrorJson(ObaApi.OBA_INTERNAL_ERROR, e.toString());
    } catch (JsonMappingException e) {
        Log.e(TAG, e.toString());
        return getErrorJson(ObaApi.OBA_INTERNAL_ERROR, e.toString());
    } catch (IOException e) {
        Log.e(TAG, e.toString());
        return getErrorJson(ObaApi.OBA_IO_EXCEPTION, e.toString());
    }
}

public void execute(final TSDB tsdb, final HttpQuery query) throws JsonGenerationException, IOException {
    LogIterator logmsgs = new LogIterator();
    if (query.hasQueryStringParam("json")) {
        ArrayList<String> logs = new ArrayList<String>();
        for (String log : logmsgs) {
            logs.add(log);
        }
        query.sendReply(JSON.serializeToBytes(logs));
    } else if (query.hasQueryStringParam("level")) {
        final Level level = Level.toLevel(query.getQueryStringParam("level"), null);
        if (level == null) {
            throw new BadRequestException("Invalid level: " + query.getQueryStringParam("level"));
        }
        final Logger root = (Logger) LoggerFactory.getLogger(Logger.ROOT_LOGGER_NAME);
        String logger_name = query.getQueryStringParam("logger");
        if (logger_name == null) {
            logger_name = Logger.ROOT_LOGGER_NAME;
        } else if (root.getLoggerContext().exists(logger_name) == null) {
            throw new BadRequestException("Invalid logger: " + logger_name);
        }
        final Logger logger = (Logger) LoggerFactory.getLogger(logger_name);
        int nloggers = 0;
        if (logger == root) {
            // Update all the loggers.
            for (final Logger l : logger.getLoggerContext().getLoggerList()) {
                l.setLevel(level);
                nloggers++;
            }
        } else {
            logger.setLevel(level);
            nloggers++;
        }
        query.sendReply("Set the log level to " + level + " on " + nloggers + " logger" + (nloggers > 1 ? "s" : "") + ".\n");
    } else {
        final StringBuilder buf = new StringBuilder(512);
        for (final String logmsg : logmsgs) {
            buf.append(logmsg).append('\n');
        }
        logmsgs = null;
        query.sendReply(buf);
    }
}

@Test
void bundlesPolicies() throws JsonGenerationException, JsonMappingException, IOException {
    ObjectMapper jsonMapper = ObjectMapperFactory.create();
    String oldJsonPolicy = "{\"auth_policies\":{\"namespace_auth\":{},\"destination_auth\":{}},\"replication_clusters\":[]," + "\"backlog_quota_map\":{},\"persistence\":null,\"latency_stats_sample_rate\":{},\"message_ttl_in_seconds\":0}";
    Policies policies = jsonMapper.readValue(oldJsonPolicy.getBytes(), Policies.class);
    assertEquals(policies, new Policies());
    String newJsonPolicy = "{\"auth_policies\":{\"namespace_auth\":{},\"destination_auth\":{}},\"replication_clusters\":[],\"bundles\":null," + "\"backlog_quota_map\":{},\"persistence\":null,\"latency_stats_sample_rate\":{},\"message_ttl_in_seconds\":0}";
    OldPolicies oldPolicies = jsonMapper.readValue(newJsonPolicy.getBytes(), OldPolicies.class);
    assertEquals(oldPolicies, new OldPolicies());
}

/**
    * Called from WebSocketWriter when it receives a message in it's
    * message loop it does not recognize.
    */
protected void processAppMessage(Object msg) throws WebSocketException, IOException {
    mPayload.reset();
    // creating a JSON generator is supposed to be a light-weight operation
    JsonGenerator generator = mJsonFactory.createJsonGenerator(mPayload);
    try {
        if (msg instanceof WampMessage.Call) {
            WampMessage.Call call = (WampMessage.Call) msg;
            generator.writeStartArray();
            generator.writeNumber(WampMessage.MESSAGE_TYPE_CALL);
            generator.writeString(call.mCallId);
            generator.writeString(call.mProcUri);
            for (Object arg : call.mArgs) {
                generator.writeObject(arg);
            }
            generator.writeEndArray();
        } else if (msg instanceof WampMessage.Prefix) {
            WampMessage.Prefix prefix = (WampMessage.Prefix) msg;
            generator.writeStartArray();
            generator.writeNumber(WampMessage.MESSAGE_TYPE_PREFIX);
            generator.writeString(prefix.mPrefix);
            generator.writeString(prefix.mUri);
            generator.writeEndArray();
        } else if (msg instanceof WampMessage.Subscribe) {
            WampMessage.Subscribe subscribe = (WampMessage.Subscribe) msg;
            generator.writeStartArray();
            generator.writeNumber(WampMessage.MESSAGE_TYPE_SUBSCRIBE);
            generator.writeString(subscribe.mTopicUri);
            generator.writeEndArray();
        } else if (msg instanceof WampMessage.Unsubscribe) {
            WampMessage.Unsubscribe unsubscribe = (WampMessage.Unsubscribe) msg;
            generator.writeStartArray();
            generator.writeNumber(WampMessage.MESSAGE_TYPE_UNSUBSCRIBE);
            generator.writeString(unsubscribe.mTopicUri);
            generator.writeEndArray();
        } else if (msg instanceof WampMessage.Publish) {
            WampMessage.Publish publish = (WampMessage.Publish) msg;
            generator.writeStartArray();
            generator.writeNumber(WampMessage.MESSAGE_TYPE_PUBLISH);
            generator.writeString(publish.mTopicUri);
            generator.writeObject(publish.mEvent);
            generator.writeEndArray();
        } else {
            // this should not happen, but to be sure
            throw new WebSocketException("invalid message received by AutobahnWriter");
        }
    } catch (JsonGenerationException e) {
        throw new WebSocketException("JSON serialization error (" + e.toString() + ")");
    } catch (JsonMappingException e) {
        throw new WebSocketException("JSON serialization error (" + e.toString() + ")");
    }
    // make sure the JSON generator has spit out everything
    generator.flush();
    // Jackson's JSON generator produces UTF-8 directly, so we send
    // a text message frame using the raw sendFrame() method
    sendFrame(1, true, mPayload.getByteArray(), 0, mPayload.size());
    // cleanup generators resources
    generator.close();
}

/*
	 * Unwrap and split the search results into individual tweets. Advance the cursor ("since_id") for the next query.
	 * To avoid rate limit errors, wait at least 2 seconds (maximum rate according to twitter is 450/15 min or once every 2 seconds).
	 * If no data
	 * is returned, wait 10 seconds.
	 */
@Override
protected void doSendLine(String line) {
    ObjectMapper mapper = new ObjectMapper();
    JsonSlurper jsonSlurper = new JsonSlurper();
    @SuppressWarnings("unchecked") Map<String, List<Map<String, ?>>> map = (Map<String, List<Map<String, ?>>>) jsonSlurper.parseText(line);
    List<Map<String, ?>> statuses = map.get("statuses");
    for (Map<String, ?> tweet : statuses) {
        StringWriter sw = new StringWriter();
        try {
            mapper.writeValue(sw, tweet);
            sendMessage(MessageBuilder.withPayload(sw.toString()).build());
        } catch (JsonGenerationException ex) {
            logger.error("Failed to convert tweet to json: " + ex.getMessage());
            break;
        } catch (JsonMappingException ex) {
            logger.error("Failed to convert tweet to json: " + ex.getMessage());
            break;
        } catch (IOException ex) {
            logger.error("Failed to convert tweet to json: " + ex.getMessage());
            break;
        }
    }
    if (!CollectionUtils.isEmpty(statuses)) {
        this.sinceId = ((Long) (statuses.get(statuses.size() - 1).get("id")));
        wait(2100);
    } else {
        wait(10000);
    }
}

public String serialize(Object obj) {
    StringWriter writer = new StringWriter();
    JsonGenerator jsonGenerator;
    try {
        jsonGenerator = new MappingJsonFactory().createJsonGenerator(writer);
        mMapper.writeValue(jsonGenerator, obj);
        return writer.toString();
    } catch (JsonGenerationException e) {
        Log.e(TAG, e.toString());
        return getErrorJson(ObaApi.OBA_INTERNAL_ERROR, e.toString());
    } catch (JsonMappingException e) {
        Log.e(TAG, e.toString());
        return getErrorJson(ObaApi.OBA_INTERNAL_ERROR, e.toString());
    } catch (IOException e) {
        Log.e(TAG, e.toString());
        return getErrorJson(ObaApi.OBA_IO_EXCEPTION, e.toString());
    }
}

@Override
public final String toNonNullValue(Object value) {
    try {
        final Class<? extends Object> type = value.getClass();
        final ObjectWriter typeWriter = typedObjectWriters.getUnchecked(type);
        final String valueAsString = typeWriter.writeValueAsString(value);
        return objectWriter.writeValueAsString(new JsonWrapper(type, valueAsString));
    } catch (JsonGenerationException e) {
        throw new IllegalArgumentException("Could not write to JSON: " + value, e);
    } catch (JsonMappingException e) {
        throw new IllegalArgumentException("Could not write to JSON: " + value, e);
    } catch (IOException e) {
        throw new IllegalArgumentException("Could not write to JSON: " + value, e);
    }
}

public static String toJsonString(Object obj) {
    try {
        return mapper.writeValueAsString(obj);
    } catch (JsonGenerationException e) {
        throw new ClientException("Unable to generate json", e);
    } catch (JsonMappingException e) {
        throw new ClientException("Unable to map json", e);
    } catch (IOException e) {
        throw new ClientException("IO error", e);
    }
}

@Override
public void serialize(String str, JsonGenerator gen, SerializerProvider provider) throws IOException {
    int status = ((JsonWriteContext) gen.getOutputContext()).writeValue();
    switch(status) {
        case JsonWriteContext.STATUS_OK_AFTER_COLON:
            gen.writeRaw(':');
            break;
        case JsonWriteContext.STATUS_OK_AFTER_COMMA:
            gen.writeRaw(',');
            break;
        case JsonWriteContext.STATUS_EXPECT_NAME:
            throw new JsonGenerationException("Can not write string value here");
    }
    gen.writeRaw('"');
    for (char c : str.toCharArray()) {
        if (c >= 0x80)
            writeUnicodeEscape(gen, c);
        else {
            int code = (c < ESCAPE_CODES.length ? ESCAPE_CODES[c] : 0);
            if (code == 0)
                gen.writeRaw(c);
            else if (code == -1)
                writeUnicodeEscape(gen, c);
            else
                writeShortEscape(gen, (char) code);
        }
    }
    gen.writeRaw('"');
}

private void serializeData(Page target, URL url, OutputStream fileStream) throws IOException, JsonGenerationException, JsonMappingException {
    switch(dataFormat) {
        case HTML:
            {
                fileStream.write(target.getContent());
                break;
            }
        case JSON:
            {
                TargetModelJson targetModel = new TargetModelJson(target);
                jsonMapper.writeValue(fileStream, targetModel);
                break;
            }
        case CBOR:
            {
                TargetModelCbor targetModel = new TargetModelCbor("", "", url, target.getContentAsString());
                cborMapper.writeValue(fileStream, targetModel);
                break;
            }
    }
}

private ApiRequest requestWithVerb(IPolicyChain<ApiRequest> chain, String verb) throws IOException, JsonGenerationException, JsonMappingException {
    IgnoredResourcesPolicy policy = new IgnoredResourcesPolicy();
    IgnoredResourcesConfig configObj = new IgnoredResourcesConfig();
    ArrayList<IgnoredResource> elements = new ArrayList<>(2);
    elements.add(createResource(verb, firstPath));
    elements.add(createResource(verb, secondPath));
    configObj.setRules(elements);
    String json = mapper.writeValueAsString(configObj);
    Object config = policy.parseConfiguration(json);
    ApiRequest request = new ApiRequest();
    request.setType("GET");
    request.setApiKey("12345");
    request.setRemoteAddr("1.2.3.4");
    request.setDestination("/invoices/1");
    IPolicyContext context = Mockito.mock(IPolicyContext.class);
    createFailurePolicyObject(context);
    // Success
    policy.apply(request, context, config, chain);
    // Fail
    request.setDestination("/invoices/23/items/43");
    policy.apply(request, context, config, chain);
    // Fail
    request.setDestination("/items/43");
    policy.apply(request, context, config, chain);
    return request;
}

private static void writeJsonProperty(JsonGenerator generator, Entry<String, EntityProperty> prop) throws JsonGenerationException, IOException {
    EdmType edmType = prop.getValue().getEdmType();
    if (prop.getValue().getIsNull()) {
        generator.writeNullField(prop.getKey());
    } else if (edmType == EdmType.BOOLEAN) {
        generator.writeBooleanField(prop.getKey(), prop.getValue().getValueAsBoolean());
    } else if (edmType == EdmType.DOUBLE) {
        generator.writeNumberField(prop.getKey(), prop.getValue().getValueAsDouble());
    } else if (edmType == EdmType.INT32) {
        generator.writeNumberField(prop.getKey(), prop.getValue().getValueAsInteger());
    } else {
        generator.writeStringField(prop.getKey(), prop.getValue().getValueAsString());
    }
}

private static void writeJsonProperty(JsonGenerator generator, Entry<String, EntityProperty> prop) throws JsonGenerationException, IOException {
    EdmType edmType = prop.getValue().getEdmType();
    if (prop.getValue().getIsNull()) {
        generator.writeNullField(prop.getKey());
    } else if (edmType == EdmType.BOOLEAN) {
        generator.writeBooleanField(prop.getKey(), prop.getValue().getValueAsBoolean());
    } else if (edmType == EdmType.DOUBLE) {
        generator.writeNumberField(prop.getKey(), prop.getValue().getValueAsDouble());
    } else if (edmType == EdmType.INT32) {
        generator.writeNumberField(prop.getKey(), prop.getValue().getValueAsInteger());
    } else {
        generator.writeStringField(prop.getKey(), prop.getValue().getValueAsString());
    }
}

private static void writeJsonProperty(JsonGenerator generator, Entry<String, EntityProperty> prop) throws JsonGenerationException, IOException {
    EdmType edmType = prop.getValue().getEdmType();
    if (prop.getValue().getIsNull()) {
        generator.writeNullField(prop.getKey());
    } else if (edmType == EdmType.BOOLEAN) {
        generator.writeBooleanField(prop.getKey(), prop.getValue().getValueAsBoolean());
    } else if (edmType == EdmType.DOUBLE) {
        generator.writeNumberField(prop.getKey(), prop.getValue().getValueAsDouble());
    } else if (edmType == EdmType.INT32) {
        generator.writeNumberField(prop.getKey(), prop.getValue().getValueAsInteger());
    } else {
        generator.writeStringField(prop.getKey(), prop.getValue().getValueAsString());
    }
}

@GET
@Path("/accession/{acc}/publications")
public Response getTargetPublications(@PathParam("acc") String resourceId, @QueryParam("filter") String filter, @QueryParam("search") String search, @QueryParam("expand") String expand) {
    boolean expandEntries = false;
    if (expand != null && (expand.toLowerCase().equals("true") || expand.toLowerCase().equals("yes")))
        expandEntries = true;
    List<Publication> pubs = null;
    try {
        pubs = db.getProteinTargetPublications(resourceId);
        Response response;
        if (countRequested)
            response = Response.ok(String.valueOf(pubs.size()), MediaType.TEXT_PLAIN).build();
        else if (expandEntries) {
            String json = Util.toJson(pubs);
            response = Response.ok(json, MediaType.APPLICATION_JSON).build();
        } else {
            List<String> links = new ArrayList<String>();
            for (Publication pub : pubs) links.add(pub.getResourcePath());
            String json = Util.toJson(links);
            response = Response.ok(json, MediaType.APPLICATION_JSON).build();
        }
        db.closeConnection();
        return response;
    } catch (SQLException e) {
        throw new WebApplicationException(e, 500);
    } catch (JsonMappingException e) {
        throw new WebApplicationException(e, 500);
    } catch (JsonGenerationException e) {
        throw new WebApplicationException(e, 500);
    } catch (IOException e) {
        throw new WebApplicationException(e, 500);
    }
}

@Override
public String toString() {
    //Try to use a JSON formatter for generating the toString
    try {
        return WRITER.writeValueAsString(this);
    } catch (JsonGenerationException e) {
    } catch (JsonMappingException e) {
    } catch (IOException e) {
    }
    //Fall back on a simpler tostring
    return "CacheKey [source=" + source + ", key=" + Arrays.toString(key) + "]";
}

private void writeValue(FieldReader reader) throws JsonGenerationException, IOException {
    final DataMode m = reader.getType().getMode();
    final MinorType mt = reader.getType().getMinorType();
    switch(m) {
        case OPTIONAL:
        case REQUIRED:
            switch(mt) {
                case FLOAT4:
                    gen.writeFloat(reader);
                    break;
                case FLOAT8:
                    gen.writeDouble(reader);
                    break;
                case INT:
                    gen.writeInt(reader);
                    break;
                case SMALLINT:
                    gen.writeSmallInt(reader);
                    break;
                case TINYINT:
                    gen.writeTinyInt(reader);
                    break;
                case BIGINT:
                    gen.writeBigInt(reader);
                    break;
                case BIT:
                    gen.writeBoolean(reader);
                    break;
                case DATE:
                    gen.writeDate(reader);
                    break;
                case TIME:
                    gen.writeTime(reader);
                    break;
                case TIMESTAMP:
                    gen.writeTimestamp(reader);
                    break;
                case INTERVALYEAR:
                case INTERVALDAY:
                case INTERVAL:
                    gen.writeInterval(reader);
                    break;
                case DECIMAL28DENSE:
                case DECIMAL28SPARSE:
                case DECIMAL38DENSE:
                case DECIMAL38SPARSE:
                case DECIMAL9:
                case DECIMAL18:
                    gen.writeDecimal(reader);
                    break;
                case LIST:
                    // this is a pseudo class, doesn't actually contain the real reader so we have to drop down.
                    gen.writeStartArray();
                    while (reader.next()) {
                        writeValue(reader.reader());
                    }
                    gen.writeEndArray();
                    break;
                case MAP:
                    gen.writeStartObject();
                    if (reader.isSet()) {
                        for (String name : reader) {
                            FieldReader childReader = reader.reader(name);
                            if (childReader.isSet()) {
                                gen.writeFieldName(name);
                                writeValue(childReader);
                            }
                        }
                    }
                    gen.writeEndObject();
                    break;
                case NULL:
                case LATE:
                    gen.writeUntypedNull();
                    break;
                case VAR16CHAR:
                    gen.writeVar16Char(reader);
                    break;
                case VARBINARY:
                    gen.writeBinary(reader);
                    break;
                case VARCHAR:
                    gen.writeVarChar(reader);
                    break;
            }
            break;
        case REPEATED:
            gen.writeStartArray();
            switch(mt) {
                case FLOAT4:
                    for (int i = 0; i < reader.size(); i++) {
                        gen.writeFloat(i, reader);
                    }
                    break;
                case FLOAT8:
                    for (int i = 0; i < reader.size(); i++) {
                        gen.writeDouble(i, reader);
                    }
                    break;
                case INT:
                    for (int i = 0; i < reader.size(); i++) {
                        gen.writeInt(i, reader);
                    }
                    break;
                case SMALLINT:
                    for (int i = 0; i < reader.size(); i++) {
                        gen.writeSmallInt(i, reader);
                    }
                    break;
                case TINYINT:
                    for (int i = 0; i < reader.size(); i++) {
                        gen.writeTinyInt(i, reader);
                    }
                    break;
                case BIGINT:
                    for (int i = 0; i < reader.size(); i++) {
                        gen.writeBigInt(i, reader);
                    }
                    break;
                case BIT:
                    for (int i = 0; i < reader.size(); i++) {
                        gen.writeBoolean(i, reader);
                    }
                    break;
                case DATE:
                    for (int i = 0; i < reader.size(); i++) {
                        gen.writeDate(i, reader);
                    }
                    break;
                case TIME:
                    for (int i = 0; i < reader.size(); i++) {
                        gen.writeTime(i, reader);
                    }
                    break;
                case TIMESTAMP:
                    for (int i = 0; i < reader.size(); i++) {
                        gen.writeTimestamp(i, reader);
                    }
                    break;
                case INTERVALYEAR:
                case INTERVALDAY:
                case INTERVAL:
                    for (int i = 0; i < reader.size(); i++) {
                        gen.writeInterval(i, reader);
                    }
                    break;
                case DECIMAL28DENSE:
                case DECIMAL28SPARSE:
                case DECIMAL38DENSE:
                case DECIMAL38SPARSE:
                case DECIMAL9:
                case DECIMAL18:
                    for (int i = 0; i < reader.size(); i++) {
                        gen.writeDecimal(i, reader);
                    }
                    break;
                case LIST:
                    for (int i = 0; i < reader.size(); i++) {
                        while (reader.next()) {
                            writeValue(reader.reader());
                        }
                    }
                    break;
                case MAP:
                    while (reader.next()) {
                        gen.writeStartObject();
                        for (String name : reader) {
                            FieldReader mapField = reader.reader(name);
                            if (mapField.isSet()) {
                                gen.writeFieldName(name);
                                writeValue(mapField);
                            }
                        }
                        gen.writeEndObject();
                    }
                    break;
                case NULL:
                    break;
                case VAR16CHAR:
                    for (int i = 0; i < reader.size(); i++) {
                        gen.writeVar16Char(i, reader);
                    }
                    break;
                case VARBINARY:
                    for (int i = 0; i < reader.size(); i++) {
                        gen.writeBinary(i, reader);
                    }
                    break;
                case VARCHAR:
                    for (int i = 0; i < reader.size(); i++) {
                        gen.writeVarChar(i, reader);
                    }
                    break;
                default:
                    throw new IllegalStateException(String.format("Unable to handle type %s.", mt));
            }
            gen.writeEndArray();
            break;
    }
}

/**
	 * Parse a JSON response for a list of "tweets" from Twitter's REST API with
	 * Jackson's streaming parse method. Although this is a sligthly faster
	 * alternative the current build uses the databinding parse, favoring a
	 * simplier implementation. This method is thus currently not in use.
	 * 
	 * @param json
	 *            the JSON response from Twitters RESP API
	 */
private List<TwitterItem> streamingTwitterParse(String json) {
    long time = System.currentTimeMillis();
    List<TwitterItem> list = new ArrayList<TwitterItem>();
    try {
        if (jfactory == null) {
            jfactory = new JsonFactory();
        }
        jParser = jfactory.createJsonParser(json);
        TwitterItem o = null;
        while (jParser.nextToken() != null) {
            if ("created_at".equals(jParser.getCurrentName())) {
                jParser.nextToken();
                o = new TwitterItem();
                o.setTimestamp(jParser.getText());
            }
            if ("text".equals(jParser.getCurrentName())) {
                jParser.nextToken();
                o.setText(jParser.getText());
            }
            if ("name".equals(jParser.getCurrentName())) {
                jParser.nextToken();
                o.getUser().setUserName(jParser.getText());
            }
            if ("profile_image_url".equals(jParser.getCurrentName())) {
                jParser.nextToken();
                o.getUser().setProfileImageURL(jParser.getText());
                list.add(o);
            }
        }
        jParser.close();
    } catch (JsonGenerationException e) {
        Log.e(getClass().getName(), e.getMessage());
    } catch (JsonMappingException e) {
        Log.e(getClass().getName(), e.getMessage());
    } catch (IOException e) {
        Log.e(getClass().getName(), e.getMessage());
    }
    Log.i(TwitterJSONParser.class.getName(), "Streaming parse");
    Log.i(TwitterJSONParser.class.getName(), "Items: " + list.size());
    Log.i(TwitterJSONParser.class.getName(), "Time in millis: " + (System.currentTimeMillis() - time));
    return list;
}

@Override
public String toString() {
    try {
        return mapper.writeValueAsString(this);
    } catch (JsonGenerationException e) {
        return "GoodwillSchema{" + JSON_THRIFT_TYPE_NAME + "='" + getName() + '\'' + ", thriftItems=" + getSchema() + '}';
    } catch (IOException e) {
        return "GoodwillSchema{" + JSON_THRIFT_TYPE_NAME + "='" + getName() + '\'' + ", thriftItems=" + getSchema() + '}';
    }
}

/**
     * 
     * @param outJson
     */
public void output(File outJson) {
    this.output();
    ObjectMapper mapper = new ObjectMapper();
    try {
        mapper.writeValue(outJson, this);
    } catch (JsonGenerationException ex) {
        log.error(ex);
    } catch (JsonMappingException ex) {
        log.error(ex);
    } catch (IOException ex) {
        log.error(ex);
    }
}

@Test
/**
     * Does serialization of Encryptable work if you create an objectMapper with an FHE SecurityConfiguration?
     * @throws JsonGenerationException
     * @throws JsonMappingException
     * @throws IOException
     */
@Ignore
public void testSerializationWithImplicitEncryption() throws JsonGenerationException, JsonMappingException, IOException {
    byte[] key = new byte[INDEX_LENGTH >>> 3];
    new Random().nextBytes(key);
    Metadata metadatum = new Metadata("TEST", "test", Arrays.asList(1, 2, 3));
    Encryptable<Metadata> data = new Encryptable<Metadata>(metadatum);
    // implicit encryption via objectmapper
    // Create our request with our (PLAIN) Encryptable. It will get encrypted upon serialization
    MetadataRequest req = new MetadataRequest(Arrays.asList(new IndexedMetadata(key, data, "test")));
    String actual = serialize(req);
    String expectedSubstring = "{\"metadata\":[{\"key\":" + wrapQuotes(Base64.encodeBase64String(key));
    // weak substring assertion that does not test ciphertext validity
    // ciphertext validity is covered in serializationDeserializationTest
    Assert.assertThat(actual, CoreMatchers.containsString(expectedSubstring));
}

@Override
public void literal(final String name, final String value) {
    try {
        final JsonStreamContext ctx = jsonGenerator.getOutputContext();
        if (ctx.inObject()) {
            jsonGenerator.writeFieldName(name);
        }
        if (value == null) {
            jsonGenerator.writeNull();
        } else {
            jsonGenerator.writeString(value);
        }
    } catch (final JsonGenerationException e) {
        throw new MetafactureException(e);
    } catch (final IOException e) {
        throw new MetafactureException(e);
    }
}

/**
     * Serialize this pair of histograms out as a JSON document using the given JsonGenerator. The format is:
     * <pre> {
     *   sums: [],
     *   counts: []     
     * } </pre> 
     */
public void writeJson(JsonGenerator jgen) throws JsonGenerationException, IOException {
    // The number of features reached during each minute, ignoring their magnitudes
    jgen.writeArrayFieldStart("sums");
    {
        for (int sum : sums) {
            jgen.writeNumber(sum);
        }
    }
    jgen.writeEndArray();
    // The total number of opportunities reached during each minute (the sum of the features' magnitudes)
    jgen.writeArrayFieldStart("counts");
    {
        for (int count : counts) {
            jgen.writeNumber(count);
        }
    }
    jgen.writeEndArray();
}