@Override public void writeHeader(final List<String> columnNames) throws IOException { jsonGenerator.writeStartArray(); for (String columnName : columnNames) { jsonGenerator.writeString(columnName); } jsonGenerator.writeEndArray(); }
/** * 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 void startArrayWithoutName(Consumer<OutputListWriter> consumer) { parentWriter.withExceptionHandling(jacksonWriter -> { jacksonWriter.writeStartArray(); consumer.accept(this); jacksonWriter.writeEndArray(); }); }
private void writeUnkown(Unknown toWrite, FSTObjectOutput oout) throws IOException { gen.writeStartObject(); gen.writeFieldName(fieldNames.TYPE_S); gen.writeString(toWrite.getType()); gen.writeFieldName(fieldNames.OBJ_S); if ( toWrite.isSequence() ) { gen.writeStartArray(); for (Object o : toWrite.getItems()) { oout.writeObject(o); } gen.writeEndArray(); } else { gen.writeStartObject(); for (Map.Entry<String, Object> stringObjectEntry : toWrite.getFields().entrySet()) { gen.writeFieldName(stringObjectEntry.getKey()); oout.writeObject(stringObjectEntry.getValue()); } gen.writeEndObject(); } gen.writeEndObject(); }
@Override public final void serialize(Collection<?> value, JsonGenerator g, SerializerProvider provider) throws IOException { final int len = value.size(); if (len == 1) { if (((_unwrapSingle == null) && provider.isEnabled(SerializationFeature.WRITE_SINGLE_ELEM_ARRAYS_UNWRAPPED)) || (_unwrapSingle == Boolean.TRUE)) { serializeContents(value, g, provider); return; } } g.writeStartArray(len); serializeContents(value, g, provider); g.writeEndArray(); }
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(); } } }
@Override public void serialize(char[] value, JsonGenerator g, SerializerProvider provider) throws IOException { // [JACKSON-289] allows serializing as 'sparse' char array too: if (provider.isEnabled(SerializationFeature.WRITE_CHAR_ARRAYS_AS_JSON_ARRAYS)) { g.writeStartArray(value.length); g.setCurrentValue(value); _writeArrayContents(g, value); g.writeEndArray(); } else { g.writeString(value, 0, value.length); } }
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(); }
jg.writeFieldName( collectionName ); jg.writeStartArray(); jg.writeEndArray();
throw new UnsupportedOperationException("Polygons are not supported"); case BOX: jgen.writeString(Type.BOX.toString()); jgen.writeFieldName(FIELD_COORDINATES); jgen.writeStartArray(); jgen.writeStartArray(); jgen.writeNumber(value.coordinates[1][0]); jgen.writeNumber(value.coordinates[0][0]); jgen.writeEndArray(); jgen.writeStartArray(); jgen.writeNumber(value.coordinates[1][1]); jgen.writeNumber(value.coordinates[0][0]); jgen.writeEndArray(); jgen.writeStartArray(); jgen.writeNumber(value.coordinates[1][1]); jgen.writeNumber(value.coordinates[0][1]); jgen.writeEndArray(); jgen.writeStartArray(); jgen.writeNumber(value.coordinates[1][0]); jgen.writeNumber(value.coordinates[0][1]); jgen.writeStartArray(); jgen.writeNumber(value.coordinates[1][0]); jgen.writeNumber(value.coordinates[0][0]);
@Override public void writeHeader(final List<String> columnNames) throws IOException { jsonGenerator.writeStartArray(); for (String columnName : columnNames) { jsonGenerator.writeString(columnName); } jsonGenerator.writeEndArray(); }
@Override public void serialize(List<String> value, JsonGenerator g, SerializerProvider provider) throws IOException { final int len = value.size(); if (len == 1) { if (((_unwrapSingle == null) && provider.isEnabled(SerializationFeature.WRITE_SINGLE_ELEM_ARRAYS_UNWRAPPED)) || (_unwrapSingle == Boolean.TRUE)) { serializeContents(value, g, provider, 1); return; } } g.writeStartArray(len); serializeContents(value, g, provider, len); g.writeEndArray(); }
/** * 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(); }
private 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) { _needToHandleName = false; // at parent must explicitly clear gen.writeFieldName(_currentName); } } else { _startHandled = true; if (_type == TYPE_OBJECT) { gen.writeStartObject(); if (_needToHandleName) { _needToHandleName = false; // at parent must explicitly clear gen.writeFieldName(_currentName); } } else if (_type == TYPE_ARRAY) { gen.writeStartArray(); } } }
@Override public void serialize(char[] value, JsonGenerator jgen, SerializerProvider provider) throws IOException, JsonGenerationException { // [JACKSON-289] allows serializing as 'sparse' char array too: if (provider.isEnabled(SerializationFeature.WRITE_CHAR_ARRAYS_AS_JSON_ARRAYS)) { jgen.writeStartArray(); _writeArrayContents(jgen, value); jgen.writeEndArray(); } else { jgen.writeString(value, 0, value.length); } }
@Override public void serialize(JsonGenerator f, SerializerProvider provider) throws IOException { final List<JsonNode> c = _children; final int size = c.size(); f.writeStartArray(size); for (int i = 0; i < size; ++i) { // we'll typically have array list // For now, assuming it's either BaseJsonNode, JsonSerializable JsonNode n = c.get(i); ((BaseJsonNode) n).serialize(f, provider); } f.writeEndArray(); }
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 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(); }
@Override public void serialize(ClaimsHolder holder, JsonGenerator gen, SerializerProvider provider) throws IOException { gen.writeStartObject(); for (Map.Entry<String, Object> e : holder.getClaims().entrySet()) { switch (e.getKey()) { case PublicClaims.AUDIENCE: if (e.getValue() instanceof String) { gen.writeFieldName(e.getKey()); gen.writeString((String)e.getValue()); break; gen.writeFieldName(e.getKey()); gen.writeString(audArray[0]); } else if (audArray.length > 1) { gen.writeFieldName(e.getKey()); gen.writeStartArray(); for(String aud : audArray) { gen.writeString(aud); gen.writeEndArray(); gen.writeEndObject();