de.ruedigermoeller.serialization

Class FSTObjectOutput

java.lang.Object

java.io.OutputStream

java.io.FilterOutputStream

java.io.DataOutputStream

de.ruedigermoeller.serialization.FSTObjectOutput

All Implemented Interfaces:

Closeable, DataOutput, Flushable, ObjectOutput, AutoCloseable

Direct Known Subclasses:

FSTObjectOutputNoShared

public class FSTObjectOutput
extends DataOutputStream
implements ObjectOutput

replacement of ObjectOutputStream

Field Summary

Fields

Modifier and Type	Field and Description
protected FSTOutputStream	buffout
FSTClazzNameRegistry	clnames
protected FSTConfiguration	conf
protected int	curDepth
protected FSTObjectRegistry	objects
protected int	writeExternalWriteAhead

Fields inherited from class java.io.DataOutputStream

written

Fields inherited from class java.io.FilterOutputStream

out

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

Methods

Modifier and Type	Method and Description
static Class[]	addToPredictionArray(Class[] possibleClasses, Class aClass)
void	close()
void	defaultWriteObject(Object toWrite, FSTClazzInfo serializationInfo)
void	ensureFree(int bytes)
void	flush() Flushes this data output stream.
byte[]	getBuffer()
FSTClazzInfoRegistry	getClassInfoRegistry()
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
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
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.
protected void	writeArray(FSTClazzInfo.FSTFieldInfo referencee, Object array)
void	writeCChar(char c)
void	writeCCharArr(char[] arr)
void	writeCDouble(double value)
void	writeCFloat(float value) Writes a 4 byte float.
void	writeCInt(int anInt)
void	writeCIntArr(int[] v)
void	writeClass(Class cl)
void	writeClass(FSTClazzInfo clInf)
void	writeClass(Object toWrite)
void	writeCLong(long anInt)
void	writeCShort(short c)
void	writeFBooleanArr(boolean[] array)
void	writeFByte(int v)
void	writeFByteArr(byte[] array)
void	writeFByteArr(byte[] array, int start, int length) does not write length, just plain bytes
void	writeFChar(int v)
void	writeFDouble(double value)
void	writeFDoubleArr(double[] array)
void	writeFFloat(float value) Writes a 4 byte float.
void	writeFFloatArr(float[] array)
void	writeFInt(int v)
void	writeFIntArr(int[] v)
void	writeFIntThin(int[] v)
void	writeFLong(long v)
void	writeFLongArr(long[] array)
void	writeFShort(int v)
void	writeFShortArr(short[] array)
void	writeIntArrCompressed(int[] v)
void	writeObject(Object obj)
void	writeObject(Object obj, Class... possibles)
protected void	writeObjectCompatible(FSTClazzInfo.FSTFieldInfo referencee, Object toWrite, FSTClazzInfo serializationInfo)
protected void	writeObjectHeader(FSTClazzInfo clsInfo, FSTClazzInfo.FSTFieldInfo referencee, Object toWrite)
void	writeObjectInternal(Object obj, Class... possibles)
protected void	writeObjectWithContext(FSTClazzInfo.FSTFieldInfo referencee, Object toWrite)
int	writeStringCompressed(String str)
void	writeStringUTF(String str)

Methods inherited from class java.io.DataOutputStream

size, write, write, writeBoolean, writeByte, writeBytes, writeChar, writeChars, writeDouble, writeFloat, writeInt, writeLong, writeShort, writeUTF

Methods inherited from class java.io.FilterOutputStream

write

Methods inherited from class java.lang.Object

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

Methods inherited from interface java.io.ObjectOutput

write, write, write

Methods inherited from interface java.io.DataOutput

writeBoolean, writeByte, writeBytes, writeChar, writeChars, writeDouble, writeFloat, writeInt, writeLong, writeShort, writeUTF

Field Detail

clnames

public FSTClazzNameRegistry clnames

conf

protected FSTConfiguration conf

objects

protected FSTObjectRegistry objects

buffout

protected FSTOutputStream buffout

curDepth

protected int curDepth

writeExternalWriteAhead

protected int writeExternalWriteAhead

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 reuseit. 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(). 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 Flushable

Specified by:

flush in interface ObjectOutput

Overrides:

flush in class DataOutputStream

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 Closeable

