com.r3corda.core.serialization

## Package com.r3corda.core.serialization

### Types

DeserializeAsKotlinObjectDef | `interface DeserializeAsKotlinObjectDef` Marker interface for kotlin object definitions so that they are deserialized as the singleton instance.
Ed25519PrivateKeySerializer | `object Ed25519PrivateKeySerializer` For serialising an ed25519 private key
Ed25519PublicKeySerializer | `object Ed25519PublicKeySerializer` For serialising an ed25519 public key
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.
KotlinObjectSerializer | `object KotlinObjectSerializer` Serializer to deserialize kotlin object definitions marked with DeserializeAsKotlinObjectDef.
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 |
kotlin.String |

### 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.
readBytesWithLength | `fun <ERROR CLASS>.readBytesWithLength(): ByteArray`
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`
writeBytesWithLength | `fun <ERROR CLASS>.writeBytesWithLength(byteArray: ByteArray): Unit`