FSTObjectOutput (fst 2.29 API)

java.lang.Object
- org.nustaq.serialization.FSTObjectOutput

All Implemented Interfaces:

DataOutput, ObjectOutput, AutoCloseable

Direct Known Subclasses:

FSTObjectOutputNoShared
```
public class FSTObjectOutput
extends Object
implements ObjectOutput
```
replacement of ObjectOutputStream

Field Summary

Fields
Modifier and Type	Field and Description
`static byte`	`ARRAY`
`static byte`	`BIG_BOOLEAN_FALSE`
`static byte`	`BIG_BOOLEAN_TRUE`
`static byte`	`BIG_INT`
`static byte`	`BIG_LONG`
`protected FSTEncoder`	`codec`
`protected FSTConfiguration`	`conf`
`protected int`	`curDepth`
`static byte`	`DIRECT_ARRAY_OBJECT`
`static byte`	`DIRECT_OBJECT`
`static byte`	`ENUM`
`static byte`	`HANDLE`
`protected FSTSerialisationListener`	`listener`
`static byte`	`NULL`
`static Object`	`NULL_PLACEHOLDER`
`static byte`	`OBJECT`
`protected FSTObjectRegistry`	`objects`
`static byte`	`ONE_OF`
`static byte`	`SPECIAL_COMPATIBILITY_OBJECT_TAG`
`static byte`	`STRING`
`static byte`	`TYPED`
`protected int`	`writeExternalWriteAhead`

Constructor Summary

Constructors
Constructor and Description
`FSTObjectOutput()` serialize without an underlying stream, the resulting byte array of writing to this FSTObjectOutput can be accessed using getBuffer(), the size using getWritten().
`FSTObjectOutput(FSTConfiguration conf)` serialize without an underlying stream, the resulting byte array of writing to this FSTObjectOutput can be accessed using getBuffer(), the size using getWritten().
`FSTObjectOutput(OutputStream out)` Creates a new FSTObjectOutput stream to write data to the specified underlying output stream.
`FSTObjectOutput(OutputStream out, FSTConfiguration conf)` Creates a new FSTObjectOutput stream to write data to the specified underlying output stream.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`close()`
`void`	`defaultWriteObject(Object toWrite, FSTClazzInfo serializationInfo)`
`void`	`ensureFree(int bytes)`
`void`	`flush()` Flushes this data output stream.
`byte[]`	`getBuffer()`
`FSTClazzInfoRegistry`	`getClassInfoRegistry()`
`FSTEncoder`	`getCodec()`
`FSTConfiguration`	`getConf()`
`byte[]`	`getCopyOfWrittenBuffer()`
`protected FSTClazzInfo`	`getFstClazzInfo(FSTClazzInfo.FSTFieldInfo referencee, Class clazz)` if class is same as last referenced, returned cached clzinfo, else do a lookup
`FSTSerialisationListener`	`getListener()`
`FSTObjectRegistry`	`getObjectMap()`
`ObjectOutputStream`	`getObjectOutputStream(Class cl, FSTClazzInfo clinfo, FSTClazzInfo.FSTFieldInfo referencee, Object toWrite)`
`int`	`getWriteExternalWriteAhead()` since the stock writeXX methods on InputStream are final, i can't ensure sufficient bufferSize on the output buffer before calling writeExternal.
`int`	`getWritten()`
`protected void`	`objectHasBeenWritten(Object obj, int oldStreamPosition, int streamPosition)` hook for debugging profiling.
`protected void`	`objectWillBeWritten(Object obj, int streamPosition)` hook for debugging profiling.
`void`	`resetForReUse()` reset keeping the last used byte[] buffer
`void`	`resetForReUse(byte[] out)`
`void`	`resetForReUse(OutputStream out)` if out == null => automatically create/reuse a bytebuffer
`protected void`	`setCodec(FSTEncoder codec)`
`void`	`setListener(FSTSerialisationListener listener)` note this might slow down serialization significantly * @param listener
`void`	`setWriteExternalWriteAhead(int writeExternalWriteAhead)` since the stock writeXX methods on InputStream are final, i can't ensure sufficient bufferSize on the output buffer before calling writeExternal.
`void`	`write(byte[] b)`
`void`	`write(byte[] b, int off, int len)`
`void`	`write(int b)`
`protected void`	`writeArray(FSTClazzInfo.FSTFieldInfo referencee, Object array)`
`void`	`writeBoolean(boolean v)`
`void`	`writeByte(int v)`
`void`	`writeBytes(String s)`
`void`	`writeChar(int v)`
`void`	`writeChars(String s)`
`void`	`writeClassTag(Class aClass)`
`void`	`writeDouble(double v)`
`void`	`writeFloat(float v)`
`void`	`writeInt(int v)`
`void`	`writeLong(long v)`
`void`	`writeObject(Object obj)`
`void`	`writeObject(Object obj, Class... possibles)`
`protected void`	`writeObjectCompatible(FSTClazzInfo.FSTFieldInfo referencee, Object toWrite, FSTClazzInfo serializationInfo)`
`protected boolean`	`writeObjectHeader(FSTClazzInfo clsInfo, FSTClazzInfo.FSTFieldInfo referencee, Object toWrite)`
`FSTClazzInfo`	`writeObjectInternal(Object obj, FSTClazzInfo ci, Class... possibles)`
`protected FSTClazzInfo`	`writeObjectWithContext(FSTClazzInfo.FSTFieldInfo referencee, Object toWrite)`
`protected FSTClazzInfo`	`writeObjectWithContext(FSTClazzInfo.FSTFieldInfo referencee, Object toWrite, FSTClazzInfo ci)`
`void`	`writeShort(int v)`
`void`	`writeStringUTF(String str)`
`void`	`writeUTF(String s)`

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

