Struct EventLog 

pub struct EventLog<E> { /* private fields */ }

Implementations

impl<E> EventLog<E>

pub const fn new() -> EventLog<E>

Examples found in repository

examples/basic_usage.rs (line 15)

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 append(&mut self, event: E)

Examples found in repository

examples/basic_usage.rs (line 16)

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 entries(&self) -> &[E]

pub fn last(&self) -> Option<&E>

Examples found in repository

examples/basic_usage.rs (line 20)

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 len(&self) -> usize

Examples found in repository

examples/basic_usage.rs (line 19)

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 is_empty(&self) -> bool

Trait Implementations

impl<E> Clone for EventLog<E>

where E: Clone,

fn clone(&self) -> EventLog<E>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<E> Debug for EventLog<E>

where E: Debug,

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

Formats the value using the given formatter.

impl<E> Default for EventLog<E>

where E: Default,

fn default() -> EventLog<E>

Returns the “default value” for a type.

impl<E> PartialEq for EventLog<E>

where E: PartialEq,

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

where E: Eq,

impl<E> StructuralPartialEq for EventLog<E>