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

public class FSTObjectOutput
extends DataOutputStream
implements ObjectOutput

Created with IntelliJ IDEA. User: Möller Date: 03.11.12 Time: 12:26 To change this template use File | Settings | File Templates.

Field Summary

Fields

Modifier and Type	Field and Description
FSTClazzNameRegistry	clnames

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()
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()
static void	main(String[] arg)
void	resetForReUse(OutputStream out) if out == null => automatically create/reuse a bytebuffer
void	setListener(FSTSerialisationListener listener) note this might slowdown serialization significatly
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	writeCChar(char c)
void	writeCCharArr(char[] array)
void	writeCDouble(double value)
void	writeCDoubleUnsafe(double value)
void	writeCFloat(float value) Writes a 4 byte float.
void	writeCFloatUnsafe(float value) Writes a 4 byte float.
void	writeCInt(int anInt)
void	writeCIntArr(int[] v)
void	writeCIntArrUnsafe(int[] v)
void	writeClass(Object toWrite)
void	writeCLong(long anInt)
void	writeCLongUnsafe(long anInt)
void	writeCShort(short c)
void	writeFBooleanArr(boolean[] array)
void	writeFByte(int v)
void	writeFByteArr(byte[] array)
void	writeFByteUnsafe(int v)
void	writeFChar(int v)
void	writeFCharArr(char[] array)
void	writeFDouble(double value)
void	writeFDoubleArr(double[] array)
void	writeFDoubleUnsafe(double value)
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	writeFIntUnsafe(int v)
void	writeFLong(long v)
void	writeFLongArr(long[] array)
void	writeFLongArrayUnsafe(long[] arr)
void	writeFLongUnsafe(long v)
void	writeFShort(int v)
void	writeFShortArr(short[] array)
void	writeIntArrCompressed(int[] v)
void	writeObject(Object obj)
void	writeObject(Object obj, Class... possibles)
protected void	writeObjectHeader(FSTClazzInfo clsInfo, FSTClazzInfo.FSTFieldInfo referencee, Object toWrite)
void	writeObjectInternal(Object obj, Class... possibles)
void	writePlainIntArrUnsafe(int[] v)
int	writeStringCompressed(String str)
void	writeStringUTF(String str)
void	writeStringUTFSpeed(String str)
void	writeStringUTFUnsafe(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

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

getListener

public FSTSerialisationListener getListener()

setListener

public void setListener(FSTSerialisationListener listener)

note this might slowdown serialization significatly

Parameters:

listener -

defaultWriteObject

public void defaultWriteObject(Object toWrite,
                      FSTClazzInfo serializationInfo)
                        throws IOException

Throws:

IOException

writeObjectHeader

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

writeFCharArr

public void writeFCharArr(char[] array)
                   throws IOException

Throws:

IOException

writeCCharArr

public void writeCCharArr(char[] array)
                   throws IOException

Throws:

IOException

writeFByteArr

public void writeFByteArr(byte[] array)
                   throws IOException

Throws:

IOException

writeFLongArrayUnsafe

public void writeFLongArrayUnsafe(long[] arr)
                           throws IOException

Throws:

IOException

writeStringCompressed

public int writeStringCompressed(String str)
                          throws IOException

Throws:

IOException

writeStringUTF

public void writeStringUTF(String str)
                    throws IOException

Throws:

IOException

writeStringUTFSpeed

public void writeStringUTFSpeed(String str)
                         throws IOException

Throws:

IOException

writeStringUTFUnsafe

public void writeStringUTFUnsafe(String str)
                          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

writeFByteUnsafe

public final void writeFByteUnsafe(int v)
                            throws IOException

Throws:

IOException

writeFIntUnsafe

public final void writeFIntUnsafe(int v)
                           throws IOException

Throws:

IOException

writeFInt

public void writeFInt(int v)
               throws IOException

Throws:

IOException

writeFLongUnsafe

public void writeFLongUnsafe(long 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

writePlainIntArrUnsafe

public void writePlainIntArrUnsafe(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

writeCIntArrUnsafe

public void writeCIntArrUnsafe(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

writeCFloatUnsafe

public void writeCFloatUnsafe(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

writeCDoubleUnsafe

public void writeCDoubleUnsafe(double value)
                        throws IOException

Throws:

IOException

writeFDouble

public void writeFDouble(double value)
                  throws IOException

Throws:

IOException

writeFDoubleUnsafe

public void writeFDoubleUnsafe(double value)
                        throws IOException

Throws:

IOException

writeCLongUnsafe

public void writeCLongUnsafe(long anInt)
                      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 -

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()

getCopyOfWrittenBuffer

public byte[] getCopyOfWrittenBuffer()

getConf

public FSTConfiguration getConf()

main

public static void main(String[] arg)
                 throws IOException

Throws:

IOException

getWritten

public int getWritten()