Struct Split 

pub struct Split<T> {
    pub own: Vec<T>,
    pub other: Vec<T>,
}

What a two-stream command writes, split by where each part lands.

The SPI is otherwise scoped to a single stream, and this is the one shape that is not: an allocation is a move between two ledgers, so the events that record it belong to two streams and either both land or neither may (EventStore::append_if_many). Naming the two halves is what keeps that from becoming a list the backend has to guess the routing of.

own is this store’s stream — the one it was opened on — and other is the stream named at the call. Either may be empty: a refused allocation writes the refusal on the parent and opens nothing.

The same shape carries the decision’s input (EventStore::append_if_many): what it is shown from this stream, and what it is shown from the other one. One name for both directions, because the two streams are the same two streams either way.

Fields

own: Vec<T>

What lands on this store’s own stream.

other: Vec<T>

What lands on the other stream of the same database.

Implementations

impl<T> Split<T>

pub fn own(own: Vec<T>) -> Self

A split that writes only this store’s own stream.

Trait Implementations

impl<T: Clone> Clone for Split<T>

fn clone(&self) -> Split<T>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug> Debug for Split<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: Eq> Eq for Split<T>

impl<T: PartialEq> PartialEq for Split<T>

fn eq(&self, other: &Split<T>) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl<T: PartialEq> StructuralPartialEq for Split<T>