Module org.elasticsearch.server

Package org.elasticsearch.common.io.stream

Class StreamOutput

java.lang.Object

java.io.OutputStream

org.elasticsearch.common.io.stream.StreamOutput

All Implemented Interfaces:

Closeable, Flushable, AutoCloseable

Direct Known Subclasses:

BufferedChecksumStreamOutput, BufferedStreamOutput, BytesRefStreamOutput, BytesStream, CountingStreamOutput, OutputStreamStreamOutput, VersionCheckingStreamOutput

public abstract class StreamOutput
extends OutputStream

A stream into which a structured Writeable may be written, e.g. for sending over a transport connection to a remote node.

This class's methods are optimized so you can put the methods that read and write a class next to each other and you can scan them visually for differences. That means that most variables should be read and written in a single line so even large objects fit both reading and writing on the screen. It also means that the methods on this class are named very similarly to StreamInput. Finally it means that the "barrier to entry" for adding new methods to this class is relatively low even though it is a shared class with code everywhere. That being said, this class deals primarily with Lists rather than Arrays. For the most part calls should adapt to lists, either by storing Lists internally or just converting to and from a List when calling. This comment is repeated on StreamInput.

It is possible to use a StreamOutput as an adapter to send a Writeable to a raw-bytes OutputStream such as a file or a compressing stream, for instance using OutputStreamStreamOutput or BufferedStreamOutput. Often, however, we want to capture the serialized representation of an object in memory as a byte[] or more generally a BytesReference (a sequence of slices of byte[]s). For example, this is how the org.elasticsearch.transport subsystem prepares a network message for transmission. There are several different ways to achieve this objective, with different performance characteristics, as described in the documentation for the following classes.

• BytesStreamOutput
• ReleasableBytesStreamOutput
• RecyclerBytesStreamOutput
• BufferedStreamOutput

Field Summary

Fields

Modifier and Type	Field	Description
static final byte	GENERIC_LIST_HEADER

Constructor Summary

Constructors

Constructor	Description
StreamOutput()

Method Summary

