com.hazelcast.internal.serialization

Interface InternalSerializationService

All Superinterfaces:

Disposable, SerializationService

All Known Implementing Classes:

AbstractSerializationService, SerializationServiceV1

public interface InternalSerializationService
extends SerializationService, Disposable

Field Summary

Fields

Modifier and Type	Field and Description
static byte	VERSION_1

Method Summary

Modifier and Type	Method and Description
<B extends Data> B	convertData(Data data, DataType type)
BufferObjectDataInput	createObjectDataInput(byte[] data)
BufferObjectDataInput	createObjectDataInput(Data data)
BufferObjectDataOutput	createObjectDataOutput()
BufferObjectDataOutput	createObjectDataOutput(int size)
PortableReader	createPortableReader(Data data)
void	disposeData(Data data)
ByteOrder	getByteOrder()
ClassLoader	getClassLoader()
PortableContext	getPortableContext()
byte	getVersion()
<T> T	readObject(ObjectDataInput in)
<T> T	readObject(ObjectDataInput in, Class aClass)
byte[]	toBytes(Object obj) Writes the obj to a byte array.
byte[]	toBytes(Object obj, int leftPadding, boolean insertPartitionHash) Writes an object to a byte-array.
<B extends Data> B	toData(Object obj, DataType type)
<B extends Data> B	toData(Object obj, DataType type, PartitioningStrategy strategy)
void	writeObject(ObjectDataOutput out, Object obj)

Methods inherited from interface com.hazelcast.spi.serialization.SerializationService

getManagedContext, toData, toData, toObject, toObject

Methods inherited from interface com.hazelcast.nio.Disposable

dispose

Field Detail

VERSION_1

static final byte VERSION_1

See Also:

Constant Field Values

Method Detail

toBytes

byte[] toBytes(Object obj)

Writes the obj to a byte array. This call is exactly the same as calling SerializationService.toData(Object) and then calling Data.toByteArray(). But it doesn't force a HeapData object being created.

toBytes

byte[] toBytes(Object obj,
               int leftPadding,
               boolean insertPartitionHash)

Writes an object to a byte-array. It allows for configurable padding on the left. The padded bytes are not zero'd out since they will be written by the caller. Zero'ing them out would be waste of time. If you want to convert an object to a Data (or its byte representation) then you want to have the partition hash, because that is part of the Data-definition. But if you want to serialize an object to a byte-array and don't care for the Data partition-hash, the hash can be disabled.

toData

<B extends Data> B toData(Object obj,
                          DataType type)

toData

<B extends Data> B toData(Object obj,
                          DataType type,
                          PartitioningStrategy strategy)

convertData

<B extends Data> B convertData(Data data,
                               DataType type)

writeObject

void writeObject(ObjectDataOutput out,
                 Object obj)

readObject

<T> T readObject(ObjectDataInput in)

readObject

<T> T readObject(ObjectDataInput in,
                 Class aClass)

disposeData

void disposeData(Data data)

createObjectDataInput

BufferObjectDataInput createObjectDataInput(byte[] data)

createObjectDataInput

BufferObjectDataInput createObjectDataInput(Data data)

createObjectDataOutput

BufferObjectDataOutput createObjectDataOutput(int size)

createObjectDataOutput

BufferObjectDataOutput createObjectDataOutput()

createPortableReader

PortableReader createPortableReader(Data data)
                             throws IOException

Throws:

IOException

getPortableContext

PortableContext getPortableContext()

getClassLoader

ClassLoader getClassLoader()

getByteOrder

ByteOrder getByteOrder()

getVersion

byte getVersion()