Struct Event 

pub struct Event {
    pub id: EventId,
    pub schema_version: u32,
    pub ts_ms: i64,
    pub actor: ActorRef,
    pub kind: String,
    pub payload: Value,
    pub causation_id: Option<EventId>,
    pub correlation_id: Option<String>,
}

Fields

id: EventId

schema_version: u32

ts_ms: i64

actor: ActorRef

kind: String

payload: Value

causation_id: Option<EventId>

correlation_id: Option<String>

Implementations

impl Event

pub fn new(actor: ActorRef, kind: impl Into<String>, payload: JsonValue) -> Self

Examples found in repository

examples/behavior_subscription.rs (lines 34-38)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let state = YoAgentState::load(MemoryEventStore::new()).await?;
    let mut runtime = YoAgentRuntime::new(state.clone());

    runtime.register_behavior(FnBehavior::new(
        BehaviorId::new("behavior_failure_to_task"),
        EventPattern::Kind("failure.observed".to_string()),
        |_ctx: BehaviorContext, event: Event| async move {
            let title = event
                .payload
                .get("title")
                .and_then(|value| value.as_str())
                .unwrap_or("Investigate failure");
            Ok(vec![StateOp::CreateNode {
                id: NodeId::new("task_from_failure"),
                kind: "task".to_string(),
                props: json!({
                    "title": format!("Investigate: {title}"),
                    "status": "Open",
                    "created_by_behavior": "behavior_failure_to_task",
                }),
            }])
        },
    ));

    runtime
        .emit_event(Event::new(
            ActorRef::agent("demo"),
            "failure.observed",
            json!({ "title": "retry timeout loses state" }),
        ))
        .await?;

    print!(
        "{}",
        state
            .lineage(NodeId::new("task_from_failure"))
            .await
            .to_markdown()
    );
    Ok(())
}

pub fn with_causation(self, event_id: EventId) -> Self

pub fn with_correlation(self, correlation_id: impl Into<String>) -> Self

pub fn payload_as<T>(&self) -> Result<T, StateError>

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

Trait Implementations

impl Clone for Event

fn clone(&self) -> Event

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Event

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Event

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Event

fn eq(&self, other: &Event) -> 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 Serialize for Event

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Event