path: root/document/src/main/java/com/yahoo/document/json/JsonWriter.java

// Copyright 2016 Yahoo Inc. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
package com.yahoo.document.json;

import com.fasterxml.jackson.core.JsonFactory;
import com.fasterxml.jackson.core.JsonGenerator;
import com.yahoo.document.Document;
import com.yahoo.document.DocumentId;
import com.yahoo.document.DocumentType;
import com.yahoo.document.Field;
import com.yahoo.document.annotation.AnnotationReference;
import com.yahoo.document.datatypes.Array;
import com.yahoo.document.datatypes.ByteFieldValue;
import com.yahoo.document.datatypes.CollectionFieldValue;
import com.yahoo.document.datatypes.DoubleFieldValue;
import com.yahoo.document.datatypes.FieldValue;
import com.yahoo.document.datatypes.FloatFieldValue;
import com.yahoo.document.datatypes.IntegerFieldValue;
import com.yahoo.document.datatypes.LongFieldValue;
import com.yahoo.document.datatypes.MapFieldValue;
import com.yahoo.document.datatypes.PredicateFieldValue;
import com.yahoo.document.datatypes.Raw;
import com.yahoo.document.datatypes.StringFieldValue;
import com.yahoo.document.datatypes.Struct;
import com.yahoo.document.datatypes.StructuredFieldValue;
import com.yahoo.document.datatypes.TensorFieldValue;
import com.yahoo.document.datatypes.WeightedSet;
import com.yahoo.document.serialization.DocumentWriter;
import com.yahoo.vespa.objects.FieldBase;
import com.yahoo.vespa.objects.Serializer;
import edu.umd.cs.findbugs.annotations.NonNull;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.nio.ByteBuffer;
import java.util.Iterator;
import java.util.Map;

import static com.yahoo.document.json.JsonSerializationHelper.*;

/**
 * Serialize Document and other FieldValue instances as JSON.
 *
 * @author <a href="mailto:steinar@yahoo-inc.com">Steinar Knutsen</a>
 */
public class JsonWriter implements DocumentWriter {

    private static final JsonFactory jsonFactory = new JsonFactory();
    private final JsonGenerator generator;

    // I really hate exception unsafe constructors, but the alternative
    // requires generator to not be a final
    /**
     *
     * @param out
     *            the target output stream
     * @throws RuntimeException
     *             if unable to create the internal JSON generator
     */
    public JsonWriter(OutputStream out) {
        this(createPrivateGenerator(out));
    }

