com.r3corda.core.serialization

Package com.r3corda.core.serialization

Types

ImmutableClassSerializer class ImmutableClassSerializer<T : Any>

Serializes properties and deserializes by using the constructor. This assumes that all backed properties are set via the constructor and the class is immutable.

NoReferencesSerializer class NoReferencesSerializer<T>
OpaqueBytes open class OpaqueBytes

A simple class that wraps a byte array and makes the equals/hashCode/toString methods work as you actually expect. In an ideal JVM this would be a value type and be completely overhead free. Project Valhalla is adding such functionality to Java, but it wont arrive for a few years yet

ReferencesAwareJavaSerializer object ReferencesAwareJavaSerializer

Improvement to the builtin JavaSerializer by honouring the Kryo.getReferences setting.

SerializationToken interface SerializationToken

This represents a token in the serialized stream for an instance of a type that implements SerializeAsToken

SerializeAsToken interface SerializeAsToken

This interface should be implemented by classes that want to substitute a token representation of themselves if they are serialized because they have a lot of internal state that does not serialize (well).

SerializeAsTokenContext class SerializeAsTokenContext

A context for mapping SerializationTokens to/from SerializeAsTokens.

SerializeAsTokenSerializer class SerializeAsTokenSerializer<T : SerializeAsToken>

A Kryo serializer for SerializeAsToken implementations.

SerializedBytes class SerializedBytes<T : Any> : OpaqueBytes

A type safe wrapper around a byte array that contains a serialised object. You can call SerializedBytes.deserialize to get the original object back.

SerializedBytesSerializer object SerializedBytesSerializer

A serialiser that avoids writing the wrapper class to the byte stream, thus ensuring SerializedBytes is a pure type safety hack.

SingletonSerializationToken data class SingletonSerializationToken : SerializationToken

A class representing a SerializationToken for some object that is not serializable but can be looked up (when deserialized) via just the class name.

SingletonSerializeAsToken abstract class SingletonSerializeAsToken : SerializeAsToken

A base class for implementing large objects / components / services that need to serialize themselves to a string token to indicate which instance the token is a serialized form of.

WireTransactionSerializer object WireTransactionSerializer

A serialisation engine that knows how to deserialise code inside a sandbox

Exceptions

MissingAttachmentsException class MissingAttachmentsException : Exception

Thrown during deserialisation to indicate that an attachment needed to construct the WireTransaction is not found

Extensions for External Classes

kotlin.ByteArray

Properties

ATTACHMENT_STORAGE val ATTACHMENT_STORAGE: String
THREAD_LOCAL_KRYO val THREAD_LOCAL_KRYO: <ERROR CLASS>

Serialization utilities, using the Kryo framework with a custom serialiser for immutable data classes and a dead simple, totally non-extensible binary (sub)format.

attachmentStorage var <ERROR CLASS>.attachmentStorage: AttachmentStorage?

Functions

createKryo fun createKryo(k: <ERROR CLASS> = Kryo()): <ERROR CLASS>
deserialize fun <T : Any> OpaqueBytes.deserialize(kryo: <ERROR CLASS> = THREAD_LOCAL_KRYO.get()): T
fun SerializedBytes<WireTransaction>.deserialize(kryo: <ERROR CLASS> = THREAD_LOCAL_KRYO.get()): WireTransaction
fun <T : Any> SerializedBytes<T>.deserialize(kryo: <ERROR CLASS> = THREAD_LOCAL_KRYO.get()): T
noReferencesWithin fun <T : Any> <ERROR CLASS>.noReferencesWithin(): Unit

Use this method to mark any types which can have the same instance within it more than once. This will make sure the serialised form is stable across multiple serialise-deserialise cycles. Using this on a type with internal cyclic references will throw a stack overflow exception during serialisation.

serialize fun <T : Any> T.serialize(kryo: <ERROR CLASS> = THREAD_LOCAL_KRYO.get()): SerializedBytes<T>

Can be called on any object to convert it to a byte array (wrapped by SerializedBytes), regardless of whether the type is marked as serializable or was designed for it (so be careful)

useClassLoader fun <T> <ERROR CLASS>.useClassLoader(cl: ClassLoader, body: () -> T): T