- Field Detail
  - NULL_PLACEHOLDER
```
public static Object NULL_PLACEHOLDER
```
  - SPECIAL_COMPATIBILITY_OBJECT_TAG
```
public static final byte SPECIAL_COMPATIBILITY_OBJECT_TAG
```
    See Also:
    
    Constant Field Values
  - ONE_OF
```
public static final byte ONE_OF
```
    See Also:
    
    Constant Field Values
  - BIG_BOOLEAN_FALSE
```
public static final byte BIG_BOOLEAN_FALSE
```
    See Also:
    
    Constant Field Values
  - BIG_BOOLEAN_TRUE
```
public static final byte BIG_BOOLEAN_TRUE
```
    See Also:
    
    Constant Field Values
  - BIG_LONG
```
public static final byte BIG_LONG
```
    See Also:
    
    Constant Field Values
  - BIG_INT
```
public static final byte BIG_INT
```
    See Also:
    
    Constant Field Values
  - DIRECT_ARRAY_OBJECT
```
public static final byte DIRECT_ARRAY_OBJECT
```
    See Also:
    
    Constant Field Values
  - HANDLE
```
public static final byte HANDLE
```
    See Also:
    
    Constant Field Values
  - ENUM
```
public static final byte ENUM
```
    See Also:
    
    Constant Field Values
  - ARRAY
```
public static final byte ARRAY
```
    See Also:
    
    Constant Field Values
  - STRING
```
public static final byte STRING
```
    See Also:
    
    Constant Field Values
  - TYPED
```
public static final byte TYPED
```
    See Also:
    
    Constant Field Values
  - DIRECT_OBJECT
```
public static final byte DIRECT_OBJECT
```
    See Also:
    
    Constant Field Values
  - NULL
```
public static final byte NULL
```
    See Also:
    
    Constant Field Values
  - OBJECT
```
public static final byte OBJECT
```
    See Also:
    
    Constant Field Values
  - codec
```
protected FSTEncoder codec
```
  - conf
```
protected final FSTConfiguration conf
```
  - objects
```
protected FSTObjectRegistry objects
```
  - curDepth
```
protected int curDepth
```
  - writeExternalWriteAhead
```
protected int writeExternalWriteAhead
```
  - listener
```
protected FSTSerialisationListener listener
```
- Constructor Detail
  - FSTObjectOutput
```
public FSTObjectOutput(OutputStream out)
```
    Creates a new FSTObjectOutput stream to write data to the specified underlying output stream. uses Default Configuration singleton
  - FSTObjectOutput
