/** * Convenience method for outputting a field entry ("member") * that has a String value. Equivalent to: *<pre> * writeFieldName(fieldName); * writeString(value); *</pre> *<p> * Note: many performance-sensitive implementations override this method */ public void writeStringField(String fieldName, String value) throws IOException { writeFieldName(fieldName); writeString(value); }
/** * Convenience method for outputting a field entry ("member") * (that will contain a JSON Array value), and the START_ARRAY marker. * Equivalent to: *<pre> * writeFieldName(fieldName); * writeStartArray(); *</pre> *<p> * Note: caller still has to take care to close the array * (by calling {#link #writeEndArray}) after writing all values * of the value Array. */ public final void writeArrayFieldStart(String fieldName) throws IOException { writeFieldName(fieldName); writeStartArray(); }
/** * Convenience method for outputting a field entry ("member") * (that will contain a JSON Object value), and the START_OBJECT marker. * Equivalent to: *<pre> * writeFieldName(fieldName); * writeStartObject(); *</pre> *<p> * Note: caller still has to take care to close the Object * (by calling {#link #writeEndObject}) after writing all * entries of the value Object. */ public final void writeObjectFieldStart(String fieldName) throws IOException { writeFieldName(fieldName); writeStartObject(); }
public class OrderTypeSerializer extends JsonSerializer<OrderType> { @Override public void serialize(OrderType value, JsonGenerator generator, SerializerProvider provider) throws IOException, JsonProcessingException { generator.writeStartObject(); generator.writeFieldName("id"); generator.writeNumber(value.getId()); generator.writeFieldName("name"); generator.writeString(value.getName()); generator.writeEndObject(); } }
public JsonOutputWriterUsingJackson body(Consumer<OutputWriter> consumer) { return parentWriter.withExceptionHandling((jacksonWriter) -> { jacksonWriter.writeFieldName(key); jacksonWriter.writeStartObject(); consumer.accept(parentWriter); jacksonWriter.writeEndObject(); }); } }
writeStartObject(typeIdDef.forValue); writeStringField(typeIdDef.asProperty, idStr); return typeIdDef; writeStartObject(); writeFieldName(idStr); break; case WRAPPER_ARRAY: default: // should never occur but translate as "as-array" writeStartArray(); // wrapper, not actual array object to write writeString(idStr); writeStartObject(typeIdDef.forValue); } else if (valueShape == JsonToken.START_ARRAY) { writeStartArray();
/** * Variant of {@link #writePath(JsonGenerator)} called when all we * need is immediately surrounding Object. Method typically called * when including a single property but not including full path * to root. */ public void writeImmediatePath(JsonGenerator gen) throws IOException { if ((_filter == null) || (_filter == TokenFilter.INCLUDE_ALL)) { return; } if (_startHandled) { // even if Object started, need to start leaf-level name if (_needToHandleName) { gen.writeFieldName(_currentName); } } else { _startHandled = true; if (_type == TYPE_OBJECT) { gen.writeStartObject(); if (_needToHandleName) { gen.writeFieldName(_currentName); } } else if (_type == TYPE_ARRAY) { gen.writeStartArray(); } } }
jg.writeFieldName( collectionName ); jg.writeStartArray(); jg.writeEndArray();
public void aliasesToJson(JsonGenerator gen) throws IOException { if (aliases == null || aliases.size() == 0) return; gen.writeFieldName("aliases"); gen.writeStartArray(); for (Name alias : aliases) gen.writeString(alias.getQualified(name.space)); gen.writeEndArray(); }
@Override public void serialize(Date object, String fieldName, boolean writeFieldNameForObject, JsonGenerator jsonGenerator) throws IOException { if (fieldName != null && object != null) { jsonGenerator.writeStringField(fieldName, mDateFormat.get().format(object)); } else if (object != null) { jsonGenerator.writeString(mDateFormat.get().format(object)); } else { if (fieldName != null) { jsonGenerator.writeFieldName(fieldName); } jsonGenerator.writeNull(); } }
/** * I believe these two messages are called for a thrift service * interface. We don't plan on storing any text objects of that * type on disk. */ @Override public void writeMessageBegin(TMessage message) throws TException { try { getCurrentWriter().writeStartObject(); getCurrentWriter().writeFieldName("method"); getCurrentWriter().writeString(message.name); getCurrentWriter().writeFieldName("type"); TypedParser.TMESSAGE_TYPE.writeValue(getCurrentWriter(), message.type); getCurrentWriter().writeFieldName("seqid"); getCurrentWriter().writeNumber(message.seqid); getCurrentWriter().writeFieldName("args"); } catch (IOException e) { throw new TTransportException(e); } }
@Override public void serialize(Object value, JsonGenerator jgen, SerializerProvider provider) throws IOException { jgen.writeStartObject(); jgen.writeFieldName("testBeanSimple"); jgen.writeString("custom"); jgen.writeEndObject(); } }
@Override public ByteBuffer write(List<Object> data, ByteBuffer buffer) { Preconditions.checkArgument(data != null && data.size() == fieldNames.size(), "Invalid schema"); StringWriter sw = new StringWriter(); try (JsonGenerator jg = jsonFactory.createGenerator(sw)) { jg.writeStartObject(); for (int i = 0; i < fieldNames.size(); ++i) { jg.writeFieldName(fieldNames.get(i)); jg.writeObject(data.get(i)); } jg.writeEndObject(); } catch (IOException e) { throw new RuntimeException(e); } return ByteBuffer.wrap(sw.toString().getBytes(StandardCharsets.UTF_8)); } }
/** * Sets up the JSON preamble to start streaming results into the entity. This must be * protected via isOpen. This is an unsafe call, make sure you know how it is used. */ private void setupJsonStream() throws IOException { Class<?> testClass = tracker.getTestClass(); jgen.writeStartObject(); jgen.writeStringField( "testClass", testClass.getCanonicalName() ); jgen.writeNumberField( "startTime", tracker.getStartTime() ); if ( testClass.isAnnotationPresent( TimeChop.class ) ) { jgen.writeStringField( "chopType", "TimeChop" ); jgen.writeObjectField( "chopParameters", testClass.getAnnotation( TimeChop.class ) ); } else if ( tracker.getTestClass().isAnnotationPresent( IterationChop.class ) ) { jgen.writeStringField( "chopType", "IterationChop" ); jgen.writeObjectField( "chopParameters", testClass.getAnnotation( IterationChop.class ) ); } else { throw new IllegalStateException( "Supplied testClass " + testClass.getCanonicalName() + "has no chop annotation." ); } jgen.writeFieldName( "runResults" ); jgen.writeStartArray(); jgen.flush(); }
/** * Method called to ensure that parent path from root is written up to * and including this node. */ public void writePath(JsonGenerator gen) throws IOException { if ((_filter == null) || (_filter == TokenFilter.INCLUDE_ALL)) { return; } if (_parent != null) { _parent._writePath(gen); } if (_startHandled) { // even if Object started, need to start leaf-level name if (_needToHandleName) { gen.writeFieldName(_currentName); } } else { _startHandled = true; if (_type == TYPE_OBJECT) { gen.writeStartObject(); gen.writeFieldName(_currentName); // we know name must be written } else if (_type == TYPE_ARRAY) { gen.writeStartArray(); } } }
private void writeCollection(String name, Collection<Object> collection) throws IOException { if (name != null) { jsonGenerator.writeFieldName(name); } jsonGenerator.writeStartArray(); for (Object object : collection) { writeJson(null, object); } jsonGenerator.writeEndArray(); }
/** * Convenience method for outputting a field entry ("member") * that has a String value. Equivalent to: *<pre> * writeFieldName(fieldName); * writeString(value); *</pre> *<p> * Note: many performance-sensitive implementations override this method */ public void writeStringField(String fieldName, String value) throws IOException { writeFieldName(fieldName); writeString(value); }
/** * Convenience method for outputting a field entry ("member") * (that will contain a JSON Array value), and the START_ARRAY marker. * Equivalent to: *<pre> * writeFieldName(fieldName); * writeStartArray(); *</pre> *<p> * Note: caller still has to take care to close the array * (by calling {#link #writeEndArray}) after writing all values * of the value Array. */ public final void writeArrayFieldStart(String fieldName) throws IOException { writeFieldName(fieldName); writeStartArray(); }
private static void writeAttribute(JsonGenerator jg, String attName, final String descriptionStr, Object value) throws IOException { boolean description = false; if (descriptionStr != null && descriptionStr.length() > 0 && !attName.equals(descriptionStr)) { description = true; jg.writeFieldName(attName); jg.writeStartObject(); jg.writeFieldName("description"); jg.writeString(descriptionStr); jg.writeFieldName("value"); writeObject(jg, description, value); jg.writeEndObject(); } else { jg.writeFieldName(attName); writeObject(jg, description, value); } }
private void getJSONStringFromMap(JsonGenerator jg, Map map, String pf) throws JsonGenerationException, IOException { jg.writeStartObject(); Iterator iter = (Iterator) map.entrySet().iterator(); while (iter.hasNext()) { Map.Entry entry = (Map.Entry) iter.next(); // Iterate over Map and write key-value jg.writeFieldName(entry.getKey().toString()); // write Key in a Map writeValue(jg, entry.getValue(), pf); // write value in a Map } jg.writeEndObject(); }