Struct Reduction 

pub struct Reduction<A> { /* private fields */ }

Describes the result of a successful LogManager::reduce operation.

This is what is stored in the ReductionCache. During subsequent reductions, the LogManager only selects the events with indexes higher than the through_index.

Implementations

impl<A> Reduction<A>

pub fn log_id(&self) -> &LogId

Returns the ID of the log that was reduced.

pub fn reduced_at(&self) -> DateTime<Utc>

Returns the wall-clock time at which the reduction occurred. This is for informational purposes only since the clocks on different service instances using this library might be skewed.

pub fn through_index(&self) -> u32

Returns the max event index included in the Aggregate.

pub fn aggregate(&self) -> &A

Returns a reference to the Aggregate.

pub fn log_state(&self) -> LogState

Returns a LogState that can be passed to LogManager::append. Typically you don’t need to call this directly, and can instead just pass the Reduction itself to LogManager::append since it can be converted automatically into a LogState.

Trait Implementations

impl<A: Clone> Clone for Reduction<A>

fn clone(&self) -> Reduction<A>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<A: Debug> Debug for Reduction<A>

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

Formats the value using the given formatter.

impl<'de, A> Deserialize<'de> for Reduction<A>

where A: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<A> From<Reduction<A>> for LogState

Converts a Reduction into a LogState by calling Reduction::log_state.

fn from(reduction: Reduction<A>) -> Self

Converts to this type from the input type.

impl<A: PartialEq> PartialEq for Reduction<A>

fn eq(&self, other: &Reduction<A>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<A> Serialize for Reduction<A>

where A: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<A> StructuralPartialEq for Reduction<A>