Package cn.sliew.milky.io

Interface DataOutputView

All Superinterfaces:

AutoCloseable, Closeable, DataOutput, Flushable, Serializable

All Known Implementing Classes:

OutputStreamDataOutputView

public interface DataOutputView
extends DataOutput, Closeable, Flushable, Serializable

Field Summary

Fields

Modifier and Type	Field	Description
static byte	ONE
static byte	TWO
static byte	ZERO

Method Summary

Modifier and Type	Method	Description
void	close()
void	flush()
byte[]	getBuffer()
default void	write(byte[] b)
default void	write(byte[] b, int off, int len)
default void	writeBoolean(boolean v)	Writes a 1 byte boolean.
void	writeBytes(byte[] b)
void	writeBytes(byte[] b, int off, int len)
default void	writeChar(int v)	Writes a 2 byte char.
default void	writeDouble(double v)	Writes a 8 byte double.
default void	writeFloat(float v)	Writes a 4 byte float.
default void	writeInt(int v)	Writes a 4 byte int.
default void	writeLong(long i)	Writes an 8 byte long.
default void	writeOptionalBoolean(Boolean b)	Writes an optional Boolean.
default void	writeOptionalDouble(Double v)	Writes an optional Double.
default void	writeOptionalFloat(Float v)	Writes an optional Float.
default void	writeOptionalInt(Integer integer)	Writes an optional Integer.
default void	writeOptionalLong(Long l)	Writes an optional Long.
default void	writeOptionalVInt(Integer integer)
default void	writeOptionalVLong(Long l)
default void	writeOptionalZLong(Long l)
default void	writeShort(int v)	Writes a 2 byte short.
default void	writeVDouble(double value, double precision, boolean optimizePositive)	Writes a 1-9 byte double with reduced precision.
default void	writeVFloat(float value, float precision)	Writes a 1-5 byte float with reduced precision.
default void	writeVInt(int v)	Writes an int in a variable-length format.
default void	writeVLong(long i)	Writes a long in a variable-length format.
default void	writeZInt(int v)	Writes a zig-zag-encoded variable-length integer.
default void	writeZLong(long i)	Writes a long in a variable-length format.

Methods inherited from interface java.io.DataOutput

write, writeByte, writeBytes, writeChars, writeUTF

Field Detail

ZERO

static final byte ZERO

See Also:

Constant Field Values

ONE

static final byte ONE

See Also:

Constant Field Values

TWO

static final byte TWO

See Also:

Constant Field Values

Method Detail

writeBytes

void writeBytes(byte[] b)
         throws IOException

Throws:

IOException

writeBytes

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

Throws:

IOException

write

default void write(byte[] b)
            throws IOException

Specified by:

write in interface DataOutput

Throws:

IOException

write

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

Specified by:

write in interface DataOutput

Throws:

IOException

writeBoolean

default void writeBoolean(boolean v)
                   throws IOException

Writes a 1 byte boolean.

Specified by:

writeBoolean in interface DataOutput

Throws:

IOException

writeOptionalBoolean

default void writeOptionalBoolean(Boolean b)
                           throws IOException

Writes an optional Boolean.

Throws:

IOException

writeShort

default void writeShort(int v)
                 throws IOException

Writes a 2 byte short.

Specified by:

writeShort in interface DataOutput

Throws:

IOException

writeChar

default void writeChar(int v)
                throws IOException

Writes a 2 byte char.

Specified by:

writeChar in interface DataOutput

Throws:

IOException

writeInt

default void writeInt(int v)
               throws IOException

Writes a 4 byte int.

Specified by:

writeInt in interface DataOutput

Throws:

IOException

writeVInt

default void writeVInt(int v)
                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) or writeZInt(int)

Throws:

IOException

writeZInt

default void writeZInt(int v)
                throws IOException

Writes a zig-zag-encoded variable-length integer. This is typically useful to write small signed ints and is equivalent to calling writeVInt(BitUtil.zigZagEncode(i)).

Throws:

IOException

See Also:

DataInputView.readZInt()

writeOptionalInt

default void writeOptionalInt(Integer integer)
                       throws IOException

Writes an optional Integer.

Throws:

IOException

writeOptionalVInt

default void writeOptionalVInt(Integer integer)
                        throws IOException

Throws:

IOException

writeLong

default void writeLong(long i)
                throws IOException

Writes an 8 byte long.

Specified by:

writeLong in interface DataOutput

Throws:

IOException

writeVLong

default void writeVLong(long i)
                 throws IOException

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

Throws:

IOException

writeZLong

default 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

default void writeOptionalLong(Long l)
                        throws IOException

Writes an optional Long.

Throws:

IOException

writeOptionalVLong

default void writeOptionalVLong(Long l)
                         throws IOException

Throws:

IOException

writeOptionalZLong

default void writeOptionalZLong(Long l)
                         throws IOException

Throws:

IOException

writeFloat

default void writeFloat(float v)
                 throws IOException

Writes a 4 byte float.

Specified by:

writeFloat in interface DataOutput

Throws:

IOException

writeVFloat

default void writeVFloat(float value,
                         float precision)
                  throws IOException

Writes a 1-5 byte float with reduced precision. Small positive numbers will be more efficient (1 byte) and small negative numbers will be inefficient (5 bytes).

Throws:

IOException

writeVDouble

default void writeVDouble(double value,
                          double precision,
                          boolean optimizePositive)
                   throws IOException

Writes a 1-9 byte double with reduced precision. Small positive numbers will be more efficient (1 byte) and small negative numbers will be inefficient (9 bytes).

Throws:

IOException

writeOptionalFloat

default void writeOptionalFloat(Float v)
                         throws IOException

Writes an optional Float.

Throws:

IOException

writeDouble

default void writeDouble(double v)
                  throws IOException

Writes a 8 byte double.

Specified by:

writeDouble in interface DataOutput

Throws:

IOException

writeOptionalDouble

default void writeOptionalDouble(Double v)
                          throws IOException

Writes an optional Double.

Throws:

IOException

getBuffer

byte[] getBuffer()

flush

void flush()
    throws IOException

Specified by:

flush in interface Flushable

Throws:

IOException

close

void close()
    throws IOException

Specified by:

close in interface AutoCloseable

Specified by:

close in interface Closeable

Throws:

IOException