```
public FSTObjectOutput(OutputStream out,
                       FSTConfiguration conf)
```
    Creates a new FSTObjectOutput stream to write data to the specified underlying output stream. The counter written is set to zero. Don't create a FSTConfiguration with each stream, just create one global static configuration and reuse it. FSTConfiguration is threadsafe.
    
    Parameters:
    
    out - the underlying output stream, to be saved for later use.
  - FSTObjectOutput
```
public FSTObjectOutput(FSTConfiguration conf)
```
    serialize without an underlying stream, the resulting byte array of writing to this FSTObjectOutput can be accessed using getBuffer(), the size using getWritten(). Don't create a FSTConfiguration with each stream, just create one global static configuration and reuse it. FSTConfiguration is threadsafe.
    
    Parameters:
    
    conf -
    
    Throws:
    
    IOException
  - FSTObjectOutput
```
public FSTObjectOutput()
```
    serialize without an underlying stream, the resulting byte array of writing to this FSTObjectOutput can be accessed using getBuffer(), the size using getWritten(). Note once you call close or flush, the tmp byte array is lost. (grab array before flushing/closing) uses default configuration singleton
    
    Throws:
    
    IOException
- Method Detail
  - flush
```
public void flush()
           throws IOException
```
    Flushes this data output stream. This forces any buffered output bytes to be written out to the stream.
    The flush method of DataOutputStream calls the flush method of its underlying output stream.
    
    Specified by:
    
    flush in interface ObjectOutput
    
    Throws:
    
    IOException - if an I/O error occurs.
    
    See Also:
    
    FilterOutputStream.out, OutputStream.flush()
  - close
```
public void close()
           throws IOException
```
    Specified by:
    
    close in interface ObjectOutput
    
    Specified by:
    
    close in interface AutoCloseable
    
    Throws:
    
    IOException
  - getWriteExternalWriteAhead
```
public int getWriteExternalWriteAhead()
```
    since the stock writeXX methods on InputStream are final, i can't ensure sufficient bufferSize on the output buffer before calling writeExternal. Default value is 5000 bytes. If you make use of the externalizable interface and write larger Objects a) cast the ObjectOutput in readExternal to FSTObjectOutput and call ensureFree on this in your writeExternal method or b) statically set a sufficient maximum using this method.
  - setWriteExternalWriteAhead
```
public void setWriteExternalWriteAhead(int writeExternalWriteAhead)
```
    since the stock writeXX methods on InputStream are final, i can't ensure sufficient bufferSize on the output buffer before calling writeExternal. Default value is 5000 bytes. If you make use of the externalizable interface and write larger Objects a) cast the ObjectOutput in readExternal to FSTObjectOutput and call ensureFree on this in your writeExternal method or b) statically set a sufficient maximum using this method.
    
    Parameters:
    
    writeExternalWriteAhead -
  - ensureFree
```
public void ensureFree(int bytes)
                throws IOException
```
    Throws:
    
    IOException
  - writeObject
```
public void writeObject(Object obj)
                 throws IOException
```
    Specified by:
    
    writeObject in interface ObjectOutput
    
    Throws:
    
    IOException
  - write
```
public void write(int b)
           throws IOException
```
    Specified by:
    
    write in interface DataOutput
    
    Specified by:
    
    write in interface ObjectOutput
    
    Throws:
    
    IOException
  - write
```
public void write(byte[] b)
           throws IOException
```
    Specified by:
    
    write in interface DataOutput
    
    Specified by:
    
    write in interface ObjectOutput
    
    Throws:
    
    IOException
  - write
```
public void write(byte[] b,
                  int off,
                  int len)
           throws IOException
```
    Specified by:
    
    write in interface DataOutput
    
    Specified by:
    
    write in interface ObjectOutput
    
    Throws:
    
    IOException
  - writeBoolean
```
public void writeBoolean(boolean v)
                  throws IOException
```
    Specified by:
    
    writeBoolean in interface DataOutput
    
    Throws:
    
    IOException
  - writeByte
```
public void writeByte(int v)
               throws IOException
```
    Specified by:
    
    writeByte in interface DataOutput
    
    Throws:
    
    IOException
  - writeShort
```
public void writeShort(int v)
                throws IOException
```
    Specified by:
    
    writeShort in interface DataOutput
    
    Throws:
    
    IOException
  - writeChar
