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
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

use std::sync::Arc;

use crate::core::io::{BroadcastScope, OutgoingFrame};
use crate::core::marker::{Edge, NodeKind, Proxy};
use crate::core::node::{SendFrameInternal, SendMessageInternal};
use crate::core::utils::Sealed;
use crate::error::SendResult;
use crate::protocol::FrameProcessor;
use crate::sync::io::OutgoingFrameSender;

use crate::prelude::*;

/// <sup>[`sync`](crate::sync)</sup>
/// Frame sender for synchronous API.
///
/// **⚠** [`FrameSender`] requires [`SendFrame`], [`SendMessage`], and [`SendVersionlessMessage`]
/// traits to be imported in order to work correctly. The latter two traits make sense only for
/// frame senders exposed by [`Edge`] nodes (like [`EdgeNode`]). You can use [`sync::prelude`] to
/// import these and other essential traits.
///
/// [`EdgeNode`]: crate::sync::node::EdgeNode
/// [`sync::prelude`]: crate::sync::prelude
#[derive(Clone, Debug)]
pub struct FrameSender<V: MaybeVersioned, K: NodeKind> {
    inner: OutgoingFrameSender<V>,
    processor: Arc<FrameProcessor>,
    kind: K,
}

impl<V: MaybeVersioned> FrameSender<V, Proxy> {
    /// <sup>⛔</sup>
    /// Creates a new proxy frame sender.
    pub(super) fn new(sender: OutgoingFrameSender<V>, processor: Arc<FrameProcessor>) -> Self {
        Self {
            inner: sender,
            processor,
            kind: Proxy,
        }
    }

    /// <sup>⛔</sup>
    /// Converts proxy frame sender into edge frame sender.
    pub(super) fn into_edge(self, kind: Edge<V>) -> FrameSender<V, Edge<V>> {
        FrameSender {
            inner: self.inner,
            processor: self.processor,
            kind,
        }
    }
}

impl<V: MaybeVersioned, K: NodeKind> FrameSender<V, K> {
    /// <sup>⛔</sup>
    /// Sends outgoing frame without processing.
    #[inline(always)]
    pub(in crate::sync) fn send_raw(
        &self,
        frame: OutgoingFrame<V>,
    ) -> SendResult<OutgoingFrame<V>> {
        self.inner.send_raw(frame)
    }

    /// <sup>⛔</sup>
    /// Return a reference to internal frame processor.
    pub(in crate::sync) fn processor(&self) -> &FrameProcessor {
        self.processor.as_ref()
    }

    /// <sup>⛔</sup>
    /// Sets frame processor.
    pub(in crate::sync) fn set_processor(&mut self, processor: Arc<FrameProcessor>) {
        self.processor = processor;
    }
}

impl<V: MaybeVersioned, K: NodeKind> Sealed for FrameSender<V, K> {}

impl<V: MaybeVersioned, K: NodeKind> SendFrameInternal<V> for FrameSender<V, K> {
    #[inline(always)]
    fn processor_internal(&self) -> &FrameProcessor {
        self.processor.as_ref()
    }

    #[inline(always)]
    unsafe fn route_frame_internal(&self, frame: Frame<V>, scope: BroadcastScope) -> Result<()> {
        self.send_raw(OutgoingFrame::scoped(frame, scope))
            .map_err(Error::from)
    }
}

impl<V: MaybeVersioned, K: NodeKind> SendFrame<V> for FrameSender<V, K> {}

impl<V: MaybeVersioned> SendMessageInternal<V> for FrameSender<V, Edge<V>> {
    fn endpoint(&self) -> &Endpoint<V> {
        &self.kind.endpoint
    }
}

impl<V: Versioned> SendMessage<V> for FrameSender<V, Edge<V>> {}

impl SendVersionlessMessage for FrameSender<Versionless, Edge<Versionless>> {}