    private static JsonGenerator createPrivateGenerator(OutputStream out) {
        try {
            return jsonFactory.createGenerator(out);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * Create a Document writer which will write to the input JSON generator.
     * JsonWriter will not close the generator and only flush it explicitly
     * after having written a full Document instance. In other words, JsonWriter
     * will <i>not</i> take ownership of the generator.
     *
     * @param generator
     *            the output JSON generator
     */
    public JsonWriter(JsonGenerator generator) {
        this.generator = generator;
    }

    /**
     * This method will only be called if there is some type which is not
     * properly supported in the API, or if something has been changed without
     * updating this class. This implementation throws an exception if it is
     * reached.
     *
     * @throws UnsupportedOperationException
     *             if invoked
     */
    @Override
    public void write(FieldBase field, FieldValue value) {
        throw new UnsupportedOperationException("Serializing " + value.getClass().getName() + " is not supported.");
    }

    @Override
    public void write(FieldBase field, Document value) {
        try {
            fieldNameIfNotNull(generator, field);
            generator.writeStartObject();

            // this makes it impossible to refeed directly, not sure what's correct
            // perhaps just change to "put"?
            generator.writeStringField("id", value.getId().toString());
            generator.writeObjectFieldStart(JsonReader.FIELDS);

            Iterator<Map.Entry<Field, FieldValue>> i = value.iterator();
            while (i.hasNext()) {
                Map.Entry<Field, FieldValue> entry = i.next();
                entry.getValue().serialize(entry.getKey(), this);
            }
            generator.writeEndObject();
            generator.writeEndObject();
            generator.flush();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    @Override
    public <T extends FieldValue> void write(FieldBase field, Array<T> value) {
        serializeArrayField(this, generator, field, value);
    }

    @Override
    public <K extends FieldValue, V extends FieldValue> void write(FieldBase field, MapFieldValue<K, V> map) {
        serializeMapField(this, generator, field, map);
    }

    @Override
    public void write(FieldBase field, ByteFieldValue value) {
        serializeByteField(generator, field, value);
    }

    @Override
    public <T extends FieldValue> void write(FieldBase field, CollectionFieldValue<T> value) {
        serializeCollectionField(this, generator, field, value);
    }

    @Override
    public void write(FieldBase field, DoubleFieldValue value) {
        serializeDoubleField(generator, field, value);
    }

    @Override
    public void write(FieldBase field, FloatFieldValue value) {
        serializeFloatField(generator, field, value);
    }

    @Override
    public void write(FieldBase field, IntegerFieldValue value) {
        serializeIntField(generator, field, value);
    }

    @Override
    public void write(FieldBase field, LongFieldValue value) {
        serializeLongField(generator, field, value);
    }

    @Override
    public void write(FieldBase field, Raw value) {
        serializeRawField(generator, field, value);
    }

    @Override
    public void write(FieldBase field, PredicateFieldValue value) {
        serializePredicateField(generator, field, value);
    }

    @Override
    public void write(FieldBase field, StringFieldValue value) {
        serializeStringField(generator, field, value);
    }

    @Override
    public void write(FieldBase field, TensorFieldValue value) {
        serializeTensorField(generator, field, value);
    }

    @Override
    public void write(FieldBase field, Struct value) {
        serializeStructField(this, generator, field, value);
    }

    @Override
    public void write(FieldBase field, StructuredFieldValue value) {
        serializeStructuredField(this, generator, field, value);
    }

    @Override
    public <T extends FieldValue> void write(FieldBase field, WeightedSet<T> value) {
        serializeWeightedSet(generator, field, value);
    }

    @Override
    public void write(FieldBase field, AnnotationReference value) {
        // not yet implemented, it's not available in XML either
        // TODO implement
    }

    @Override
    public void write(Document document) {
        write(null, document);
    }

    @Override
    public void write(DocumentId id) {
        // NOP, fetched from Document
    }

    @Override
    public void write(DocumentType type) {
        // NOP, fetched from Document
    }

    /**
     * Utility method to easily serialize a single document.
     *
     * @param document
     *            the document to be serialized
     * @return the input document serialised as UTF-8 encoded JSON
     */
    public static byte[] toByteArray(@NonNull Document document) {
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        JsonWriter writer = new JsonWriter(out);
        writer.write(document);
        return out.toByteArray();
    }

    /**
     * Utility method to easily serialize a single document ID as a remove
     * operation.
     *
     * @param docId
     *            the document to remove or which has been removed
     * @return a document remove operation serialised as UTF-8 encoded JSON for
     *         the input document ID
     */
    public static byte[] documentRemove(@NonNull DocumentId docId) {
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        try {
            JsonGenerator throwAway = jsonFactory.createGenerator(out);
            throwAway.writeStartObject();
            throwAway.writeStringField(JsonReader.REMOVE, docId.toString());
            throwAway.writeEndObject();
            throwAway.close();
        } catch (IOException e) {
            // Under normal circumstances, nothing here will be triggered
            throw new RuntimeException(e);
        }
        return out.toByteArray();
    }

    @Override
    public Serializer putByte(FieldBase field, byte value) {
        serializeByte(generator, field, value);
        return this;
    }

    @Override
    public Serializer putShort(FieldBase field, short value) {
        serializeShort(generator, field, value);
        return this;
    }

    @Override
    public Serializer putInt(FieldBase field, int value) {
        serializeInt(generator, field, value);
        return this;
    }

    @Override
    public Serializer putLong(FieldBase field, long value) {
        serializeLong(generator, field, value);
        return this;
    }

    @Override
    public Serializer putFloat(FieldBase field, float value) {
        serializeFloat(generator, field, value);
        return this;
    }

    @Override
    public Serializer putDouble(FieldBase field, double value) {
        serializeDouble(generator, field, value);
        return this;
    }

    @Override
    public Serializer put(FieldBase field, byte[] value) {
        serializeByteArray(generator, field, value);
        return this;
    }

    @Override
    public Serializer put(FieldBase field, ByteBuffer value) {
        serializeByteBuffer(generator, field, value);
        return this;
    }

    @Override
    public Serializer put(FieldBase field, String value) {
        serializeString(generator, field, value);
        return this;
    }
}