Modifier and Type	Method	Description
static void	checkWriteable(Object value)
abstract void	close()	Closes this stream to further operations.
abstract void	flush()	Forces any buffered output to be written.
TransportVersion	getTransportVersion()	The transport version to serialize the data as.
void	legacyWriteWithSizePrefix(Writeable writeable)	Deprecated. use writeWithSizePrefix(org.elasticsearch.common.io.stream.Writeable) instead
abstract long	position()
void	setTransportVersion(TransportVersion version)	Set the transport version of the data in this stream.
void	write(byte[] b, int off, int len)
void	write(int b)
<T> void	writeArray(Writeable.Writer<T> writer, T[] array)	Writes the specified array to the stream using the specified Writeable.Writer for each element in the array.
<T extends Writeable> void	writeArray(T[] array)	Writes the specified array of Writeables.
void	writeBigInteger(BigInteger bigInteger)	Write a BigInteger to the stream
void	writeBoolean(boolean b)	Writes a boolean.
abstract void	writeByte(byte b)	Writes a single byte.
void	writeByteArray(byte[] b)	Writes an array of bytes.
void	writeBytes(byte[] b)	Writes an array of bytes.
void	writeBytes(byte[] b, int length)	Writes an array of bytes.
abstract void	writeBytes(byte[] b, int offset, int length)	Writes an array of bytes.
void	writeBytesRef(org.apache.lucene.util.BytesRef bytes)
void	writeBytesReference(BytesReference bytes)	Writes the bytes reference, including a length header.
void	writeCollection(Collection<? extends Writeable> collection)	Writes a collection which can then be read using StreamInput.readCollectionAsList(org.elasticsearch.common.io.stream.Writeable.Reader<T>) or another readCollectionAs* method.
<T> void	writeCollection(Collection<T> collection, Writeable.Writer<T> writer)	Writes a collection which can then be read using StreamInput.readCollectionAsList(org.elasticsearch.common.io.stream.Writeable.Reader<T>) or another readCollectionAs* method.
void	writeDouble(double v)
void	writeDoubleArray(double[] values)
void	writeDoubleLE(double v)
<E extends Enum<E>> void	writeEnum(E enumValue)	Writes an enum with type E in terms of the value of its ordinal.
<E extends Enum<E>> void	writeEnumSet(EnumSet<E> enumSet)	Writes a set of enum with type E in terms of the value of its ordinal.
void	writeException(Throwable throwable)
void	writeFloat(float v)
void	writeFloatArray(float[] values)
<T> void	writeGenericList(List<T> v, Writeable.Writer<T> writer)
void	writeGenericMap(Map<String,Object> map)
void	writeGenericNull()
abstract void	writeGenericString(String value)	Write a String within writeGenericValue(java.lang.Object), represented as the type code byte 0 followed by the string itself written as if with writeString(java.lang.String).
void	writeGenericValue(Object value)	Notice: when serialization a map, the stream out map with the stream in map maybe have the different key-value orders, they will maybe have different stream order.
void	writeGeoPoint(GeoPoint geoPoint)	Writes the given GeoPoint to the stream
final void	writeInstant(Instant instant)	Writes an Instant to the stream with nanosecond resolution
void	writeInt(int i)	Writes an int as four bytes.
void	writeIntArray(int[] values)
void	writeIntLE(int i)	Writes an int as four bytes, least significant bytes first.
void	writeLong(long i)	Writes a long as eight bytes.
void	writeLongArray(long[] values)
void	writeLongLE(long i)	Writes a long as eight bytes.
final <V> void	writeMap(Map<String,V> map, Writeable.Writer<V> valueWriter)	Same as writeMap(Map, Writer, Writer) but for String keys.
final <K extends Writeable, V extends Writeable> void	writeMap(Map<K,V> map)	Write a Map of K-type keys to V-type.
final <K, V> void	writeMap(Map<K,V> map, Writeable.Writer<K> keyWriter, Writeable.Writer<V> valueWriter)	Write a Map of K-type keys to V-type.
final <V extends Writeable> void	writeMapValues(Map<?,V> map)	Writes values of a map as a collection
final <V> void	writeMapValues(Map<?,V> map, Writeable.Writer<V> valueWriter)	Writes values of a map as a collection
void	writeMapWithConsistentOrder(Map<String,? extends Object> map)	write map to stream with consistent order to make sure every map generated bytes order are same.
void	writeMissingString()	Similar to writeOptionalString(java.lang.String) but for use when the value is always missing.
<T extends Writeable> void	writeMissingWriteable(Class<T> ignored)	Similar to writeOptionalWriteable(org.elasticsearch.common.io.stream.Writeable) but for use when the value is always missing.
void	writeNamedWriteable(NamedWriteable namedWriteable)	Writes a NamedWriteable to the current stream, by first writing its name and then the object itself
void	writeNamedWriteableCollection(Collection<? extends NamedWriteable> list)	Writes a collection of NamedWriteable objects which can then be read using StreamInput.readNamedWriteableCollectionAsList(java.lang.Class<T>).
<T> void	writeOptional(Writeable.Writer<T> writer, T maybeItem)	Writes a boolean value indicating whether the given object is null, followed by the object's serialization if it is not null.
<T> void	writeOptionalArray(Writeable.Writer<T> writer, T[] array)	Same as writeArray(Writer, Object[]) but the provided array may be null.
<T extends Writeable> void	writeOptionalArray(T[] array)	Same as writeArray(Writeable[]) but the provided array may be null.
void	writeOptionalBoolean(Boolean b)
void	writeOptionalByteArray(byte[] array)	Writes a byte array, for null arrays it writes false.
void	writeOptionalBytesReference(BytesReference bytes)	Writes an optional bytes reference including a length header.
<T extends Writeable> void	writeOptionalCollection(Collection<T> collection)	Writes a possibly-null collection which can then be read using StreamInput.readOptionalCollectionAsList(org.elasticsearch.common.io.stream.Writeable.Reader<T>).
<T> void	writeOptionalCollection(Collection<T> collection, Writeable.Writer<T> writer)	Writes a possibly-null collection which can then be read using StreamInput.readOptionalCollectionAsList(org.elasticsearch.common.io.stream.Writeable.Reader<T>).
void	writeOptionalDouble(Double v)
<E extends Enum<E>> void	writeOptionalEnum(E enumValue)	Writes an optional enum with type E in terms of the value of its ordinal.
void	writeOptionalException(Throwable throwable)	Write an optional Throwable to the stream.
void	writeOptionalFloat(Float floatValue)
void	writeOptionalFloatArray(float[] array)	Writes a float array, for null arrays it writes false.
final void	writeOptionalInstant(Instant instant)	Writes an Instant to the stream, which could possibly be null
void	writeOptionalInt(Integer integer)	Writes an optional Integer.
void	writeOptionalLong(Long l)
final <K, V> void	writeOptionalMap(Map<K,V> map, Writeable.Writer<K> keyWriter, Writeable.Writer<V> valueWriter)	Write an optional Map of K-type keys to V-type.
void	writeOptionalNamedWriteable(NamedWriteable namedWriteable)	Write an optional NamedWriteable to the stream.
void	writeOptionalNamedWriteableCollection(Collection<? extends NamedWriteable> list)	Writes a possibly-null collection of NamedWriteable objects which can then be read using StreamInput.readOptionalNamedWriteableCollectionAsList(java.lang.Class<T>).
void	writeOptionalSecureString(SecureString secureStr)
abstract void	writeOptionalString(String str)	Write a possibly-null String, represented as a invalid reference boolean which is false if the string is null, or else true if it is not null, and in this latter case it is followed by the string itself written as if with writeString(java.lang.String).
void	writeOptionalStringArray(String[] array)	Writes a string array, for nullable string, writes false.
void	writeOptionalStringCollection(Collection<String> collection)	Writes a possibly-null collection of strings which can then be read using StreamInput.readOptionalStringCollectionAsList().
void	writeOptionalText(Text text)
void	writeOptionalTimeValue(TimeValue timeValue)	Write an optional TimeValue to the stream.
void	writeOptionalVInt(Integer integer)
void	writeOptionalVLong(Long l)
void	writeOptionalWriteable(Writeable writeable)	Writes a boolean value indicating whether the given object is null, followed by the object's serialization if it is not null.
void	writeOptionalZoneId(ZoneId timeZone)	Write an optional ZoneId to the stream.
void	writeSecureString(SecureString secureStr)
void	writeShort(short v)
abstract void	writeString(String str)	Write a String: its length in Unicode code units (chars) (NB not bytes) written using writeVInt(int) followed by the sequence of characters themselves encoded as UTF-8.
void	writeStringArray(String[] array)
void	writeStringArrayNullable(String[] array)	Writes a string array, for nullable string, writes it as 0 (empty string).
void	writeStringCollection(Collection<String> collection)	Writes a collection of strings which can then be read using StreamInput.readStringCollectionAsList() or another readStringCollectionAs* method.
void	writeText(Text text)
void	writeTimeValue(TimeValue timeValue)	Write a TimeValue to the stream
void	writeVInt(int i)	Writes an int in a variable-length format.
void	writeVIntArray(int[] values)
void	writeVLong(long i)	Writes a non-negative long in a variable-length format.
void	writeVLongArray(long[] values)
void	writeWithSizePrefix(Writeable writeable)	Serializes a writable just like Writeable.writeTo(StreamOutput) would but also compresses and prefixes it with the serialized size of the result.
void	writeWriteable(Writeable writeable)	This method allow to use a method reference when writing collection elements such as out.writeMap(map, StreamOutput::writeString, StreamOutput::writeWriteable)
void	writeZLong(long i)	Writes a long in a variable-length format.
void	writeZoneId(ZoneId timeZone)	Write a ZoneId to the stream.

