Java Code Examples for com.fasterxml.jackson.core.JsonGenerator#writeRawValue()

@SuppressWarnings("rawtypes")
static void serializeTBase(@Nullable TBase value, JsonGenerator gen,
                           boolean useNamedEnums) throws IOException {
    if (value == null) {
        gen.writeNull();
        return;
    }

    gen.writeRawValue(serializeTBaseLike(protocol -> {
        try {
            value.write(protocol);
        } catch (TException ex) {
            throw new IllegalArgumentException(ex);
        }
    }, useNamedEnums));
}
 

protected void summary (Statement s, String name, String sql, JsonGenerator gen, boolean arrayWrapper) throws IOException, SQLException {
   logger.trace("summary: {}", name);
   if (arrayWrapper) {
       gen.writeArrayFieldStart(name);
   } else {
       gen.writeFieldName(name);
   }
   JDBCResultSet rs = (JDBCResultSet)s.executeQuery(sql);
   StringWriter strings = new StringWriter();
   PrintWriter writer = new PrintWriter(strings);
   collectResults(rs, writer, options);
   gen.writeRawValue(strings.toString());
   if (arrayWrapper) {
       gen.writeEndArray();
   }
}
 

private void writeBody(
        final HttpMessage message,
        final JsonGenerator generator) throws IOException {

    final String body = message.getBodyAsString();

    if (body.isEmpty()) {
        return;
    }
    generator.writeFieldName("body");

    final String contentType = message.getContentType();

    if (JsonMediaType.JSON.test(contentType)) {
        generator.writeRawValue(body);
    } else {
        generator.writeString(body);
    }
}
 

public String getStatsAsJson() {
    try {
        StringWriter stringWriter = new StringWriter();
        JsonGenerator jsonGenerator = jsonFactory.createGenerator(stringWriter);
        jsonGenerator.writeStartObject();
        jsonGenerator.writeArrayFieldStart("clusters");
        for (ClusterConnection cluster : clusters) {
            jsonGenerator.writeStartObject();
            jsonGenerator.writeNumberField("clusterid", cluster.getClusterId());
            jsonGenerator.writeFieldName("stats");
            jsonGenerator.writeRawValue(cluster.getStatsAsJSon());
            jsonGenerator.writeEndObject();
        }
        jsonGenerator.writeEndArray();
        jsonGenerator.writeFieldName("sessionParams");
        jsonGenerator.writeRawValue(sessionParamsAsXmlString);
        jsonGenerator.writeFieldName("throttleDebugMessage");
        jsonGenerator.writeRawValue("\"" + throttler.getDebugMessage() + "\"");
        jsonGenerator.writeEndObject();
        jsonGenerator.close();
        return stringWriter.toString();
    } catch (IOException e) {
        return "{ \"Error\" : \""+ e.getMessage() + "\"}";
    }
}
 

@Override
public void serialize(Message message, JsonGenerator gen, SerializerProvider serializers) throws IOException {
    gen.writeRawValue(JsonFormat.printer()
            .includingDefaultValueFields()
            .omittingInsignificantWhitespace()
            .print(message));
}
 

@Override
public void serialize(Map<String, T> value, JsonGenerator g) throws IOException, JsonGenerationException {
    g.writeStartObject();
    for (Map.Entry<String, T> e : value.entrySet()) {
        g.writeFieldName(e.getKey());
        g.writeRawValue(underlying.serialize(e.getValue()));
    }
    g.writeEndObject();
}
 

@Override
public void writeJsonValue(JsonGenerator jsonGenerator, Block block, int position, ConnectorSession session)
        throws IOException
{
    if (block.isNull(position)) {
        jsonGenerator.writeNull();
    }
    else {
        Slice value = JSON.getSlice(block, position);
        jsonGenerator.writeRawValue(value.toStringUtf8());
    }
}
 

private void writeIncludingSchema(final GenericData.Record value, final JsonGenerator gen) throws IOException {
    // Start new object.
    gen.writeStartObject();

    // Write value
    gen.writeFieldName("value");
    gen.writeRawValue(value.toString());

    // Write schema
    gen.writeFieldName("schema");
    gen.writeRawValue(value.getSchema().toString());

    // End object
    gen.writeEndObject();
}
 

protected void _serialize(JsonGenerator gen) throws IOException
{
    if (_value instanceof SerializableString) {
        gen.writeRawValue((SerializableString) _value);
    } else {
        gen.writeRawValue(String.valueOf(_value));
    }
}
 

protected void serializeFieldCustomized(
        Entity entity,
        JsonGenerator gen,
        BeanPropertyDefinition property,
        List<BeanPropertyDefinition> properties,
        CustomSerialization annotation) throws IOException {
    // check if encoding field is present in current bean
    // get value
    // call CustomSerializationManager
    Optional<BeanPropertyDefinition> encodingProperty = properties.stream().filter(p -> p.getName().equals(annotation.encoding())).findFirst();
    if (!encodingProperty.isPresent()) {
        throw new JsonGenerationException("can not serialize instance of class '" + entity.getClass() + "'! \n"
                + "Reason: trying to use custom serialization for field '" + property.getName() + "' but field '" + annotation.encoding() + "' specifying enconding is not present!",
                gen);
    }
    Object value = encodingProperty.get().getAccessor().getValue(entity);
    String encodingType = null;
    if (value != null) {
        encodingType = value.toString();
    }
    String customJson = CustomSerializationManager.getInstance()
            .getSerializer(encodingType)
            .serialize(property.getAccessor().getValue(entity));
    if (customJson != null && !customJson.isEmpty()) {
        gen.writeFieldName(property.getName());
        gen.writeRawValue(customJson);
    }
}
 

