Struct EventEnvelope 

pub struct EventEnvelope<P> {
    pub id: EventId,
    pub name: EventName,
    pub kind: EventKind,
    pub source: EventSource,
    pub target: Option<EventTarget>,
    pub timestamp: EventTimestamp,
    pub metadata: EventMetadata,
    pub payload: P,
}

Fields

id: EventId

name: EventName

kind: EventKind

source: EventSource

target: Option<EventTarget>

timestamp: EventTimestamp

metadata: EventMetadata

payload: P

Implementations

impl<P> EventEnvelope<P>

pub fn new( name: EventName, kind: EventKind, source: EventSource, payload: P, ) -> EventEnvelope<P>

Examples found in repository

examples/basic_usage.rs (lines 5-10)

fn main() {
    let event = EventEnvelope::new(
        EventName::new("command.started"),
        EventKind::Started,
        EventSource::new("cli"),
        "rustuse build",
    );

    assert_eq!(event.name.as_str(), "command.started");
    assert_eq!(event.payload, "rustuse build");

    let mut log = EventLog::new();
    log.append(EventName::new("test.started"));
    log.append(EventName::new("test.passed"));

    assert_eq!(log.len(), 2);
    assert_eq!(log.last().map(EventName::as_str), Some("test.passed"));
}

pub fn with_id(self, id: impl Into<EventId>) -> EventEnvelope<P>

pub fn with_target(self, target: impl Into<EventTarget>) -> EventEnvelope<P>

pub fn with_metadata(self, metadata: EventMetadata) -> EventEnvelope<P>

pub fn with_timestamp(self, timestamp: EventTimestamp) -> EventEnvelope<P>

Trait Implementations

impl<P> Clone for EventEnvelope<P>

where P: Clone,

fn clone(&self) -> EventEnvelope<P>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<P> Debug for EventEnvelope<P>

where P: Debug,

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

Formats the value using the given formatter.

impl<P> PartialEq for EventEnvelope<P>

where P: PartialEq,

fn eq(&self, other: &EventEnvelope<P>) -> 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<P> Eq for EventEnvelope<P>

where P: Eq,

impl<P> StructuralPartialEq for EventEnvelope<P>