Methods inherited from class java.io.OutputStream

nullOutputStream, write

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Details

GENERIC_LIST_HEADER

public static final byte GENERIC_LIST_HEADER

See Also:

• Constant Field Values

Constructor Details

StreamOutput

public StreamOutput()

Method Details

getTransportVersion

public TransportVersion getTransportVersion()

The transport version to serialize the data as.

setTransportVersion

public void setTransportVersion(TransportVersion version)

Set the transport version of the data in this stream.

position

public abstract long position()

Returns:

the current position of the stream, in bytes. Increases as data is written to the stream. If the stream is seekable then the seek operation updates the current position().

writeByte

public abstract void writeByte(byte b)
                        throws IOException

Writes a single byte.

Throws:

IOException

writeBytes

public void writeBytes(byte[] b)
                throws IOException

Writes an array of bytes.

Parameters:

b - the bytes to write

Throws:

IOException

writeBytes

public void writeBytes(byte[] b,
 int length)
                throws IOException

Writes an array of bytes.

Parameters:

b - the bytes to write

length - the number of bytes to write

Throws:

IOException

writeBytes

public abstract void writeBytes(byte[] b,
 int offset,
 int length)
                         throws IOException

Writes an array of bytes.

Parameters:

b - the bytes to write

offset - the offset in the byte array

