nativeshell 0.1.16

NativeShell Rust package
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

use std::marker::PhantomData;

use crate::shell::{BinaryMessengerReply, Context, ContextRef, EngineHandle, EngineManager};

use super::MessageCodec;

pub struct MessageChannel<V>
where
    V: 'static,
{
    context: Context,
    channel_name: String,
    engine_handle: EngineHandle,
    _data: PhantomData<V>,
}

impl<V> MessageChannel<V> {
    pub fn new<F>(
        context: &ContextRef,
        engine_handle: EngineHandle,
        channel_name: &str,
        codec: &'static dyn MessageCodec<V>,
        callback: F,
    ) -> Self
    where
        F: Fn(V, MessageReply<V>) + 'static,
    {
        Self::new_with_engine_manager(
            context.weak(),
            engine_handle,
            channel_name,
            codec,
            callback,
            &context.engine_manager.borrow(),
        )
    }

    pub fn new_with_engine_manager<F>(
        context: Context,
        engine_handle: EngineHandle,
        channel_name: &str,
        codec: &'static dyn MessageCodec<V>,
        callback: F,
        engine_manager: &EngineManager,
    ) -> Self
    where
        F: Fn(V, MessageReply<V>) + 'static,
    {
        let res = MessageChannel {
            context,
            channel_name: channel_name.into(),
            engine_handle,
            _data: PhantomData {},
        };

        let engine = engine_manager.get_engine(engine_handle);
        if let Some(engine) = engine {
            let codec = codec;
            engine
                .binary_messenger()
                .register_channel_handler(channel_name, move |data, reply| {
                    let message = codec.decode_message(data).unwrap();
                    let reply = MessageReply { reply, codec };
                    callback(message, reply);
                });
        }
        res
    }
}

//
//
//

pub struct MessageReply<V>
where
    V: 'static,
{
    reply: BinaryMessengerReply,
    codec: &'static dyn MessageCodec<V>,
}

impl<V> MessageReply<V> {
    pub fn send(self, value: V) {
        let encoded = self.codec.encode_message(&value);
        self.reply.send(&encoded);
    }
}

impl<V> Drop for MessageChannel<V> {
    fn drop(&mut self) {
        if let Some(context) = self.context.get() {
            let engine_manager = context.engine_manager.borrow();
            let engine = engine_manager.get_engine(self.engine_handle);
            if let Some(engine) = engine {
                engine
                    .binary_messenger()
                    .unregister_channel_handler(&self.channel_name);
            }
        }
    }
}