private static void writeValue(VespaDocumentSerializer42 serializer, DataType dataType, Object value) { FieldValue fieldValue; if (value instanceof FieldValue) { fieldValue = (FieldValue)value; } else { fieldValue = dataType.createFieldValue(value); } fieldValue.serialize(serializer); }
private static void writeValue(VespaDocumentSerializer6 serializer, DataType dataType, Object value) { FieldValue fieldValue; if (value instanceof FieldValue) { fieldValue = (FieldValue)value; } else { fieldValue = dataType.createFieldValue(value); } fieldValue.serialize(serializer); }
@Override public void write(AddValueUpdate update, DataType superType) { update.getValue().serialize(this); }
@Override public void write(RemoveValueUpdate update, DataType superType) { update.getValue().serialize(null, this); }
final public void serialize(GrowableByteBuffer buf) { serialize(DocumentSerializerFactory.create6(buf)); }
public static <T extends FieldValue> void serializeCollectionField(FieldWriter fieldWriter, JsonGenerator generator, FieldBase field, CollectionFieldValue<T> value) { fieldNameIfNotNull(generator, field); wrapIOException(() -> { generator.writeStartArray(); Iterator<T> i = value.iterator(); while (i.hasNext()) { i.next().serialize(null, fieldWriter); } generator.writeEndArray(); }); }
public static void serializeStructuredField(FieldWriter fieldWriter, JsonGenerator generator, FieldBase field, StructuredFieldValue value) { fieldNameIfNotNull(generator, field); wrapIOException(() -> { generator.writeStartObject(); Iterator<Map.Entry<Field, FieldValue>> i = value.iterator(); while (i.hasNext()) { Map.Entry<Field, FieldValue> entry = i.next(); entry.getValue().serialize(entry.getKey(), fieldWriter); } generator.writeEndObject(); }); }
public static <T extends FieldValue> void serializeArrayField(FieldWriter fieldWriter, JsonGenerator generator, FieldBase field, Array<T> value) { wrapIOException(() -> { fieldNameIfNotNull(generator, field); generator.writeStartArray(); for (T elem : value) { elem.serialize(null, fieldWriter); } generator.writeEndArray(); }); }
@Override public void write(AssignValueUpdate update, DataType superType) { wrapIOException(() -> generator.writeFieldName("assign")); update.getValue().serialize(null, this); }
@Override public void onSerialize(Serializer target) { if (target instanceof FieldWriter) { serialize(null, (FieldWriter) target); } else if (target instanceof BufferSerializer) { serialize(null, DocumentSerializerFactory.create6(((BufferSerializer) target).getBuf())); } else { DocumentSerializer fw = DocumentSerializerFactory.create6(new GrowableByteBuffer()); serialize(null, fw); target.put(null, fw.getBuf().getByteBuffer()); } }
@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(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); } }
public static <K extends FieldValue, V extends FieldValue> void serializeMapField(FieldWriter fieldWriter, JsonGenerator generator, FieldBase field, MapFieldValue<K, V> map) { fieldNameIfNotNull(generator, field); wrapIOException(() -> { generator.writeStartObject(); for (Map.Entry<K, V> entry : map.entrySet()) { K key = entry.getKey(); DataType keyType = key.getDataType(); if ( ! (keyType instanceof PrimitiveDataType)) { throw new IllegalArgumentException("Can't use complex types as keys for map fields. Type: " + keyType); } generator.writeFieldName(key.toString()); entry.getValue().serialize(null, fieldWriter); } generator.writeEndObject(); }); }
/** * Write out the value of array field * * @param field - field description (name and data type) * @param array - field value */ public <T extends FieldValue> void write(FieldBase field, Array<T> array) { buf.putInt1_2_4Bytes(array.size()); List<T> lst = array.getValues(); for (FieldValue value : lst) { value.serialize(this); } }
@Override public void write(MapValueUpdate update, DataType superType) { wrapIOException(() -> { generator.writeObjectFieldStart("match"); generator.writeFieldName("element"); update.getValue().serialize(null, this); update.getUpdate().serialize(this, superType); generator.writeEndObject(); }); }
/** * Write out the value of array field * * @param field - field description (name and data type) * @param array - field value */ public <T extends FieldValue> void write(FieldBase field, Array<T> array) { buf.putInt1_2_4Bytes(array.size()); List<T> lst = array.getValues(); for (FieldValue value : lst) { value.serialize(this); } }
private void write(FieldPath fieldPath, Collection<FieldPathUpdate> fieldPathUpdates, JsonGenerator generator) throws IOException { generator.writeObjectFieldStart(fieldPath.toString()); for (FieldPathUpdate update : fieldPathUpdates) { if (writeArithmeticFieldPathUpdate(update, generator)) continue; generator.writeFieldName(update.getUpdateType().name().toLowerCase()); if (update instanceof AssignFieldPathUpdate) { AssignFieldPathUpdate assignUp = (AssignFieldPathUpdate) update; if (assignUp.getExpression() != null) { throw new RuntimeException("Unable to parse expression: " + assignUp.getExpression()); } else { assignUp.getNewValue().serialize(null, this); } } else if (update instanceof AddFieldPathUpdate) { ((AddFieldPathUpdate) update).getNewValues().serialize(null, this); } else if (update instanceof RemoveFieldPathUpdate) { generator.writeNumber(0); } else { throw new RuntimeException("Unsupported fieldpath operation: " + update.getClass().getName()); } } generator.writeEndObject(); }
public void write(AssignFieldPathUpdate update) { write((FieldPathUpdate)update); byte flags = 0; if (update.getRemoveIfZero()) { flags |= AssignFieldPathUpdate.REMOVE_IF_ZERO; } if (update.getCreateMissingPath()) { flags |= AssignFieldPathUpdate.CREATE_MISSING_PATH; } if (update.isArithmetic()) { flags |= AssignFieldPathUpdate.ARITHMETIC_EXPRESSION; putByte(null, flags); put(null, update.getExpression()); } else { putByte(null, flags); update.getFieldValue().serialize(this); } }
/** * Write out the value of weighted set field * * @param field - field description (name and data type) * @param ws - field value */ public <T extends FieldValue> void write(FieldBase field, WeightedSet<T> ws) { WeightedSetDataType type = ws.getDataType(); putInt(null, type.getNestedType().getId()); putInt(null, ws.size()); Iterator<T> it = ws.fieldValueIterator(); while (it.hasNext()) { FieldValue key = it.next(); java.lang.Integer value = ws.get(key); int sizePos = buf.position(); putInt(null, 0); int startPos = buf.position(); key.serialize(this); putInt(null, value); int finalPos = buf.position(); int size = finalPos - startPos; buf.position(sizePos); putInt(null, size); buf.position(finalPos); } }