```
public void writeChar(int v)
               throws IOException
```
    Specified by:
    
    writeChar in interface DataOutput
    
    Throws:
    
    IOException
  - writeInt
```
public void writeInt(int v)
              throws IOException
```
    Specified by:
    
    writeInt in interface DataOutput
    
    Throws:
    
    IOException
  - writeLong
```
public void writeLong(long v)
               throws IOException
```
    Specified by:
    
    writeLong in interface DataOutput
    
    Throws:
    
    IOException
  - writeFloat
```
public void writeFloat(float v)
                throws IOException
```
    Specified by:
    
    writeFloat in interface DataOutput
    
    Throws:
    
    IOException
  - writeDouble
```
public void writeDouble(double v)
                 throws IOException
```
    Specified by:
    
    writeDouble in interface DataOutput
    
    Throws:
    
    IOException
  - writeBytes
```
public void writeBytes(String s)
                throws IOException
```
    Specified by:
    
    writeBytes in interface DataOutput
    
    Throws:
    
    IOException
  - writeChars
```
public void writeChars(String s)
                throws IOException
```
    Specified by:
    
    writeChars in interface DataOutput
    
    Throws:
    
    IOException
  - writeUTF
```
public void writeUTF(String s)
              throws IOException
```
    Specified by:
    
    writeUTF in interface DataOutput
    
    Throws:
    
    IOException
  - writeObject
```
public void writeObject(Object obj,
                        Class... possibles)
                 throws IOException
```
    Throws:
    
    IOException
  - writeObjectInternal
```
public FSTClazzInfo writeObjectInternal(Object obj,
                                        FSTClazzInfo ci,
                                        Class... possibles)
                                 throws IOException
```
    Parameters:
    
    obj -
    
    ci -
    
    possibles -
    
    Returns:
    
    last FSTClazzInfo if class is plain reusable (not replaceable, needs compatible mode)
    
    Throws:
    
    IOException
  - getListener
```
public FSTSerialisationListener getListener()
```
  - setListener
```
public void setListener(FSTSerialisationListener listener)
```
    note this might slow down serialization significantly * @param listener
  - objectWillBeWritten
```
protected void objectWillBeWritten(Object obj,
                                   int streamPosition)
```
    hook for debugging profiling. empty impl, you need to subclass to make use of this hook
    
    Parameters:
    
    obj -
    
    streamPosition -
  - objectHasBeenWritten
```
protected void objectHasBeenWritten(Object obj,
                                    int oldStreamPosition,
                                    int streamPosition)
```
    hook for debugging profiling. empty impl, you need to subclass to make use of this hook
    
    Parameters:
    
    obj -
    
    oldStreamPosition -
    
    streamPosition -
  - writeObjectWithContext
```
protected FSTClazzInfo writeObjectWithContext(FSTClazzInfo.FSTFieldInfo referencee,
                                              Object toWrite)
                                       throws IOException
```
    Throws:
    
    IOException
  - writeObjectWithContext
```
protected FSTClazzInfo writeObjectWithContext(FSTClazzInfo.FSTFieldInfo referencee,
                                              Object toWrite,
                                              FSTClazzInfo ci)
                                       throws IOException
```
    Throws:
    
    IOException
  - getFstClazzInfo
```
protected FSTClazzInfo getFstClazzInfo(FSTClazzInfo.FSTFieldInfo referencee,
                                       Class clazz)
```
    if class is same as last referenced, returned cached clzinfo, else do a lookup
  - defaultWriteObject
```
public void defaultWriteObject(Object toWrite,
                               FSTClazzInfo serializationInfo)
                        throws IOException
```
    Throws:
    
    IOException
  - writeObjectCompatible
```
protected void writeObjectCompatible(FSTClazzInfo.FSTFieldInfo referencee,
                                     Object toWrite,
                                     FSTClazzInfo serializationInfo)
                              throws IOException
```
    Throws:
    
    IOException
  - writeObjectHeader
```
protected boolean writeObjectHeader(FSTClazzInfo clsInfo,
                                    FSTClazzInfo.FSTFieldInfo referencee,
                                    Object toWrite)
                             throws IOException
```
    Parameters:
    
    clsInfo -
    
    referencee -
    
    toWrite -
    
    Returns:
    
    true if header already wrote object
    
    Throws:
    
    IOException
  - writeArray
