Class StreamOutput

  • All Implemented Interfaces:
    java.io.Closeable, java.io.Flushable, java.lang.AutoCloseable
    Direct Known Subclasses:
    BufferedChecksumStreamOutput, BytesStream, DataOutputStreamOutput, OutputStreamStreamOutput

    public abstract class StreamOutput
    extends java.io.OutputStream
    A stream from another node to this node. Technically, it can also be streamed from a byte array but that is mostly for testing. 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.
    • Constructor Detail

      • StreamOutput

        public StreamOutput()
    • Method Detail

      • getVersion

        public Version getVersion()
        The version of the node on the other side of this stream.
      • setVersion

        public void setVersion​(Version version)
        Set the version of the node on the other side of this stream.
      • hasFeature

        public boolean hasFeature​(java.lang.String feature)
        Test if the stream has the specified feature. Features are used when serializing ClusterState.Custom or MetaData.Custom; see also ClusterState.FeatureAware.
        Parameters:
        feature - the feature to test
        Returns:
        true if the stream has the specified feature
      • setFeatures

        public void setFeatures​(java.util.Set<java.lang.String> features)
        Set the features on the stream. See hasFeature(String).
        Parameters:
        features - the features on the stream
      • position

        public long position()
                      throws java.io.IOException
        Throws:
        java.io.IOException
      • seek

        public void seek​(long position)
                  throws java.io.IOException
        Throws:
        java.io.IOException
      • writeByte

        public abstract void writeByte​(byte b)
                                throws java.io.IOException
        Writes a single byte.
        Throws:
        java.io.IOException
      • writeBytes

        public void writeBytes​(byte[] b)
                        throws java.io.IOException
        Writes an array of bytes.
        Parameters:
        b - the bytes to write
        Throws:
        java.io.IOException
      • writeBytes

        public void writeBytes​(byte[] b,
                               int length)
                        throws java.io.IOException
        Writes an array of bytes.
        Parameters:
        b - the bytes to write
        length - the number of bytes to write
        Throws:
        java.io.IOException
      • writeBytes

        public abstract void writeBytes​(byte[] b,
                                        int offset,
                                        int length)
                                 throws java.io.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:
        java.io.IOException
      • writeByteArray

        public void writeByteArray​(byte[] b)
                            throws java.io.IOException
        Writes an array of bytes.
        Parameters:
        b - the bytes to write
        Throws:
        java.io.IOException
      • writeBytesReference

        public void writeBytesReference​(@Nullable
                                        BytesReference bytes)
                                 throws java.io.IOException
        Writes the bytes reference, including a length header.
        Throws:
        java.io.IOException
      • writeBytesRef

        public void writeBytesRef​(org.apache.lucene.util.BytesRef bytes)
                           throws java.io.IOException
        Throws:
        java.io.IOException
      • writeShort

        public final void writeShort​(short v)
                              throws java.io.IOException
        Throws:
        java.io.IOException
      • writeInt

        public void writeInt​(int i)
                      throws java.io.IOException
        Writes an int as four bytes.
        Throws:
        java.io.IOException
      • writeVInt

        public void writeVInt​(int i)
                       throws java.io.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:
        java.io.IOException
      • writeLong

        public void writeLong​(long i)
                       throws java.io.IOException
        Writes a long as eight bytes.
        Throws:
        java.io.IOException
      • writeVLong

        public void writeVLong​(long i)
                        throws java.io.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:
        java.io.IOException
      • writeZLong

        public void writeZLong​(long i)
                        throws java.io.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:
        java.io.IOException
      • writeOptionalLong

        public void writeOptionalLong​(@Nullable
                                      java.lang.Long l)
                               throws java.io.IOException
        Throws:
        java.io.IOException
      • writeOptionalString

        public void writeOptionalString​(@Nullable
                                        java.lang.String str)
                                 throws java.io.IOException
        Throws:
        java.io.IOException
      • writeOptionalVInt

        public void writeOptionalVInt​(@Nullable
                                      java.lang.Integer integer)
                               throws java.io.IOException
        Throws:
        java.io.IOException
      • writeOptionalFloat

        public void writeOptionalFloat​(@Nullable
                                       java.lang.Float floatValue)
                                throws java.io.IOException
        Throws:
        java.io.IOException
      • writeOptionalText

        public void writeOptionalText​(@Nullable
                                      Text text)
                               throws java.io.IOException
        Throws:
        java.io.IOException
      • writeText

        public void writeText​(Text text)
                       throws java.io.IOException
        Throws:
        java.io.IOException
      • writeString

        public void writeString​(java.lang.String str)
                         throws java.io.IOException
        Throws:
        java.io.IOException
      • writeFloat

        public void writeFloat​(float v)
                        throws java.io.IOException
        Throws:
        java.io.IOException
      • writeDouble

        public void writeDouble​(double v)
                         throws java.io.IOException
        Throws:
        java.io.IOException
      • writeOptionalDouble

        public void writeOptionalDouble​(@Nullable
                                        java.lang.Double v)
                                 throws java.io.IOException
        Throws:
        java.io.IOException
      • writeBoolean

        public void writeBoolean​(boolean b)
                          throws java.io.IOException
        Writes a boolean.
        Throws:
        java.io.IOException
      • writeOptionalBoolean

        public void writeOptionalBoolean​(@Nullable
                                         java.lang.Boolean b)
                                  throws java.io.IOException
        Throws:
        java.io.IOException
      • flush

        public abstract void flush()
                            throws java.io.IOException
        Forces any buffered output to be written.
        Specified by:
        flush in interface java.io.Flushable
        Overrides:
        flush in class java.io.OutputStream
        Throws:
        java.io.IOException
      • close

        public abstract void close()
                            throws java.io.IOException
        Closes this stream to further operations.
        Specified by:
        close in interface java.lang.AutoCloseable
        Specified by:
        close in interface java.io.Closeable
        Overrides:
        close in class java.io.OutputStream
        Throws:
        java.io.IOException
      • reset

        public abstract void reset()
                            throws java.io.IOException
        Throws:
        java.io.IOException
      • write

        public void write​(int b)
                   throws java.io.IOException
        Specified by:
        write in class java.io.OutputStream
        Throws:
        java.io.IOException
      • write

        public void write​(byte[] b,
                          int off,
                          int len)
                   throws java.io.IOException
        Overrides:
        write in class java.io.OutputStream
        Throws:
        java.io.IOException
      • writeStringArray

        public void writeStringArray​(java.lang.String[] array)
                              throws java.io.IOException
        Throws:
        java.io.IOException
      • writeStringArrayNullable

        public void writeStringArrayNullable​(@Nullable
                                             java.lang.String[] array)
                                      throws java.io.IOException
        Writes a string array, for nullable string, writes it as 0 (empty string).
        Throws:
        java.io.IOException
      • writeOptionalStringArray

        public void writeOptionalStringArray​(@Nullable
                                             java.lang.String[] array)
                                      throws java.io.IOException
        Writes a string array, for nullable string, writes false.
        Throws:
        java.io.IOException
      • writeMap

        public void writeMap​(@Nullable
                             java.util.Map<java.lang.String,​java.lang.Object> map)
                      throws java.io.IOException
        Throws:
        java.io.IOException
      • writeMapWithConsistentOrder

        public void writeMapWithConsistentOrder​(@Nullable
                                                java.util.Map<java.lang.String,​? extends java.lang.Object> map)
                                         throws java.io.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:
        java.io.IOException
      • writeMapOfLists

        public final <K,​V> void writeMapOfLists​(java.util.Map<K,​java.util.List<V>> map,
                                                      Writeable.Writer<K> keyWriter,
                                                      Writeable.Writer<V> valueWriter)
                                               throws java.io.IOException
        Write a Map of K-type keys to V-type Lists.
        
         Map<String, List<String>> map = ...;
         out.writeMapOfLists(map, StreamOutput::writeString, StreamOutput::writeString);
         
        Parameters:
        keyWriter - The key writer
        valueWriter - The value writer
        Throws:
        java.io.IOException
      • writeMap

        public final <K,​V> void writeMap​(java.util.Map<K,​V> map,
                                               Writeable.Writer<K> keyWriter,
                                               Writeable.Writer<V> valueWriter)
                                        throws java.io.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:
        java.io.IOException
      • writeInstant

        public final void writeInstant​(java.time.Instant instant)
                                throws java.io.IOException
        Writes an Instant to the stream with nanosecond resolution
        Throws:
        java.io.IOException
      • writeOptionalInstant

        public final void writeOptionalInstant​(@Nullable
                                               java.time.Instant instant)
                                        throws java.io.IOException
        Writes an Instant to the stream, which could possibly be null
        Throws:
        java.io.IOException
      • writeGenericValue

        public void writeGenericValue​(@Nullable
                                      java.lang.Object value)
                               throws java.io.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:
        java.io.IOException
      • writeIntArray

        public void writeIntArray​(int[] values)
                           throws java.io.IOException
        Throws:
        java.io.IOException
      • writeVIntArray

        public void writeVIntArray​(int[] values)
                            throws java.io.IOException
        Throws:
        java.io.IOException
      • writeLongArray

        public void writeLongArray​(long[] values)
                            throws java.io.IOException
        Throws:
        java.io.IOException
      • writeVLongArray

        public void writeVLongArray​(long[] values)
                             throws java.io.IOException
        Throws:
        java.io.IOException
      • writeFloatArray

        public void writeFloatArray​(float[] values)
                             throws java.io.IOException
        Throws:
        java.io.IOException
      • writeDoubleArray

        public void writeDoubleArray​(double[] values)
                              throws java.io.IOException
        Throws:
        java.io.IOException
      • writeArray

        public <T> void writeArray​(Writeable.Writer<T> writer,
                                   T[] array)
                            throws java.io.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:
        java.io.IOException - if an I/O exception occurs while writing the array
      • writeOptionalArray

        public <T> void writeOptionalArray​(Writeable.Writer<T> writer,
                                           @Nullable
                                           T[] array)
                                    throws java.io.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:
        java.io.IOException
      • writeArray

        public <T extends Writeable> void writeArray​(T[] array)
                                              throws java.io.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:
        java.io.IOException
      • writeOptionalArray

        public <T extends Writeable> void writeOptionalArray​(@Nullable
                                                             T[] array)
                                                      throws java.io.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:
        java.io.IOException
      • writeOptionalStreamable

        public void writeOptionalStreamable​(@Nullable
                                            Streamable streamable)
                                     throws java.io.IOException
        Serializes a potential null value.
        Throws:
        java.io.IOException
      • writeOptionalWriteable

        public void writeOptionalWriteable​(@Nullable
                                           Writeable writeable)
                                    throws java.io.IOException
        Throws:
        java.io.IOException
      • writeException

        public void writeException​(java.lang.Throwable throwable)
                            throws java.io.IOException
        Throws:
        java.io.IOException
      • writeNamedWriteable

        public void writeNamedWriteable​(NamedWriteable namedWriteable)
                                 throws java.io.IOException
        Writes a NamedWriteable to the current stream, by first writing its name and then the object itself
        Throws:
        java.io.IOException
      • writeOptionalNamedWriteable

        public void writeOptionalNamedWriteable​(@Nullable
                                                NamedWriteable namedWriteable)
                                         throws java.io.IOException
        Write an optional NamedWriteable to the stream.
        Throws:
        java.io.IOException
      • writeGeoPoint

        public void writeGeoPoint​(GeoPoint geoPoint)
                           throws java.io.IOException
        Writes the given GeoPoint to the stream
        Throws:
        java.io.IOException
      • writeTimeZone

        public void writeTimeZone​(org.joda.time.DateTimeZone timeZone)
                           throws java.io.IOException
        Write a DateTimeZone to the stream.
        Throws:
        java.io.IOException
      • writeOptionalTimeZone

        public void writeOptionalTimeZone​(@Nullable
                                          org.joda.time.DateTimeZone timeZone)
                                   throws java.io.IOException
        Write an optional DateTimeZone to the stream.
        Throws:
        java.io.IOException
      • writeStreamableList

        public void writeStreamableList​(java.util.List<? extends Streamable> list)
                                 throws java.io.IOException
        Writes a list of Streamable objects
        Throws:
        java.io.IOException
      • writeCollection

        public void writeCollection​(java.util.Collection<? extends Writeable> collection)
                             throws java.io.IOException
        Writes a collection to this stream. The corresponding collection can be read from a stream input using StreamInput.readList(Writeable.Reader).
        Parameters:
        collection - the collection to write to this stream
        Throws:
        java.io.IOException - if an I/O exception occurs writing the collection
      • writeList

        public void writeList​(java.util.List<? extends Writeable> list)
                       throws java.io.IOException
        Writes a list of Writeable objects
        Throws:
        java.io.IOException
      • writeCollection

        public <T> void writeCollection​(java.util.Collection<T> collection,
                                        Writeable.Writer<T> writer)
                                 throws java.io.IOException
        Writes a collection of objects via a Writeable.Writer.
        Parameters:
        collection - the collection of objects
        Throws:
        java.io.IOException - if an I/O exception occurs writing the collection
      • writeStringCollection

        public void writeStringCollection​(java.util.Collection<java.lang.String> collection)
                                   throws java.io.IOException
        Writes a collection of a strings. The corresponding collection can be read from a stream input using StreamInput.readList(Writeable.Reader).
        Parameters:
        collection - the collection of strings
        Throws:
        java.io.IOException - if an I/O exception occurs writing the collection
      • writeNamedWriteableList

        public void writeNamedWriteableList​(java.util.List<? extends NamedWriteable> list)
                                     throws java.io.IOException
        Writes a list of NamedWriteable objects.
        Throws:
        java.io.IOException
      • writeEnum

        public <E extends java.lang.Enum<E>> void writeEnum​(E enumValue)
                                                     throws java.io.IOException
        Writes an enum with type E that by serialized it based on it's ordinal value
        Throws:
        java.io.IOException
      • writeEnumSet

        public <E extends java.lang.Enum<E>> void writeEnumSet​(java.util.EnumSet<E> enumSet)
                                                        throws java.io.IOException
        Writes an EnumSet with type E that by serialized it based on it's ordinal value
        Throws:
        java.io.IOException
      • writeTimeValue

        public void writeTimeValue​(TimeValue timeValue)
                            throws java.io.IOException
        Write a TimeValue to the stream
        Throws:
        java.io.IOException
      • writeOptionalTimeValue

        public void writeOptionalTimeValue​(@Nullable
                                           TimeValue timeValue)
                                    throws java.io.IOException
        Write an optional TimeValue to the stream.
        Throws:
        java.io.IOException