length - the number of bytes to write

Throws:

IOException

writeByteArray

public void writeByteArray(byte[] b)
                    throws IOException

Writes an array of bytes.

Parameters:

b - the bytes to write

Throws:

IOException

legacyWriteWithSizePrefix

@Deprecated
public void legacyWriteWithSizePrefix(Writeable writeable)
                               throws IOException

Deprecated.

use writeWithSizePrefix(org.elasticsearch.common.io.stream.Writeable) instead

Serializes a writable just like Writeable.writeTo(StreamOutput) would but prefixes it with the serialized size of the result.

Parameters:

writeable - Writeable to serialize

Throws:

IOException

writeWithSizePrefix

public void writeWithSizePrefix(Writeable writeable)
                         throws IOException

Serializes a writable just like Writeable.writeTo(StreamOutput) would but also compresses and prefixes it with the serialized size of the result.

Parameters:

writeable - Writeable to serialize

Throws:

IOException

writeBytesReference

public void writeBytesReference(@Nullable
 BytesReference bytes)
                         throws IOException

Writes the bytes reference, including a length header.

Throws:

IOException

writeOptionalBytesReference

public void writeOptionalBytesReference(@Nullable
 BytesReference bytes)
                                 throws IOException

Writes an optional bytes reference including a length header. Use this if you need to differentiate between null and empty bytes references. Use writeBytesReference(BytesReference) and StreamInput.readBytesReference() if you do not.

Throws:

IOException

writeBytesRef

public void writeBytesRef(org.apache.lucene.util.BytesRef bytes)
                   throws IOException

Throws:

IOException

writeShort

public void writeShort(short v)
                throws IOException

Throws:

IOException

writeInt

public void writeInt(int i)
              throws IOException

Writes an int as four bytes.

Throws:

IOException

writeIntLE

public void writeIntLE(int i)
                throws IOException

Writes an int as four bytes, least significant bytes first.

Throws:

IOException

writeVInt

public void writeVInt(int i)
               throws IOException

Writes an int in a variable-length format. Writes between one and five bytes. Smaller values take fewer bytes. Negative numbers will always use all 5 bytes and are therefore better serialized using writeInt(int)

Throws:

IOException

writeLong

public void writeLong(long i)
               throws IOException

Writes a long as eight bytes.

Throws:

IOException

writeLongLE

public void writeLongLE(long i)
                 throws IOException

Writes a long as eight bytes.

Throws:

IOException

writeVLong

public void writeVLong(long i)
                throws IOException

Writes a non-negative long in a variable-length format. Writes between one and ten bytes. Smaller values take fewer bytes. Negative numbers use ten bytes and trip assertions (if running in tests) so prefer writeLong(long) or writeZLong(long) for negative numbers.

Throws:

IOException

writeOptionalVLong

public void writeOptionalVLong(@Nullable
 Long l)
                        throws IOException

Throws:

IOException

writeZLong

public void writeZLong(long i)
                throws IOException

Writes a long in a variable-length format. Writes between one and ten bytes. Values are remapped by sliding the sign bit into the lsb and then encoded as an unsigned number e.g., 0 -;> 0, -1 -;> 1, 1 -;> 2, ..., Long.MIN_VALUE -;> -1, Long.MAX_VALUE -;> -2 Numbers with small absolute value will have a small encoding If the numbers are known to be non-negative, use writeVLong(long)