```
protected void writeArray(FSTClazzInfo.FSTFieldInfo referencee,
                          Object array)
                   throws IOException
```
    Throws:
    
    IOException
  - writeStringUTF
```
public void writeStringUTF(String str)
                    throws IOException
```
    Throws:
    
    IOException
  - resetForReUse
```
public void resetForReUse(OutputStream out)
```
    if out == null => automatically create/reuse a bytebuffer
    
    Parameters:
    
    out -
  - resetForReUse
```
public void resetForReUse()
```
    reset keeping the last used byte[] buffer
  - resetForReUse
```
public void resetForReUse(byte[] out)
```
  - getClassInfoRegistry
```
public FSTClazzInfoRegistry getClassInfoRegistry()
```
  - getObjectOutputStream
```
public ObjectOutputStream getObjectOutputStream(Class cl,
                                                FSTClazzInfo clinfo,
                                                FSTClazzInfo.FSTFieldInfo referencee,
                                                Object toWrite)
                                         throws IOException
```
    Parameters:
    
    cl - - class or superclass of currently serialized obj, write declared fields of this class only
    
    clinfo -
    
    referencee -
    
    toWrite -
    
    Returns:
    
    Throws:
    
    IOException
  - getObjectMap
```
public FSTObjectRegistry getObjectMap()
```
  - getBuffer
```
public byte[] getBuffer()
```
    Returns:
    
    the written buffer reference. use getWritten() to obtain the length of written bytes. WARNING: if more than one objects have been written, an implicit flush is triggered, so the buffer only contains the last written object. getWritten() then has a larger size than the buffer length. only usable if one single object is written to the stream (e.g. messaging) note: in case of non-standard underlyings (e.g. serializing to direct offheap or DirectBuffer, this method might cause creation of a byte array and a copy.
  - getCopyOfWrittenBuffer
```
public byte[] getCopyOfWrittenBuffer()
```
    Returns:
    
    a copy of written bytes. Warning: if the stream has been flushed, this will fail with an exception. a flush is triggered after each 1st level writeObject. note: in case of non-stream based serialization (directbuffer, offheap mem) getBuffer will return a copy anyways.
  - getConf
```
public FSTConfiguration getConf()
```
  - getWritten
```
public int getWritten()
```
    Returns:
    
    the number of bytes written to this stream. This also is the number of valid bytes in the buffer one obtains from the various getBuffer, getCopyOfBuffer methods. Warning: if the stream has been flushed (done after each 1st level object write), the buffer will be smaller than the value given here or contain invalid bytes.
  - writeClassTag
```
public void writeClassTag(Class aClass)
```
  - getCodec
```
public FSTEncoder getCodec()
```
  - setCodec
```
protected void setCodec(FSTEncoder codec)
```

Class FSTObjectOutput

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

NULL_PLACEHOLDER

SPECIAL_COMPATIBILITY_OBJECT_TAG

ONE_OF

BIG_BOOLEAN_FALSE

BIG_BOOLEAN_TRUE

BIG_LONG

BIG_INT

DIRECT_ARRAY_OBJECT

HANDLE

ENUM

ARRAY

STRING

TYPED

DIRECT_OBJECT

NULL

OBJECT

codec

conf

objects

curDepth

writeExternalWriteAhead

listener

Constructor Detail

FSTObjectOutput

FSTObjectOutput

FSTObjectOutput

FSTObjectOutput

Method Detail

flush

close

getWriteExternalWriteAhead

setWriteExternalWriteAhead

ensureFree

writeObject

write

write

write

writeBoolean

writeByte

writeShort

writeChar

writeInt

writeLong

writeFloat

writeDouble

writeBytes

writeChars

writeUTF

writeObject

writeObjectInternal

getListener

setListener

objectWillBeWritten

objectHasBeenWritten

writeObjectWithContext

writeObjectWithContext

getFstClazzInfo

defaultWriteObject

writeObjectCompatible

writeObjectHeader

writeArray

writeStringUTF

resetForReUse

resetForReUse

resetForReUse

getClassInfoRegistry

getObjectOutputStream

getObjectMap

getBuffer

getCopyOfWrittenBuffer

getConf

getWritten

writeClassTag

getCodec