pubnub 0.7.0

PubNub SDK for Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89

//! Heartbeat Event Engine effect invocation module.
//!
//! The module contains the [`PresenceEffectInvocation`] type, which describes
//! available event engine effect invocations.

use crate::{
    core::event_engine::EffectInvocation,
    lib::core::fmt::{Display, Formatter, Result},
    presence::event_engine::{PresenceEffect, PresenceEvent, PresenceInput},
};

#[derive(Debug)]
pub(crate) enum PresenceEffectInvocation {
    /// Heartbeat effect invocation.
    Heartbeat {
        /// User input with channels and groups.
        ///
        /// Object contains list of channels and groups for which `user_id`
        /// presence should be announced.
        input: PresenceInput,
    },

    /// Leave effect invocation.
    Leave {
        /// User input with channels and groups.
        ///
        /// Object contains list of channels and groups for which `user_id`
        /// should leave.
        input: PresenceInput,
    },

    /// Delay effect invocation.
    Wait {
        /// User input with channels and groups.
        ///
        /// Object contains list of channels and groups for which `user_id`
        /// presence should be announced.
        input: PresenceInput,
    },

    /// Cancel delay effect invocation.
    CancelWait,

    /// Terminate Presence Event Engine processing loop.
    TerminateEventEngine,
}

impl EffectInvocation for PresenceEffectInvocation {
    type Effect = PresenceEffect;
    type Event = PresenceEvent;

    fn id(&self) -> &str {
        match self {
            Self::Heartbeat { .. } => "HEARTBEAT",
            Self::Leave { .. } => "LEAVE",
            Self::Wait { .. } => "WAIT",
            Self::CancelWait => "CANCEL_WAIT",
            Self::TerminateEventEngine => "TERMINATE_EVENT_ENGINE",
        }
    }

    fn is_managed(&self) -> bool {
        matches!(self, Self::Wait { .. })
    }

    fn is_cancelling(&self) -> bool {
        matches!(self, Self::CancelWait)
    }

    fn cancelling_effect(&self, effect: &Self::Effect) -> bool {
        matches!(effect, PresenceEffect::Wait { .. }) && matches!(self, Self::CancelWait { .. })
    }

    fn is_terminating(&self) -> bool {
        matches!(self, Self::TerminateEventEngine)
    }
}

impl Display for PresenceEffectInvocation {
    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
        match self {
            Self::Heartbeat { .. } => write!(f, "HEARTBEAT"),
            Self::Leave { .. } => write!(f, "LEAVE"),
            Self::Wait { .. } => write!(f, "WAIT"),
            Self::CancelWait => write!(f, "CANCEL_WAIT"),
            Self::TerminateEventEngine => write!(f, "TERMINATE_EVENT_ENGINE"),
        }
    }
}