Throws:

IOException

writeOptionalLong

public void writeOptionalLong(@Nullable
 Long l)
                       throws IOException

Throws:

IOException

writeOptionalString

public abstract void writeOptionalString(@Nullable
 String str)
                                  throws IOException

Write a possibly-null String, represented as a

invalid reference

boolean

which is false if the string is null, or else true if it is not null, and in this latter case it is followed by the string itself written as if with writeString(java.lang.String).

May be performance-critical, so subclasses must specify an explicit implementation. If performance is unimportant, consider using StreamOutputHelper.writeOptionalString(java.lang.String, java.io.OutputStream).

Throws:

IOException

writeOptionalSecureString

public void writeOptionalSecureString(@Nullable
 SecureString secureStr)
                               throws IOException

Throws:

IOException

writeOptionalInt

public void writeOptionalInt(@Nullable
 Integer integer)
                      throws IOException

Writes an optional Integer.

Throws:

IOException

writeOptionalVInt

public void writeOptionalVInt(@Nullable
 Integer integer)
                       throws IOException

Throws:

IOException

writeOptionalFloat

public void writeOptionalFloat(@Nullable
 Float floatValue)
                        throws IOException

Throws:

IOException

writeOptionalText

public void writeOptionalText(@Nullable
 Text text)
                       throws IOException

Throws:

IOException

writeText

public void writeText(Text text)
               throws IOException

Throws:

IOException

writeString

public abstract void writeString(String str)
                          throws IOException

Write a String: its length in Unicode code units (chars) (NB not bytes) written using writeVInt(int) followed by the sequence of characters themselves encoded as UTF-8.

May be performance-critical, so subclasses must specify an explicit implementation. If performance is unimportant, consider using StreamOutputHelper.writeString(java.lang.String, java.io.OutputStream).

Throws:

IOException

writeSecureString

public void writeSecureString(SecureString secureStr)
                       throws IOException

Throws:

IOException

writeFloat

public void writeFloat(float v)
                throws IOException

Throws:

IOException

writeDouble

public void writeDouble(double v)
                 throws IOException

Throws:

IOException

writeDoubleLE

public void writeDoubleLE(double v)
                   throws IOException

Throws:

IOException

writeOptionalDouble

public void writeOptionalDouble(@Nullable
 Double v)
                         throws IOException

Throws:

IOException

writeBoolean

public void writeBoolean(boolean b)
                  throws IOException

Writes a boolean.

Throws:

IOException

writeOptionalBoolean

public void writeOptionalBoolean(@Nullable
 Boolean b)
                          throws IOException

Throws:

IOException

flush

public abstract void flush()
                    throws IOException

Forces any buffered output to be written.

Specified by:

flush in interface Flushable

Overrides:

flush in class OutputStream

Throws:

IOException

close

public abstract void close()
                    throws IOException

Closes this stream to further operations.

Specified by:

close in interface AutoCloseable

Specified by:

close in interface Closeable

Overrides:

close in class OutputStream

Throws:

IOException

write

public void write(int b)
           throws IOException

Specified by:

write in class OutputStream

Throws:

IOException

write

public void write(byte[] b,
 int off,
 int len)
           throws IOException

Overrides:

write in class OutputStream

Throws:

IOException

writeStringArray

public void writeStringArray(String[] array)
                      throws IOException

Throws:

IOException

writeStringArrayNullable

public void writeStringArrayNullable(@Nullable
 String[] array)
                              throws IOException

Writes a string array, for nullable string, writes it as 0 (empty string).

Throws:

IOException

writeOptionalStringArray

public void writeOptionalStringArray(@Nullable
 String[] array)
                              throws IOException

Writes a string array, for nullable string, writes false.

Throws:

IOException

writeOptionalByteArray

public void writeOptionalByteArray(@Nullable
 byte[] array)
                            throws IOException

Writes a byte array, for null arrays it writes false.

Parameters:

array - an array or null

Throws:

IOException

writeOptionalFloatArray

public void writeOptionalFloatArray(@Nullable
 float[] array)
                             throws IOException

Writes a float array, for null arrays it writes false.

Parameters:

array - an array or null

Throws:

IOException

