Java Code Examples for org.apache.flink.core.memory.DataOutputView#writeInt()

@Override
public void copy(
		DataInputView source, DataOutputView target) throws IOException {
	TXN pendingTxnHandle = transactionSerializer.deserialize(source);
	transactionSerializer.serialize(pendingTxnHandle, target);
	final long pendingTxnStartTime = source.readLong();
	target.writeLong(pendingTxnStartTime);

	int numPendingCommitTxns = source.readInt();
	target.writeInt(numPendingCommitTxns);
	for (int i = 0; i < numPendingCommitTxns; i++) {
		TXN pendingCommitTxnHandle = transactionSerializer.deserialize(source);
		transactionSerializer.serialize(pendingCommitTxnHandle, target);
		final long pendingCommitTxnStartTime = source.readLong();
		target.writeLong(pendingCommitTxnStartTime);
	}

	boolean hasContext = source.readBoolean();
	target.writeBoolean(hasContext);
	if (hasContext) {
		CONTEXT context = contextSerializer.deserialize(source);
		contextSerializer.serialize(context, target);
	}
}
 

@Override
public void serialize(Map<K, V> map, DataOutputView target) throws IOException {
	final int size = map.size();
	target.writeInt(size);

	for (Map.Entry<K, V> entry : map.entrySet()) {
		if (entry.getKey() == null) {
			target.writeBoolean(true);
		} else {
			target.writeBoolean(false);
			keySerializer.serialize(entry.getKey(), target);
		}

		if (entry.getValue() == null) {
			target.writeBoolean(true);
		} else {
			target.writeBoolean(false);
			valueSerializer.serialize(entry.getValue(), target);
		}
	}
}
 

/**
 * Implementation note: we currently chose the same format between {@link NestedMapsStateTable} and
 * {@link CopyOnWriteStateTable}.
 *
 * <p>{@link NestedMapsStateTable} could naturally support a kind of
 * prefix-compressed format (grouping by namespace, writing the namespace only once per group instead for each
 * mapping). We might implement support for different formats later (tailored towards different state table
 * implementations).
 */
@Override
public void writeStateInKeyGroup(@Nonnull DataOutputView dov, int keyGroupId) throws IOException {
	final Map<N, Map<K, S>> keyGroupMap = owningStateTable.getMapForKeyGroup(keyGroupId);
	if (null != keyGroupMap) {
		Map<N, Map<K, S>> filteredMappings = filterMappingsInKeyGroupIfNeeded(keyGroupMap);
		dov.writeInt(countMappingsInKeyGroup(filteredMappings));
		for (Map.Entry<N, Map<K, S>> namespaceEntry : filteredMappings.entrySet()) {
			final N namespace = namespaceEntry.getKey();
			final Map<K, S> namespaceMap = namespaceEntry.getValue();
			for (Map.Entry<K, S> keyEntry : namespaceMap.entrySet()) {
				writeElement(namespace, keyEntry, dov);
			}
		}
	} else {
		dov.writeInt(0);
	}
}
 

@Override
public void serialize(TestType record, DataOutputView target) throws IOException {
	target.writeUTF(record.getKey());
	target.writeUTF(RANDOM_PAYLOAD);
	target.writeInt(record.getValue());
	target.writeBoolean(true);
}
 

@Override
public void write(DataOutputView out) throws IOException {
	out.writeInt(position);

	for (int i = 0; i < position; i++) {
		out.writeFloat(data[i]);
	}
}
 

@Override
public void serialize(ArrayList<T> list, DataOutputView target) throws IOException {
	final int size = list.size();
	target.writeInt(size);
	for (int i = 0; i < size; i++) {
		elementSerializer.serialize(list.get(i), target);
	}
}
 

private static <T> void writeFramed(DataOutputView out, BiConsumerWithException<DataOutputView, T, IOException> writer, T item) throws IOException {
	DataOutputSerializer frame = new DataOutputSerializer(64);
	writer.accept(frame, item);

	final byte[] buffer = frame.getSharedBuffer();
	final int bufferSize = frame.length();
	out.writeInt(bufferSize);
	out.write(buffer, 0, bufferSize);
}
 

public static boolean copyBigInteger(DataInputView source, DataOutputView target) throws IOException {
	final int len = source.readInt();
	target.writeInt(len);
	if (len > 4) {
		target.write(source, len - 4);
	}
	return len == 0; // returns true if the copied record was null
}
 

@Override
public void serialize(int[] record, DataOutputView target) throws IOException {
	if (record == null) {
		throw new IllegalArgumentException("The record must not be null.");
	}
	
	final int len = record.length;
	target.writeInt(len);
	for (int i = 0; i < len; i++) {
		target.writeInt(record[i]);
	}
}
 

@Override
public void serialize(byte[] record, DataOutputView target) throws IOException {
  if (record == null) {
    throw new IllegalArgumentException("The record must not be null.");
  }

  final int len = record.length;
  target.writeInt(len);
  target.write(record);
}
 

public void serialize(M record, DataOutputView target) throws IOException {
  final int size = record.getSerializedSize();
  target.writeInt(size);

  output.set(target);
  try {
    record.writeTo(output);
  } finally {
    output.done();
  }
}
 

@Override
public void copy(DataInputView source, DataOutputView target) throws IOException {
	final int len = source.readInt();
	target.writeInt(len);
	
	for (int i = 0; i < len; i++) {
		StringValue.copyString(source, target);
	}
}
 

@Override
public void copy(DataInputView source, DataOutputView target) throws IOException {
	final int len = source.readInt();
	target.writeInt(len);
	target.write(source, len);
}
 

@Override
public void copy(DataInputView source, DataOutputView target) throws IOException {
	int length = source.readInt();
	target.writeInt(length);
	target.write(source, length);
}
 

@Override
public void serialize(T record, DataOutputView target) throws IOException {
	// use our own maintained ordinals instead of the actual enum ordinal
	target.writeInt(valueToOrdinal.get(record));
}
 

@Override
public void write(DataOutputView out) throws IOException {
	out.writeInt(this.value);
}
 

@Override
public void serialize(EventId record, DataOutputView target) throws IOException {
	target.writeInt(record.id);
	target.writeLong(record.timestamp);
}
 

@Override
public void write(final DataOutputView out) throws IOException {
	out.writeInt(this.value);
}
 

@Override
public void serialize(Integer record, DataOutputView target) throws IOException {
	target.writeInt(MAGIC_VALUE);
	target.writeInt(record);
}
 

@Override
public void write(DataOutputView out) throws IOException {
	out.writeInt(this.value);
}