maviola 0.3.0

High-level MAVLink communication library with support for essential micro-services.
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

use std::sync::Arc;

use crate::core::io::ChannelInfo;
use crate::core::io::OutgoingFrame;
use crate::core::marker::Proxy;
use crate::core::node::CallbackApiInternal;
use crate::core::utils::Sealed;
use crate::protocol::FrameProcessor;
use crate::sync::node::FrameSender;

use crate::prelude::*;

/// <sup>[`sync`](crate::sync)</sup>
/// Callback object which caller receives upon each incoming frame.
///
/// You can control how to respond to incoming frames by choosing a channel to which response will
/// be broadcast (import [`CallbackApi`] or use [`prelude`](crate::prelude) to access these
/// methods):
///
/// * [`Callback::send`] sends frame to all possible channels.
/// * [`Callback::respond`] sends frame directly to the sender's channel.
/// * [`Callback::broadcast`] broadcast frame to all channels except the one from which the
///   original frame was received.
/// * [`Callback::broadcast_within`] broadcast frame to all channels within sender's connection
///   except the channel from which the original frame was received.
/// * [`Callback::broadcast_except`] broadcast frame to all connections except the one which sent
///   this frame.
/// * [`Callback::forward`] forward a frame to all channels of a specific connection.
#[derive(Clone, Debug)]
pub struct Callback<V: MaybeVersioned> {
    channel_info: ChannelInfo,
    sender: FrameSender<V, Proxy>,
}

impl<V: MaybeVersioned> Callback<V> {
    pub(super) fn new(channel_info: ChannelInfo, sender: FrameSender<V, Proxy>) -> Self {
        Self {
            channel_info,
            sender,
        }
    }

    pub(in crate::sync) fn set_processor(&mut self, processor: Arc<FrameProcessor>) {
        self.sender.set_processor(processor);
    }
}

impl<V: MaybeVersioned> Sealed for Callback<V> {}

impl<V: MaybeVersioned> CallbackApiInternal<V> for Callback<V> {
    unsafe fn send_internal(&self, frame: OutgoingFrame<V>) -> Result<()> {
        self.sender.send_raw(frame).map_err(Error::from).map(|_| ())
    }

    fn process_frame(&self, frame: &Frame<V>) -> Result<Frame<V>> {
        let mut frame = frame.clone();
        self.sender.processor().process_outgoing(&mut frame)?;
        Ok(frame)
    }
}

impl<V: MaybeVersioned> CallbackApi<V> for Callback<V> {
    fn info(&self) -> &ChannelInfo {
        &self.channel_info
    }
}

impl<V: MaybeVersioned> From<Callback<V>> for ChannelInfo {
    fn from(value: Callback<V>) -> Self {
        value.channel_info
    }
}