writeGenericMap

public void writeGenericMap(@Nullable
 Map<String,Object> map)
                     throws IOException

Throws:

IOException

writeMapWithConsistentOrder

public void writeMapWithConsistentOrder(@Nullable
 Map<String,? extends Object> map)
                                 throws IOException

write map to stream with consistent order to make sure every map generated bytes order are same. This method is compatible with StreamInput.readMap and StreamInput.readGenericValue This method only will handle the map keys order, not maps contained within the map

Throws:

IOException

writeMapValues

public final <V> void writeMapValues(Map<?,V> map,
 Writeable.Writer<V> valueWriter)
                              throws IOException

Writes values of a map as a collection

Throws:

IOException

writeMapValues

public final <V extends Writeable> void writeMapValues(Map<?,V> map)
                                                throws IOException

Writes values of a map as a collection

Throws:

IOException

writeMap

public final <K extends Writeable,
V extends Writeable>
void writeMap(Map<K,V> map)
       throws IOException

Write a Map of K-type keys to V-type.

Throws:

IOException

writeOptionalMap

public final <K,
V> void writeOptionalMap(Map<K,V> map,
 Writeable.Writer<K> keyWriter,
 Writeable.Writer<V> valueWriter)
                                   throws IOException

Write an optional Map of K-type keys to V-type.

 Map<String, String> map = ...;
 out.writeMap(map, StreamOutput::writeString, StreamOutput::writeString);
 

Parameters:

keyWriter - The key writer

valueWriter - The value writer

Throws:

IOException

writeMap

public final <K,
V> void writeMap(Map<K,V> map,
 Writeable.Writer<K> keyWriter,
 Writeable.Writer<V> valueWriter)
                           throws IOException

Write a Map of K-type keys to V-type.

 Map<String, String> map = ...;
 out.writeMap(map, StreamOutput::writeString, StreamOutput::writeString);
 

Parameters:

keyWriter - The key writer

valueWriter - The value writer

Throws:

IOException

writeMap

public final <V> void writeMap(Map<String,V> map,
 Writeable.Writer<V> valueWriter)
                        throws IOException

Same as writeMap(Map, Writer, Writer) but for String keys.

Throws:

IOException

writeInstant

public final void writeInstant(Instant instant)
                        throws IOException

Writes an Instant to the stream with nanosecond resolution

Throws:

IOException

writeOptionalInstant

public final void writeOptionalInstant(@Nullable
 Instant instant)
                                throws IOException

Writes an Instant to the stream, which could possibly be null

Throws:

IOException

writeGenericList

public <T> void writeGenericList(List<T> v,
 Writeable.Writer<T> writer)
                          throws IOException

Throws:

IOException

writeGenericString

public abstract void writeGenericString(String value)
                                 throws IOException

Write a String within writeGenericValue(java.lang.Object), represented as the type code byte 0 followed by the string itself written as if with writeString(java.lang.String).

May be performance-critical, so subclasses must specify an explicit implementation. If performance is unimportant, consider using StreamOutputHelper.writeGenericString(java.lang.String, java.io.OutputStream).

Throws:

IOException

writeGenericNull

public void writeGenericNull()
                      throws IOException

Throws:

IOException

writeGenericValue

public void writeGenericValue(@Nullable
 Object value)
                       throws IOException

Notice: when serialization a map, the stream out map with the stream in map maybe have the different key-value orders, they will maybe have different stream order. If want to keep stream out map and stream in map have the same stream order when stream, can use writeMapWithConsistentOrder

Throws:

IOException

checkWriteable

public static void checkWriteable(@Nullable
 Object value)
                           throws IllegalArgumentException

Throws:

IllegalArgumentException

writeIntArray

public void writeIntArray(int[] values)
                   throws IOException

Throws:

IOException

writeVIntArray

public void writeVIntArray(int[] values)
                    throws IOException

Throws:

IOException

writeLongArray

public void writeLongArray(long[] values)
                    throws IOException

Throws:

IOException

writeVLongArray

public void writeVLongArray(long[] values)
                     throws IOException

Throws:

IOException

writeFloatArray

public void writeFloatArray(float[] values)
                     throws IOException

