rustbus 0.19.3

An implementation of the dbus protocol
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
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150

use rustbus::connection::dispatch_conn::DispatchConn;
use rustbus::connection::dispatch_conn::HandleEnvironment;
use rustbus::connection::dispatch_conn::HandleResult;
use rustbus::connection::dispatch_conn::Matches;
use rustbus::connection::ll_conn::DuplexConn;
use rustbus::message_builder::MarshalledMessage;

// just to make the function definitions a bit shorter
type MyHandleEnv<'a, 'b> = HandleEnvironment<&'b mut Counter, ()>;

struct Counter {
    count: u64,
}
fn default_handler(
    c: &mut &mut Counter,
    _matches: Matches,
    msg: &MarshalledMessage,
    _env: &mut MyHandleEnv,
) -> HandleResult<()> {
    c.count += 1;
    println!(
        "Woohoo the default handler got called for \"{:?}\" (the {}'ths time)",
        msg.dynheader.object, c.count
    );
    Ok(None)
}
fn name_handler(
    c: &mut &mut Counter,
    matches: Matches,
    _msg: &MarshalledMessage,
    env: &mut MyHandleEnv,
) -> HandleResult<()> {
    c.count += 1;
    println!(
        "Woohoo a name got called (the {}'ths time): {}",
        c.count,
        matches.matches.get(":name").unwrap()
    );

    let mut name_counter = Counter { count: 0 };
    let name = matches.matches.get(":name").unwrap().to_owned();
    let ch = Box::new(
        move |c: &mut &mut Counter,
              _matches: Matches,
              _msg: &MarshalledMessage,
              _env: &mut MyHandleEnv| {
            name_counter.count += 1;
            c.count += 1;

            println!(
                "Woohoo the closure for {} got called (the {}'ths time)",
                name, name_counter.count
            );
            Ok(None)
        },
    );

    let new_path = format!("/{}", matches.matches.get(":name").unwrap());
    println!("Add new path: \"{}\"", new_path);

    env.new_dispatches.insert(&new_path, ch);

    Ok(None)
}

fn main() {
    let mut con =
        DuplexConn::connect_to_bus(rustbus::connection::get_session_bus_path().unwrap(), false)
            .unwrap();
    con.send_hello(rustbus::connection::Timeout::Infinite)
        .unwrap();

    if std::env::args().find(|arg| "server".eq(arg)).is_some() {
        con.send
            .send_message(&mut rustbus::standard_messages::request_name(
                "killing.spark.io".into(),
                rustbus::standard_messages::DBUS_NAME_FLAG_REPLACE_EXISTING,
            ))
            .unwrap()
            .write_all()
            .unwrap();

        let mut counter = Counter { count: 0 };
        let dh = Box::new(default_handler);
        let nh = Box::new(name_handler);
        let ch = Box::new(
            |c: &mut &mut Counter,
             _matches: Matches,
             _msg: &MarshalledMessage,
             _env: &mut MyHandleEnv| {
                c.count += 1;
                println!("Woohoo the closure got called (the {}'ths time)", c.count,);
                Ok(None)
            },
        );
        let mut dpcon = DispatchConn::new(con, &mut counter, dh);
        dpcon.add_handler("/A/B/:name", nh);
        dpcon.add_handler("/A/C/D", ch);

        dpcon.run().unwrap();
    } else {
        println!("Sending stuff!");

        // default handler
        let mut msg1 = rustbus::message_builder::MessageBuilder::new()
            .call("ABCD")
            .at("killing.spark.io")
            .on("/ABCD")
            .build();
        con.send
            .send_message(&mut msg1)
            .unwrap()
            .write_all()
            .unwrap();

        // pick up the name
        let mut msg2 = rustbus::message_builder::MessageBuilder::new()
            .call("ABCD")
            .at("killing.spark.io")
            .on("/A/B/moritz")
            .build();
        con.send
            .send_message(&mut msg2)
            .unwrap()
            .write_all()
            .unwrap();

        // call new handler for that name
        let mut msg3 = rustbus::message_builder::MessageBuilder::new()
            .call("ABCD")
            .at("killing.spark.io")
            .on("/moritz")
            .build();
        con.send
            .send_message(&mut msg3)
            .unwrap()
            .write_all()
            .unwrap();
        con.send
            .send_message(&mut msg3)
            .unwrap()
            .write_all()
            .unwrap();
        con.send
            .send_message(&mut msg3)
            .unwrap()
            .write_all()
            .unwrap();
    }
}