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 |
MissingAttachmentsException |
class MissingAttachmentsException : Exception Thrown during deserialisation to indicate that an attachment needed to construct the WireTransaction is not found |
kotlin.ByteArray | |
kotlin.String |
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? |
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 |