Throws:

IOException

writeDoubleArray

public void writeDoubleArray(double[] values)
                      throws IOException

Throws:

IOException

writeArray

public <T> void writeArray(Writeable.Writer<T> writer,
 T[] array)
                    throws IOException

Writes the specified array to the stream using the specified Writeable.Writer for each element in the array. This method can be seen as writer version of StreamInput.readArray(Writeable.Reader, IntFunction). The length of array encoded as a variable-length integer is first written to the stream, and then the elements of the array are written to the stream.

Type Parameters:

T - the type of the elements of the array

Parameters:

writer - the writer used to write individual elements

array - the array

Throws:

IOException - if an I/O exception occurs while writing the array

writeOptionalArray

public <T> void writeOptionalArray(Writeable.Writer<T> writer,
 @Nullable
 T[] array)
                            throws IOException

Same as writeArray(Writer, Object[]) but the provided array may be null. An additional boolean value is serialized to indicate whether the array was null or not.

Throws:

IOException

writeArray

public <T extends Writeable> void writeArray(T[] array)
                                      throws IOException

Writes the specified array of Writeables. This method can be seen as writer version of StreamInput.readArray(Writeable.Reader, IntFunction). The length of array encoded as a variable-length integer is first written to the stream, and then the elements of the array are written to the stream.

Throws:

IOException

writeOptionalArray

public <T extends Writeable> void writeOptionalArray(@Nullable
 T[] array)
                                              throws IOException

Same as writeArray(Writeable[]) but the provided array may be null. An additional boolean value is serialized to indicate whether the array was null or not.

Throws:

IOException

writeOptionalWriteable

public void writeOptionalWriteable(@Nullable
 Writeable writeable)
                            throws IOException

Writes a boolean value indicating whether the given object is null, followed by the object's serialization if it is not null.

Throws:

IOException

See Also:

• StreamInput.readOptionalWriteable(org.elasticsearch.common.io.stream.Writeable.Reader<T>)

writeOptional

public <T> void writeOptional(Writeable.Writer<T> writer,
 @Nullable
 T maybeItem)
                       throws IOException

Writes a boolean value indicating whether the given object is null, followed by the object's serialization if it is not null.

Throws:

IOException

See Also:

• StreamInput.readOptional(org.elasticsearch.common.io.stream.Writeable.Reader<T>)

writeWriteable

public void writeWriteable(Writeable writeable)
                    throws IOException

This method allow to use a method reference when writing collection elements such as out.writeMap(map, StreamOutput::writeString, StreamOutput::writeWriteable)

Throws:

IOException

writeException

public void writeException(Throwable throwable)
                    throws IOException

Throws:

IOException

writeOptionalException

public void writeOptionalException(@Nullable
 Throwable throwable)
                            throws IOException

Write an optional Throwable to the stream.

Throws:

IOException

writeNamedWriteable

public void writeNamedWriteable(NamedWriteable namedWriteable)
                         throws IOException

Writes a NamedWriteable to the current stream, by first writing its name and then the object itself

Throws:

IOException

writeOptionalNamedWriteable

public void writeOptionalNamedWriteable(@Nullable
 NamedWriteable namedWriteable)
                                 throws IOException

Write an optional NamedWriteable to the stream.

Throws:

IOException

writeGeoPoint

public void writeGeoPoint(GeoPoint geoPoint)
                   throws IOException

Writes the given GeoPoint to the stream

Throws:

IOException

writeZoneId

public void writeZoneId(ZoneId timeZone)
                 throws IOException

Write a ZoneId to the stream.

Throws:

IOException

writeOptionalZoneId

public void writeOptionalZoneId(@Nullable
 ZoneId timeZone)
                         throws IOException

Write an optional ZoneId to the stream.

Throws:

IOException

writeCollection

public void writeCollection(Collection<? extends Writeable> collection)
                     throws IOException

Writes a collection which can then be read using StreamInput.readCollectionAsList(org.elasticsearch.common.io.stream.Writeable.Reader<T>) or another readCollectionAs* method. Make sure to read the collection back into the same type as was originally written.

Throws:

IOException

writeCollection

