FlowPersistentReprSerializer

abstract def deserialize(t: T): Try[(PersistentRepr, Set[String], Long)]

deserialize into a PersistentRepr, a set of tags and a Long representing the global ordering of events

abstract def serialize(persistentRepr: PersistentRepr, tags: Set[String]): Try[T]

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def deserializeFlow: Flow[T, Try[(PersistentRepr, Set[String], Long)], NotUsed]

A flow which deserializes each element into a PersistentRepr, a set of tags and a Long representing the global ordering of events

def deserializeFlowWithoutTags: Flow[T, Try[PersistentRepr], NotUsed]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def serialize(persistentRepr: PersistentRepr): Try[T]

def serialize(messages: Seq[AtomicWrite]): Seq[Try[Seq[T]]]

An akka.persistence.AtomicWrite contains a Sequence of events (with metadata, the PersistentRepr) that must all be persisted or all fail, what makes the operation atomic.

final def synchronized[T0](arg0: ⇒ T0): T0

def toString(): String

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

final def wait(): Unit

def finalize(): Unit