protected void addCommonReturnValues(JsonGenerator jsonGenerator) throws IOException {
    ConfigKey<?> key = requestData.getConfigKey();
    setResponseField(jsonGenerator, SlimeResponseData.RESPONSE_VERSION, getProtocolVersion());
    setResponseField(jsonGenerator, SlimeResponseData.RESPONSE_DEF_NAME, key.getName());
    setResponseField(jsonGenerator, SlimeResponseData.RESPONSE_DEF_NAMESPACE, key.getNamespace());
    setResponseField(jsonGenerator, SlimeResponseData.RESPONSE_DEF_MD5, key.getMd5());
    setResponseField(jsonGenerator, SlimeResponseData.RESPONSE_CONFIGID, key.getConfigId());
    setResponseField(jsonGenerator, SlimeResponseData.RESPONSE_CLIENT_HOSTNAME, requestData.getClientHostName());
    jsonGenerator.writeFieldName(SlimeResponseData.RESPONSE_TRACE);
    jsonGenerator.writeRawValue(getRequestTrace().toString(true));
}
 

@Override
public void serialize(String value, JsonGenerator gen, SerializerProvider serializers) throws IOException {
    gen.writeRawValue(value);
}
 

@Override
public void serialize(JavaScriptFunction value, JsonGenerator gen, SerializerProvider serializers) throws IOException, JsonProcessingException {
	gen.writeRawValue(value.function);
}
 

@Override
public void serialize(Folder value, JsonGenerator gen, SerializerProvider provider) throws IOException {

    gen.writeStartObject();
    gen.writeStringField("name", value.getName());

    // we access internal mapper to delegate the serialization of File list  
    ObjectMapper mapper = (ObjectMapper) gen.getCodec();

    gen.writeFieldName("files");
    String stringValue = mapper.writeValueAsString(value.getFiles());
    gen.writeRawValue(stringValue);

    gen.writeEndObject();

}
 

@Override
public void serialize(JSONObject jsonObject, JsonGenerator jgen,
                      SerializerProvider provider) throws IOException{
    jgen.writeRawValue(jsonObject.toString());
}
 

@Override
public void serialize(ScriptAware value, JsonGenerator gen, SerializerProvider provider)
    throws IOException {
  gen.writeRawValue(value.getScript());
}
 

@Override
public void serialize(VType vType, JsonGenerator gen, SerializerProvider serializers) throws IOException {
	gen.writeRawValue(VTypeToJson.toJson(vType).toString());
}
 

@Override
public void serialize(VType vType, JsonGenerator gen, SerializerProvider serializers) throws IOException {
	gen.writeRawValue(VTypeToJson.toJson(vType).toString());
}
 

private void writeValueOnly(final GenericData.Record value, final JsonGenerator gen) throws IOException {
    gen.writeRawValue(value.toString());
}
 

/**
 * Saves state changes transactionally.
 * [
 * {
 * "operation": "upsert",
 * "request": {
 * "key": "key1",
 * "value": "myData"
 * }
 * },
 * {
 * "operation": "delete",
 * "request": {
 * "key": "key2"
 * }
 * }
 * ]
 *
 * @param actorType    Name of the actor being changed.
 * @param actorId      Identifier of the actor being changed.
 * @param stateChanges Collection of changes to be performed transactionally.
 * @return Void.
 */
Mono<Void> apply(String actorType, ActorId actorId, ActorStateChange... stateChanges) {
  if ((stateChanges == null) || stateChanges.length == 0) {
    return Mono.empty();
  }

  int count = 0;
  // Constructing the JSON via a stream API to avoid creating transient objects to be instantiated.
  byte[] payload = null;
  try (ByteArrayOutputStream writer = new ByteArrayOutputStream()) {
    JsonGenerator generator = JSON_FACTORY.createGenerator(writer);
    // Start array
    generator.writeStartArray();

    for (ActorStateChange stateChange : stateChanges) {
      if ((stateChange == null) || (stateChange.getChangeKind() == null)) {
        continue;
      }

      String operationName = stateChange.getChangeKind().getDaprStateChangeOperation();
      if ((operationName == null) || (operationName.length() == 0)) {
        continue;
      }

      count++;

      // Start operation object.
      generator.writeStartObject();
      generator.writeStringField("operation", operationName);

      // Start request object.
      generator.writeObjectFieldStart("request");
      generator.writeStringField("key", stateChange.getStateName());
      if ((stateChange.getChangeKind() == ActorStateChangeKind.UPDATE)
          || (stateChange.getChangeKind() == ActorStateChangeKind.ADD)) {
        byte[] data = this.stateSerializer.serialize(stateChange.getValue());
        if (data != null) {
          if (this.isStateSerializerDefault) {
            // DefaultObjectSerializer is a JSON serializer, so we just pass it on.
            generator.writeFieldName("value");
            generator.writeRawValue(new String(data, CHARSET));
          } else {
            // Custom serializer uses byte[].
            generator.writeBinaryField("value", data);
          }
        }
      }
      // End request object.
      generator.writeEndObject();

      // End operation object.
      generator.writeEndObject();
    }

    // End array
    generator.writeEndArray();

    generator.close();
    writer.flush();
    payload = writer.toByteArray();
  } catch (IOException e) {
    e.printStackTrace();
    return Mono.error(e);
  }

  if (count == 0) {
    // No-op since there is no operation to be performed.
    Mono.empty();
  }

  return this.daprClient.saveActorStateTransactionally(actorType, actorId.toString(), payload);
}