public <T> void writeCollection(Collection<T> collection,
 Writeable.Writer<T> writer)
                         throws IOException

Writes a collection which can then be read using StreamInput.readCollectionAsList(org.elasticsearch.common.io.stream.Writeable.Reader<T>) or another readCollectionAs* method. Make sure to read the collection back into the same type as was originally written.

Throws:

IOException

writeStringCollection

public void writeStringCollection(Collection<String> collection)
                           throws IOException

Writes a collection of strings which can then be read using StreamInput.readStringCollectionAsList() or another readStringCollectionAs* method. Make sure to read the collection back into the same type as was originally written.

Throws:

IOException

writeOptionalCollection

public <T extends Writeable> void writeOptionalCollection(@Nullable
 Collection<T> collection)
                                                   throws IOException

Writes a possibly-null collection which can then be read using StreamInput.readOptionalCollectionAsList(org.elasticsearch.common.io.stream.Writeable.Reader<T>).

Throws:

IOException

writeOptionalCollection

public <T> void writeOptionalCollection(@Nullable
 Collection<T> collection,
 Writeable.Writer<T> writer)
                                 throws IOException

Writes a possibly-null collection which can then be read using StreamInput.readOptionalCollectionAsList(org.elasticsearch.common.io.stream.Writeable.Reader<T>).

Throws:

IOException

writeOptionalStringCollection

public void writeOptionalStringCollection(@Nullable
 Collection<String> collection)
                                   throws IOException

Writes a possibly-null collection of strings which can then be read using StreamInput.readOptionalStringCollectionAsList().

Throws:

IOException

writeNamedWriteableCollection

public void writeNamedWriteableCollection(Collection<? extends NamedWriteable> list)
                                   throws IOException

Writes a collection of NamedWriteable objects which can then be read using StreamInput.readNamedWriteableCollectionAsList(java.lang.Class<T>).

Throws:

IOException

writeOptionalNamedWriteableCollection

public void writeOptionalNamedWriteableCollection(@Nullable
 Collection<? extends NamedWriteable> list)
                                           throws IOException

Writes a possibly-null collection of NamedWriteable objects which can then be read using StreamInput.readOptionalNamedWriteableCollectionAsList(java.lang.Class<T>).

Throws:

IOException

writeEnum

public <E extends Enum<E>> void writeEnum(E enumValue)
                                   throws IOException

Writes an enum with type E in terms of the value of its ordinal. Enums serialized like this must have a corresponding test which uses EnumSerializationTestUtils#assertEnumSerialization to fix the wire protocol.

Throws:

IOException

writeOptionalEnum

public <E extends Enum<E>> void writeOptionalEnum(@Nullable
 E enumValue)
                                           throws IOException

Writes an optional enum with type E in terms of the value of its ordinal. Enums serialized like this must have a corresponding test which uses EnumSerializationTestUtils#assertEnumSerialization to fix the wire protocol.

Throws:

IOException

writeEnumSet

public <E extends Enum<E>> void writeEnumSet(EnumSet<E> enumSet)
                                      throws IOException

Writes a set of enum with type E in terms of the value of its ordinal. Enums serialized like this must have a corresponding test which uses EnumSerializationTestUtils#assertEnumSerialization to fix the wire protocol.

Throws:

IOException

writeTimeValue

public void writeTimeValue(TimeValue timeValue)
                    throws IOException

Write a TimeValue to the stream

Throws:

IOException

writeOptionalTimeValue

public void writeOptionalTimeValue(@Nullable
 TimeValue timeValue)
                            throws IOException

Write an optional TimeValue to the stream.

Throws:

IOException

writeMissingWriteable

public <T extends Writeable> void writeMissingWriteable(Class<T> ignored)
                                                 throws IOException

Similar to writeOptionalWriteable(org.elasticsearch.common.io.stream.Writeable) but for use when the value is always missing.

Throws:

IOException

writeMissingString

public void writeMissingString()
                        throws IOException

Similar to writeOptionalString(java.lang.String) but for use when the value is always missing.

Throws:

IOException

writeBigInteger

public void writeBigInteger(BigInteger bigInteger)
                     throws IOException

Write a BigInteger to the stream

Throws:

IOException