Specified by:

close in interface ObjectOutput

Specified by:

close in interface AutoCloseable

Overrides:

close in class FilterOutputStream

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

writeObject

public void writeObject(Object obj,
               Class... possibles)
                 throws IOException

Throws:

IOException

writeObjectInternal

public void writeObjectInternal(Object obj,
                       Class... possibles)
                         throws IOException

Throws:

IOException

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 void writeObjectWithContext(FSTClazzInfo.FSTFieldInfo referencee,
                          Object toWrite)
                               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 void writeObjectHeader(FSTClazzInfo clsInfo,
                     FSTClazzInfo.FSTFieldInfo referencee,
                     Object toWrite)
                          throws IOException

Throws:

IOException

writeArray

protected void writeArray(FSTClazzInfo.FSTFieldInfo referencee,
              Object array)
                   throws IOException

Throws:

IOException

writeFBooleanArr

public void writeFBooleanArr(boolean[] array)
                      throws IOException

Throws:

IOException

writeFLongArr

public void writeFLongArr(long[] array)
                   throws IOException

Throws:

IOException

writeFFloatArr

public void writeFFloatArr(float[] array)
                    throws IOException

Throws:

IOException

writeFDoubleArr

public void writeFDoubleArr(double[] array)
                     throws IOException

Throws:

IOException

writeFShortArr

public void writeFShortArr(short[] array)
                    throws IOException

Throws:

IOException

writeCCharArr

public void writeCCharArr(char[] arr)
                   throws IOException

Throws:

IOException

writeFByteArr

public void writeFByteArr(byte[] array)
                   throws IOException

Throws:

IOException

writeFByteArr

public void writeFByteArr(byte[] array,
                 int start,
                 int length)
                   throws IOException

does not write length, just plain bytes

Parameters:

array -

length -

Throws:

IOException

writeStringCompressed

public int writeStringCompressed(String str)
                          throws IOException

Throws:

IOException

writeStringUTF

public void writeStringUTF(String str)
                    throws IOException

Throws:

IOException

writeClass

public final void writeClass(Class cl)
                      throws IOException

Throws:

IOException

writeClass

public final void writeClass(FSTClazzInfo clInf)
                      throws IOException

Throws:

IOException

writeClass

public final void writeClass(Object toWrite)
                      throws IOException

Throws:

IOException

addToPredictionArray

public static Class[] addToPredictionArray(Class[] possibleClasses,
                           Class aClass)

writeCShort

public void writeCShort(short c)
                 throws IOException

Throws:

IOException

writeCChar

public void writeCChar(char c)
                throws IOException

Throws:

IOException

writeFChar

public void writeFChar(int v)
                throws IOException

Throws:

IOException

writeFShort

public void writeFShort(int v)
                 throws IOException

Throws:

IOException

writeFByte

public final void writeFByte(int v)
                      throws IOException

Throws:

IOException

writeFInt

public void writeFInt(int v)
               throws IOException

Throws:

IOException

writeFLong

public void writeFLong(long v)
                throws IOException

Throws:

IOException

writeFIntThin

public void writeFIntThin(int[] v)
                   throws IOException

Throws:

IOException

writeIntArrCompressed

public void writeIntArrCompressed(int[] v)
                           throws IOException

Throws:

IOException

writeFIntArr

public void writeFIntArr(int[] v)
                  throws IOException

Throws:

IOException

writeCIntArr

public void writeCIntArr(int[] v)
                  throws IOException

Throws:

IOException

writeCInt

public void writeCInt(int anInt)
               throws IOException

Throws:

IOException

writeCFloat

public void writeCFloat(float value)
                 throws IOException

Writes a 4 byte float.

Throws:

IOException

writeFFloat

public void writeFFloat(float value)
                 throws IOException

Writes a 4 byte float.

Throws:

IOException

writeCDouble

public void writeCDouble(double value)
                  throws IOException

Throws:

IOException

writeFDouble

public void writeFDouble(double value)
                  throws IOException

Throws:

IOException

writeCLong

public void writeCLong(long anInt)
                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 valid length of written bytes.

getCopyOfWrittenBuffer

public byte[] getCopyOfWrittenBuffer()

Returns:

a copy of written bytes

getConf

public FSTConfiguration getConf()

getWritten

public int getWritten()