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

@Override
protected void write(JsonGenerator g, JacksonJrsTreeCodec codec) throws IOException {
    if (_value == null) {
        g.writeNull();
    } else if (_value instanceof byte[]) {
        g.writeBinary((byte[]) _value);
    } else {
        g.writeObject(_value);
    }
}
 

@Override
public void serialize(ByteBuffer value, JsonGenerator jgen,
        SerializerProvider provider) throws IOException,
        JsonProcessingException {
    // value is never null, according to JsonSerializer contract
    jgen.writeBinary(value.array());
}
 

@Override
public void serialize(Byte[] value, JsonGenerator jgen, SerializerProvider provider) throws IOException {
    byte[] bytes = new byte[value.length];
    for (int i = 0; i < value.length; i++) {
        bytes[i] = value[i];
    }
    jgen.writeBinary(bytes);
}
 

@Override
public void serialize(UUID value, JsonGenerator gen, SerializerProvider provider)
    throws IOException
{
    // First: perhaps we could serialize it as raw binary data?
    if (gen.canWriteBinaryNatively()) {
        /* 07-Dec-2013, tatu: One nasty case; that of TokenBuffer. While it can
         *   technically retain binary data, we do not want to do use binary
         *   with it, as that results in UUIDs getting converted to Base64 for
         *   most conversions.
         */
        if (!(gen instanceof TokenBuffer)) {
            gen.writeBinary(_asBytes(value));
            return;
        }
    }
    
    // UUID.toString() works ok functionally, but we can make it go much faster
    // (by 4x with micro-benchmark)

    final char[] ch = new char[36];
    final long msb = value.getMostSignificantBits();
    _appendInt((int) (msb >> 32), ch, 0);
    ch[8] = '-';
    int i = (int) msb;
    _appendShort(i >>> 16, ch, 9);
    ch[13] = '-';
    _appendShort(i, ch, 14);
    ch[18] = '-';

    final long lsb = value.getLeastSignificantBits();
    _appendShort((int) (lsb >>> 48), ch, 19);
    ch[23] = '-';
    _appendShort((int) (lsb >>> 32), ch, 24);
    _appendInt((int) lsb, ch, 28);

    gen.writeString(ch, 0, 36);
}
 

private static SimpleModule getWriteBlobAsBase64Module() {
  JsonSerializer<Blob> dateSerializer = new JsonSerializer<Blob>() {
    @Override
    public void serialize(Blob value, JsonGenerator jgen, SerializerProvider provider)
        throws IOException {
      byte[] bytes = value.getBytes();
      jgen.writeBinary(bytes, 0, bytes.length);
    }
  };
  SimpleModule writeBlobAsBase64Module = new SimpleModule("writeBlobAsBase64Module",
      new Version(1, 0, 0, null, null, null));
  writeBlobAsBase64Module.addSerializer(Blob.class, dateSerializer);
  return writeBlobAsBase64Module;
}
 

/**
 * {@inheritDoc}
 */
@Override
public void serialize(X509Certificate value, JsonGenerator gen, SerializerProvider provider) throws IOException {
    try {
        gen.writeBinary(value.getEncoded());
    } catch (CertificateEncodingException e) {
        throw new UnexpectedCheckedException(e);
    }
}
 

@Override
public void serialize(byte[] value, JsonGenerator g, SerializerProvider provider)
    throws IOException
{
    g.writeBinary(provider.getConfig().getBase64Variant(),
            value, 0, value.length);
}
 

private void writeValue(Object obj, JsonGenerator gen) throws IOException {
    if (obj == null) {
        throw new IllegalStateException("Unexpected null value");
    } else if (obj instanceof String) {
        gen.writeString((String) obj);
    } else if (Number.class.isAssignableFrom(obj.getClass())) {
        if (obj instanceof Long) {
            gen.writeNumber((Long) obj);
        } else if (obj instanceof Integer) {
            gen.writeNumber((Integer) obj);
        } else if (obj instanceof Short) {
            gen.writeNumber((Short) obj);
        } else if (obj instanceof Double) {
            gen.writeNumber((Double) obj);
        } else if (obj instanceof Float) {
            gen.writeNumber((Float) obj);
        } else if (obj instanceof BigInteger) {
            gen.writeNumber((BigInteger) obj);
        } else if (obj instanceof BigDecimal) {
            gen.writeNumber((BigDecimal) obj);
        } else {
            throw new IllegalStateException("Unknown number value: " + obj);
        }
    } else if (obj instanceof Boolean) {
        gen.writeBoolean((Boolean) obj);
    } else if (obj instanceof byte[]) {
        gen.writeBinary((byte[]) obj);
    }
}
 

@Override
protected void doSerialize(Schema schema, JsonGenerator jgen, SerializerProvider provider)
        throws IOException
{
    ByteArrayOutputStream out = new ByteArrayOutputStream();
    MessageSerializer.serialize(new WriteChannel(Channels.newChannel(out)), schema);
    jgen.writeBinary(out.toByteArray());
}
 

@Override
protected void doSerialize(ArrowRecordBatch arrowRecordBatch, JsonGenerator jgen, SerializerProvider provider)
        throws IOException
{
    try {
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        MessageSerializer.serialize(new WriteChannel(Channels.newChannel(out)), arrowRecordBatch);
        jgen.writeBinary(out.toByteArray());
    }
    finally {
        arrowRecordBatch.close();
    }
}
 

@Override
public void serialize(BitSet value, JsonGenerator gen, SerializerProvider serializers) throws IOException {
    gen.writeBinary(value.toByteArray());
}
 

@Override
public void serialize(DoubleHistogram doubleHistogram, JsonGenerator jsonGenerator, SerializerProvider serializerProvider) throws IOException, JsonProcessingException {
    ByteBuffer allocate = ByteBuffer.allocate(doubleHistogram.getNeededByteBufferCapacity());
    doubleHistogram.encodeIntoByteBuffer(allocate);
    jsonGenerator.writeBinary(allocate.array());
}
 

@Override
public void serialize(X value, JsonGenerator gen, SerializerProvider provider) throws IOException {
  gen.writeBinary(ProtostuffIOUtil.toByteArray(value, schema, LinkedBuffer.allocate()));
  // JsonIOUtil.writeTo(gen, value, schema, false);
}
 

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

@Override
public void serialize(JWS<? extends Serializable> value, JsonGenerator gen, SerializerProvider provider) throws IOException {
    gen.writeBinary(value.getBytes());
}
 

@Override
public void serialize(AAGUID value, JsonGenerator gen, SerializerProvider provider) throws IOException {
    gen.writeBinary(value.getBytes());
}
 

@Override
public void serialize(TPMSAttest value, JsonGenerator gen, SerializerProvider provider) throws IOException {
    gen.writeBinary(value.getBytes());
}
 

@Override
public void serialize(ByteString value, JsonGenerator gen, SerializerProvider provider) throws IOException {
  gen.writeBinary(value.toByteArray());
}
 

@Override
public void serialize(byte [] value, JsonGenerator g) throws IOException, JsonGenerationException {
    g.writeBinary(value);
}
 

@Override
public void serialize(ByteBuf byteBuf, JsonGenerator gen, SerializerProvider serializers) throws IOException {

    byteBuf.resetReaderIndex();

    ByteBufInputStream inputStream = new ByteBufInputStream(byteBuf);
    gen.writeBinary(inputStream, byteBuf.writerIndex());

}