Struct actyxos_sdk::event::Event

pub struct Event<T> {
    pub lamport: LamportTimestamp,
    pub stream: StreamInfo,
    pub timestamp: TimeStamp,
    pub offset: Offset,
    pub payload: T,
}

Events are delivered in this envelope together with their metadata

Metadata

Ordering and equality do not depend on the type of payload: lamport and stream.source uniquely identify the event and give rise to a total order (first by Lamport timestamp, then by source ID; a source — an ActyxOS node — will never use the same Lamport timestamp more than once).

The contained Lamport timestamp tracks the causal order of events, which may not always be linked to or consistent with real time, especially when events were produced by devices that were not communicating for some time period. This implies that the wall clock timestamp may go backwards when consuming an ordered event stream (this would also be the case due to clock skew between devices).

Illustrative example: two groups of nodes are separated from each other for some time period, for example due to traveling through an area without network coverage. Their logical clocks may advance at different speeds because the number of events created in each group may be different. When sorting by Lamport timestamp, the events from the group with the lower event rate will tend to be sorted earlier than the events from the other group, regardless of the wall clock time at which they occurred.

It is desirable to sort by Lamport timestamps because they provide the correct (intuitive) sort order when nodes are properly communicating, which is the common case. Using device hardware clocks has proven to be quite unreliable because they may jump forward and backward due to human or machine error.

Payload

The EventService client will provide a generic Payload payload type, you may use the extract method to parse the payload as a more specific object.

use serde::{Deserialize, Serialize};
use actyxos_sdk::event::{Event, Payload};

#[derive(Serialize, Deserialize, Debug, Clone)]
struct MyPayload {
    x: f64,
    y: Option<f64>,
}

let event: Event<Payload> = Event::mk_test("semantics", "name", "{\"x\":42}").unwrap();
let my_event: Event<MyPayload> = event.extract::<MyPayload>().expect("expected MyPayload");

Fields

lamport: LamportTimestamp

stream: StreamInfo

timestamp: TimeStamp

offset: Offset

payload: T

Implementations

impl Event<Payload>

pub fn extract<'a, T>(&'a self) -> Result<Event<T>, Error> where
    T: Deserialize<'a> + Clone, 

Try to extract the given type from the generic payload and return a new event envelope if successful. The produced payload is deserialized as efficiently as possible and may therefore still reference memory owned by the Payload. You may need to .clone() it to remove this dependency.

pub fn mk_test(
    semantics: &str,
    name: &str,
    payload: &str
) -> Result<Event<Payload>, Error>

Create an Event instance for testing purposes.

Caveat emptor: This will not generate proper timestamps and two such events will compare equal to each other (so cannot be put into collections without first making their Lamport timestamps unique).

Trait Implementations

impl<T> Abomonation for Event<T> where
    T: Abomonation, 

unsafe fn entomb<W: Write>(&self, _write: &mut W) -> Result<()>

Write any additional information about &self beyond its binary representation.

fn extent(&self) -> usize

Reports the number of further bytes required to entomb self.

unsafe fn exhume<'a, 'b>(
    &'a mut self,
    bytes: &'b mut [u8]
) -> Option<&'b mut [u8]>

Recover any information for &mut self not evident from its binary representation.

impl<T> AddAssign<&'_ Event<T>> for OffsetMap

fn add_assign(&mut self, other: &Event<T>)

Performs the += operation.

impl<T: Clone> Clone for Event<T>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Event<T>

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

Formats the value using the given formatter.

impl<'de, T> Deserialize<'de> for Event<T> where
    T: Deserialize<'de>, 

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl<T> Display for Event<T>

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

Formats the value using the given formatter.

impl<T> Ord for Event<T>

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

Restrict a value to a certain interval.

impl<T> PartialEq<Event<T>> for Event<T>

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl<T> PartialOrd<Event<T>> for Event<T>

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

This method tests less than (for self and other) and is used by the < operator.

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

This method tests less than or equal to (for self and other) and is used by the <= operator.

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

This method tests greater than (for self and other) and is used by the > operator.

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

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T> Serialize for Event<T> where
    T: Serialize, 

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

Serialize this value into the given Serde serializer.

impl<T> SubAssign<&'_ Event<T>> for OffsetMap

fn sub_assign(&mut self, other: &Event<T>)

Ensure that the given event is no longer contained within this OffsetMap.

impl<T> Eq for Event<T>