tokio-dbus 0.2.0

Pure Rust D-Bus implementation for Tokio.
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

#[cfg(feature = "alloc")]
use alloc::boxed::Box;

use crate::{MessageKind, ObjectPath, Serial};

/// The kind of a D-Bus message.
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub(crate) enum OwnedMessageKind {
    /// Method call. This message type may prompt a reply.
    MethodCall {
        /// The path being called.
        path: Box<ObjectPath>,
        /// The member being called.
        member: Box<str>,
    },
    /// Method reply with returned data.
    MethodReturn {
        /// The serial this is a reply to.
        reply_serial: Serial,
    },
    /// Error reply. If the first argument exists and is a string, it is an
    /// error message.
    Error {
        /// The name of the error.
        error_name: Box<str>,
        /// The serial this is a reply to.
        reply_serial: Serial,
    },
    /// Signal emission.
    Signal {
        /// The path the signal is emitted from.
        path: Box<ObjectPath>,
        /// The member being signalled.
        member: Box<str>,
    },
}

impl OwnedMessageKind {
    #[inline]
    pub(crate) fn borrow(&self) -> MessageKind<'_> {
        match *self {
            OwnedMessageKind::MethodCall {
                ref path,
                ref member,
            } => MessageKind::MethodCall { path, member },
            OwnedMessageKind::MethodReturn { reply_serial } => {
                MessageKind::MethodReturn { reply_serial }
            }
            OwnedMessageKind::Error {
                ref error_name,
                reply_serial,
            } => MessageKind::Error {
                error_name,
                reply_serial,
            },
            OwnedMessageKind::Signal {
                ref path,
                ref member,
            } => MessageKind::Signal { path, member },
        }
    }
}

impl PartialEq<MessageKind<'_>> for OwnedMessageKind {
    #[inline]
    fn eq(&self, other: &MessageKind<'_>) -> bool {
        *other == *self
    }
}