BasicStream (ice 3.6.5 API)

java.lang.Object
- IceInternal.BasicStream

public class BasicStream
extends java.lang.Object

Constructor Summary

Constructors
Constructor and Description
`BasicStream(Instance instance, EncodingVersion encoding)`
`BasicStream(Instance instance, EncodingVersion encoding, boolean direct)`
`BasicStream(Instance instance, EncodingVersion encoding, byte[] data)`
`BasicStream(Instance instance, EncodingVersion encoding, java.nio.ByteBuffer data)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`clear()`
`java.lang.Object`	`closure()`
`java.lang.Object`	`closure(java.lang.Object p)`
`BasicStream`	`compress(int headerSize, int compressionLevel)`
`static boolean`	`compressible()`
`void`	`endReadEncaps()`
`void`	`endReadEncapsChecked()`
`SlicedData`	`endReadException(boolean preserve)`
`SlicedData`	`endReadObject(boolean preserve)`
`void`	`endReadSlice()`
`void`	`endSize(int pos)`
`void`	`endWriteEncaps()`
`void`	`endWriteEncapsChecked()`
`void`	`endWriteException()`
`void`	`endWriteObject()`
`void`	`endWriteSlice()`
`void`	`expand(int n)`
`Buffer`	`getBuffer()`
`int`	`getReadEncapsSize()`
`EncodingVersion`	`getReadEncoding()`
`EncodingVersion`	`getWriteEncoding()`
`Instance`	`instance()`
`boolean`	`isEmpty()`
`int`	`pos()`
`void`	`pos(int n)`
`Buffer`	`prepareWrite()`
`int`	`readAndCheckSeqSize(int minSize)`
`byte[]`	`readBlob(int sz)`
`boolean`	`readBool()`
`void`	`readBool(int tag, BooleanOptional v)`
`boolean[]`	`readBoolSeq()`
`void`	`readBoolSeq(int tag, Optional<boolean[]> v)`
`byte`	`readByte()`
`void`	`readByte(int tag, ByteOptional v)`
`java.nio.ByteBuffer`	`readByteBuffer()`
`byte[]`	`readByteSeq()`
`void`	`readByteSeq(int tag, Optional<byte[]> v)`
`double`	`readDouble()`
`void`	`readDouble(int tag, DoubleOptional v)`
`java.nio.DoubleBuffer`	`readDoubleBuffer()`
`double[]`	`readDoubleSeq()`
`void`	`readDoubleSeq(int tag, Optional<double[]> v)`
`byte[]`	`readEncaps(EncodingVersion encoding)`
`int`	`readEnum(int maxValue)`
`float`	`readFloat()`
`void`	`readFloat(int tag, FloatOptional v)`
`java.nio.FloatBuffer`	`readFloatBuffer()`
`float[]`	`readFloatSeq()`
`void`	`readFloatSeq(int tag, Optional<float[]> v)`
`int`	`readInt()`
`void`	`readInt(int tag, IntOptional v)`
`java.nio.IntBuffer`	`readIntBuffer()`
`int[]`	`readIntSeq()`
`void`	`readIntSeq(int tag, Optional<int[]> v)`
`long`	`readLong()`
`void`	`readLong(int tag, LongOptional v)`
`java.nio.LongBuffer`	`readLongBuffer()`
`long[]`	`readLongSeq()`
`void`	`readLongSeq(int tag, Optional<long[]> v)`
`void`	`readObject(int tag, Optional<Object> v)`
`void`	`readObject(Patcher patcher)`
`boolean`	`readOpt(int tag, OptionalFormat expectedFormat)`
`boolean`	`readOptImpl(int readTag, OptionalFormat expectedFormat)`
`void`	`readPendingObjects()`
`ObjectPrx`	`readProxy()`
`void`	`readProxy(int tag, Optional<ObjectPrx> v)`
`java.io.Serializable`	`readSerializable()`
`short`	`readShort()`
`void`	`readShort(int tag, ShortOptional v)`
`java.nio.ShortBuffer`	`readShortBuffer()`
`short[]`	`readShortSeq()`
`void`	`readShortSeq(int tag, Optional<short[]> v)`
`int`	`readSize()`
`java.lang.String`	`readString()`
`void`	`readString(int tag, Optional<java.lang.String> v)`
`java.lang.String[]`	`readStringSeq()`
`void`	`readStringSeq(int tag, Optional<java.lang.String[]> v)`
`void`	`reset()`
`void`	`resetEncaps()`
`void`	`resize(int sz, boolean reading)`
`void`	`rewriteBool(boolean v, int dest)`
`void`	`rewriteByte(byte v, int dest)`
`void`	`rewriteInt(int v, int dest)`
`int`	`size()`
`void`	`skip(int size)`
`EncodingVersion`	`skipEmptyEncaps()`
`EncodingVersion`	`skipEncaps()`
`void`	`skipOpt(OptionalFormat format)`
`void`	`skipOpts()`
`void`	`skipSize()`
`void`	`skipSlice()`
`void`	`sliceObjects(boolean b)`
`EncodingVersion`	`startReadEncaps()`
`void`	`startReadException()`
`void`	`startReadObject()`
`java.lang.String`	`startReadSlice()`
`int`	`startSize()`
`void`	`startWriteEncaps()`
`void`	`startWriteEncaps(EncodingVersion encoding, FormatType format)`
`void`	`startWriteException(SlicedData data)`
`void`	`startWriteObject(SlicedData data)`
`void`	`startWriteSlice(java.lang.String typeId, int compactId, boolean last)`
`void`	`swap(BasicStream other)`
`void`	`throwException(UserExceptionFactory factory)`
`BasicStream`	`uncompress(int headerSize, int messageSizeMax)`
`void`	`writeBlob(byte[] v)`
`void`	`writeBlob(byte[] v, int off, int len)`
`void`	`writeBool(boolean v)`
`void`	`writeBool(int tag, boolean v)`
`void`	`writeBool(int tag, BooleanOptional v)`
`void`	`writeBoolSeq(boolean[] v)`
`void`	`writeBoolSeq(int tag, boolean[] v)`
`void`	`writeBoolSeq(int tag, Optional<boolean[]> v)`
`void`	`writeByte(byte v)`
`void`	`writeByte(int tag, byte v)`
`void`	`writeByte(int tag, ByteOptional v)`
`void`	`writeByteBuffer(java.nio.ByteBuffer v)`
`void`	`writeByteSeq(byte[] v)`
`void`	`writeByteSeq(int tag, byte[] v)`
`void`	`writeByteSeq(int tag, Optional<byte[]> v)`
`void`	`writeDouble(double v)`
`void`	`writeDouble(int tag, double v)`
`void`	`writeDouble(int tag, DoubleOptional v)`
`void`	`writeDoubleBuffer(java.nio.DoubleBuffer v)`
`void`	`writeDoubleSeq(double[] v)`
`void`	`writeDoubleSeq(int tag, double[] v)`
`void`	`writeDoubleSeq(int tag, Optional<double[]> v)`
`void`	`writeEmptyEncaps(EncodingVersion encoding)`
`void`	`writeEncaps(byte[] v)`
`void`	`writeEnum(int v, int maxValue)`
`void`	`writeFloat(float v)`
`void`	`writeFloat(int tag, float v)`
`void`	`writeFloat(int tag, FloatOptional v)`
`void`	`writeFloatBuffer(java.nio.FloatBuffer v)`
`void`	`writeFloatSeq(float[] v)`
`void`	`writeFloatSeq(int tag, float[] v)`
`void`	`writeFloatSeq(int tag, Optional<float[]> v)`
`void`	`writeInt(int v)`
`void`	`writeInt(int tag, int v)`
`void`	`writeInt(int tag, IntOptional v)`
`void`	`writeIntBuffer(java.nio.IntBuffer v)`
`void`	`writeIntSeq(int[] v)`
`void`	`writeIntSeq(int tag, int[] v)`
`void`	`writeIntSeq(int tag, Optional<int[]> v)`
`void`	`writeLong(int tag, long v)`
`void`	`writeLong(int tag, LongOptional v)`
`void`	`writeLong(long v)`
`void`	`writeLongBuffer(java.nio.LongBuffer v)`
`void`	`writeLongSeq(int tag, long[] v)`
`void`	`writeLongSeq(int tag, Optional<long[]> v)`
`void`	`writeLongSeq(long[] v)`
`void`	`writeObject(int tag, Object v)`
`<T extends Object> void`	`writeObject(int tag, Optional<T> v)`
`void`	`writeObject(Object v)`
`boolean`	`writeOpt(int tag, OptionalFormat format)`
`boolean`	`writeOptImpl(int tag, OptionalFormat format)`
`void`	`writePendingObjects()`
`void`	`writeProxy(int tag, ObjectPrx v)`
`void`	`writeProxy(int tag, Optional<ObjectPrx> v)`
`void`	`writeProxy(ObjectPrx v)`
`void`	`writeSerializable(java.io.Serializable o)`
`void`	`writeShort(int tag, short v)`
`void`	`writeShort(int tag, ShortOptional v)`
`void`	`writeShort(short v)`
`void`	`writeShortBuffer(java.nio.ShortBuffer v)`
`void`	`writeShortSeq(int tag, Optional<short[]> v)`
`void`	`writeShortSeq(int tag, short[] v)`
`void`	`writeShortSeq(short[] v)`
`void`	`writeSize(int v)`
`void`	`writeString(int tag, Optional<java.lang.String> v)`
`void`	`writeString(int tag, java.lang.String v)`
`void`	`writeString(java.lang.String v)`
`void`	`writeStringSeq(int tag, Optional<java.lang.String[]> v)`
`void`	`writeStringSeq(int tag, java.lang.String[] v)`
`void`	`writeStringSeq(java.lang.String[] v)`
`void`	`writeUserException(UserException e)`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

BasicStream

public BasicStream(Instance instance,
                   EncodingVersion encoding)

BasicStream

public BasicStream(Instance instance,
                   EncodingVersion encoding,
                   boolean direct)

BasicStream

public BasicStream(Instance instance,
                   EncodingVersion encoding,
                   byte[] data)

BasicStream

public BasicStream(Instance instance,
                   EncodingVersion encoding,
                   java.nio.ByteBuffer data)

Method Detail

reset
```
public void reset()
```

clear
```
public void clear()
```

instance
```
public Instance instance()
```

closure
```
public java.lang.Object closure()
```

closure

public java.lang.Object closure(java.lang.Object p)

swap
```
public void swap(BasicStream other)
```

resetEncaps
```
public void resetEncaps()
```

resize

public void resize(int sz,
                   boolean reading)

prepareWrite
```
public Buffer prepareWrite()
```

getBuffer
```
public Buffer getBuffer()
```

startWriteObject

public void startWriteObject(SlicedData data)

endWriteObject
```
public void endWriteObject()
```

startReadObject
```
public void startReadObject()
```

endReadObject

public SlicedData endReadObject(boolean preserve)

startWriteException

public void startWriteException(SlicedData data)

endWriteException
```
public void endWriteException()
```

startReadException
```
public void startReadException()
```

endReadException

public SlicedData endReadException(boolean preserve)

startWriteEncaps
```
public void startWriteEncaps()
```

startWriteEncaps

public void startWriteEncaps(EncodingVersion encoding,
                             FormatType format)

endWriteEncaps
```
public void endWriteEncaps()
```

endWriteEncapsChecked
```
public void endWriteEncapsChecked()
```

writeEmptyEncaps

public void writeEmptyEncaps(EncodingVersion encoding)

writeEncaps
```
public void writeEncaps(byte[] v)
```

getWriteEncoding

public EncodingVersion getWriteEncoding()

startReadEncaps

public EncodingVersion startReadEncaps()

endReadEncaps
```
public void endReadEncaps()
```

skipEmptyEncaps

public EncodingVersion skipEmptyEncaps()

endReadEncapsChecked
```
public void endReadEncapsChecked()
```

readEncaps

public byte[] readEncaps(EncodingVersion encoding)

getReadEncoding

public EncodingVersion getReadEncoding()

getReadEncapsSize
```
public int getReadEncapsSize()
```

skipEncaps
```
public EncodingVersion skipEncaps()
```

startWriteSlice

public void startWriteSlice(java.lang.String typeId,
                            int compactId,
                            boolean last)

endWriteSlice
```
public void endWriteSlice()
```

startReadSlice

public java.lang.String startReadSlice()

endReadSlice
```
public void endReadSlice()
```

skipSlice
```
public void skipSlice()
```

readPendingObjects
```
public void readPendingObjects()
```

writePendingObjects
```
public void writePendingObjects()
```

writeSize
```
public void writeSize(int v)
```

readSize
```
public int readSize()
```

readAndCheckSeqSize

public int readAndCheckSeqSize(int minSize)

startSize
```
public int startSize()
```

endSize
```
public void endSize(int pos)
```

writeBlob
```
public void writeBlob(byte[] v)
```

writeBlob

public void writeBlob(byte[] v,
                      int off,
                      int len)

readBlob
```
public byte[] readBlob(int sz)
```

writeOpt

public boolean writeOpt(int tag,
                        OptionalFormat format)

readOpt

public boolean readOpt(int tag,
                       OptionalFormat expectedFormat)

writeByte
```
public void writeByte(byte v)
```

writeByte

public void writeByte(int tag,
                      ByteOptional v)

writeByte

public void writeByte(int tag,
                      byte v)

rewriteByte

public void rewriteByte(byte v,
                        int dest)

writeByteSeq
```
public void writeByteSeq(byte[] v)
```

writeByteSeq

public void writeByteSeq(int tag,
                         Optional<byte[]> v)

writeByteSeq

public void writeByteSeq(int tag,
                         byte[] v)

writeByteBuffer

public void writeByteBuffer(java.nio.ByteBuffer v)

writeSerializable

public void writeSerializable(java.io.Serializable o)

readByte
```
public byte readByte()
```

readByte

public void readByte(int tag,
                     ByteOptional v)

readByteSeq
```
public byte[] readByteSeq()
```

readByteSeq

public void readByteSeq(int tag,
                        Optional<byte[]> v)

readByteBuffer

public java.nio.ByteBuffer readByteBuffer()

readSerializable

public java.io.Serializable readSerializable()

writeBool
```
public void writeBool(boolean v)
```

writeBool

public void writeBool(int tag,
                      BooleanOptional v)

writeBool

public void writeBool(int tag,
                      boolean v)

rewriteBool

public void rewriteBool(boolean v,
                        int dest)

writeBoolSeq

public void writeBoolSeq(boolean[] v)

writeBoolSeq

public void writeBoolSeq(int tag,
                         Optional<boolean[]> v)

writeBoolSeq

public void writeBoolSeq(int tag,
                         boolean[] v)

readBool
```
public boolean readBool()
```

readBool

public void readBool(int tag,
                     BooleanOptional v)

readBoolSeq
```
public boolean[] readBoolSeq()
```

readBoolSeq

public void readBoolSeq(int tag,
                        Optional<boolean[]> v)

writeShort
```
public void writeShort(short v)
```

writeShort

public void writeShort(int tag,
                       ShortOptional v)

writeShort

public void writeShort(int tag,
                       short v)

writeShortSeq
```
public void writeShortSeq(short[] v)
```

writeShortSeq

public void writeShortSeq(int tag,
                          Optional<short[]> v)

writeShortSeq

public void writeShortSeq(int tag,
                          short[] v)

writeShortBuffer

public void writeShortBuffer(java.nio.ShortBuffer v)

readShort
```
public short readShort()
```

readShort

public void readShort(int tag,
                      ShortOptional v)

readShortSeq
```
public short[] readShortSeq()
```

readShortSeq

public void readShortSeq(int tag,
                         Optional<short[]> v)

readShortBuffer

public java.nio.ShortBuffer readShortBuffer()

writeInt
```
public void writeInt(int v)
```

writeInt

public void writeInt(int tag,
                     IntOptional v)

writeInt

public void writeInt(int tag,
                     int v)

rewriteInt

public void rewriteInt(int v,
                       int dest)

writeIntSeq
```
public void writeIntSeq(int[] v)
```

writeIntSeq

public void writeIntSeq(int tag,
                        Optional<int[]> v)

writeIntSeq

public void writeIntSeq(int tag,
                        int[] v)

writeIntBuffer

public void writeIntBuffer(java.nio.IntBuffer v)

readInt
```
public int readInt()
```

readInt

public void readInt(int tag,
                    IntOptional v)

readIntSeq
```
public int[] readIntSeq()
```

readIntSeq

public void readIntSeq(int tag,
                       Optional<int[]> v)

readIntBuffer

public java.nio.IntBuffer readIntBuffer()

writeLong
```
public void writeLong(long v)
```

writeLong

public void writeLong(int tag,
                      LongOptional v)

writeLong

public void writeLong(int tag,
                      long v)

writeLongSeq
```
public void writeLongSeq(long[] v)
```

writeLongSeq

public void writeLongSeq(int tag,
                         Optional<long[]> v)

writeLongSeq

public void writeLongSeq(int tag,
                         long[] v)

writeLongBuffer

public void writeLongBuffer(java.nio.LongBuffer v)

readLong
```
public long readLong()
```

readLong

public void readLong(int tag,
                     LongOptional v)

readLongSeq
```
public long[] readLongSeq()
```

readLongSeq

public void readLongSeq(int tag,
                        Optional<long[]> v)

readLongBuffer

public java.nio.LongBuffer readLongBuffer()

writeFloat
```
public void writeFloat(float v)
```

writeFloat

public void writeFloat(int tag,
                       FloatOptional v)

writeFloat

public void writeFloat(int tag,
                       float v)

writeFloatSeq
```
public void writeFloatSeq(float[] v)
```

writeFloatSeq

public void writeFloatSeq(int tag,
                          Optional<float[]> v)

writeFloatSeq

public void writeFloatSeq(int tag,
                          float[] v)

writeFloatBuffer

public void writeFloatBuffer(java.nio.FloatBuffer v)

readFloat
```
public float readFloat()
```

readFloat

public void readFloat(int tag,
                      FloatOptional v)

readFloatSeq
```
public float[] readFloatSeq()
```

readFloatSeq

public void readFloatSeq(int tag,
                         Optional<float[]> v)

readFloatBuffer

public java.nio.FloatBuffer readFloatBuffer()

writeDouble
```
public void writeDouble(double v)
```

writeDouble

public void writeDouble(int tag,
                        DoubleOptional v)

writeDouble

public void writeDouble(int tag,
                        double v)

writeDoubleSeq

public void writeDoubleSeq(double[] v)

writeDoubleSeq

public void writeDoubleSeq(int tag,
                           Optional<double[]> v)

writeDoubleSeq

public void writeDoubleSeq(int tag,
                           double[] v)

writeDoubleBuffer

public void writeDoubleBuffer(java.nio.DoubleBuffer v)

readDouble
```
public double readDouble()
```

readDouble

public void readDouble(int tag,
                       DoubleOptional v)

readDoubleSeq
```
public double[] readDoubleSeq()
```

readDoubleSeq

public void readDoubleSeq(int tag,
                          Optional<double[]> v)

readDoubleBuffer

public java.nio.DoubleBuffer readDoubleBuffer()

writeString

public void writeString(java.lang.String v)

writeString

public void writeString(int tag,
                        Optional<java.lang.String> v)

writeString

public void writeString(int tag,
                        java.lang.String v)

writeStringSeq

public void writeStringSeq(java.lang.String[] v)

writeStringSeq

public void writeStringSeq(int tag,
                           Optional<java.lang.String[]> v)

writeStringSeq

public void writeStringSeq(int tag,
                           java.lang.String[] v)

readString
```
public java.lang.String readString()
```

readString

public void readString(int tag,
                       Optional<java.lang.String> v)

readStringSeq

public java.lang.String[] readStringSeq()

readStringSeq

public void readStringSeq(int tag,
                          Optional<java.lang.String[]> v)

writeProxy
```
public void writeProxy(ObjectPrx v)
```

writeProxy

public void writeProxy(int tag,
                       Optional<ObjectPrx> v)

writeProxy

public void writeProxy(int tag,
                       ObjectPrx v)

readProxy
```
public ObjectPrx readProxy()
```

readProxy

public void readProxy(int tag,
                      Optional<ObjectPrx> v)

writeEnum

public void writeEnum(int v,
                      int maxValue)

readEnum
```
public int readEnum(int maxValue)
```

writeObject
```
public void writeObject(Object v)
```

writeObject

public <T extends Object> void writeObject(int tag,
                                           Optional<T> v)

writeObject

public void writeObject(int tag,
                        Object v)

readObject

public void readObject(Patcher patcher)

readObject

public void readObject(int tag,
                       Optional<Object> v)

writeUserException

public void writeUserException(UserException e)

throwException

public void throwException(UserExceptionFactory factory)
                    throws UserException

Throws:: UserException

sliceObjects
```
public void sliceObjects(boolean b)
```

readOptImpl

public boolean readOptImpl(int readTag,
                           OptionalFormat expectedFormat)

writeOptImpl

public boolean writeOptImpl(int tag,
                            OptionalFormat format)

skipOpt

public void skipOpt(OptionalFormat format)

skipOpts
```
public void skipOpts()
```

skip
```
public void skip(int size)
```

skipSize
```
public void skipSize()
```

pos
```
public int pos()
```

pos
```
public void pos(int n)
```

size
```
public int size()
```

isEmpty
```
public boolean isEmpty()
```

compress

public BasicStream compress(int headerSize,
                            int compressionLevel)

uncompress

public BasicStream uncompress(int headerSize,
                              int messageSizeMax)

expand
```
public void expand(int n)
```

compressible
```
public static boolean compressible()
```

Class BasicStream

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

BasicStream

BasicStream

BasicStream

BasicStream

Method Detail

reset

clear

instance

closure

closure

swap

resetEncaps

resize

prepareWrite

getBuffer

startWriteObject

endWriteObject

startReadObject

endReadObject

startWriteException

endWriteException

startReadException

endReadException

startWriteEncaps

startWriteEncaps

endWriteEncaps

endWriteEncapsChecked

writeEmptyEncaps

writeEncaps

getWriteEncoding

startReadEncaps

endReadEncaps

skipEmptyEncaps

endReadEncapsChecked

readEncaps

getReadEncoding

getReadEncapsSize

skipEncaps

startWriteSlice

endWriteSlice

startReadSlice

endReadSlice

skipSlice

readPendingObjects

writePendingObjects

writeSize

readSize

readAndCheckSeqSize

startSize

endSize

writeBlob

writeBlob

readBlob

writeOpt

readOpt

writeByte

writeByte

writeByte

rewriteByte

writeByteSeq

writeByteSeq

writeByteSeq

writeByteBuffer

writeSerializable

readByte

readByte

readByteSeq

readByteSeq

readByteBuffer

readSerializable

writeBool

writeBool

writeBool

rewriteBool

writeBoolSeq