foxglove 0.22.0

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

use crate::channel::ChannelDescriptor;

/// The reliability policy for a channel's data delivery.
///
/// This determines whether data logged on a channel is sent over the reliable control bytestream
/// or over unreliable data tracks.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum Reliability {
    /// Data is sent over lossy data tracks (unordered, no guaranteed delivery).
    ///
    /// This is the default and is suitable for high-frequency data streams.
    #[default]
    Lossy,
    /// Data is sent over the reliable control channel (ordered, guaranteed delivery).
    ///
    /// Use this for low-frequency, config-like data where every message must be delivered.
    Reliable,
}

/// Quality-of-service profile for a channel.
///
/// Controls how data for a channel is delivered to remote participants.
/// Construct with [`QosProfile::default()`] or [`QosProfile::builder()`].
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub struct QosProfile {
    pub(crate) reliability: Reliability,
}

impl QosProfile {
    /// Returns a builder for constructing a [`QosProfile`].
    pub fn builder() -> QosProfileBuilder {
        QosProfileBuilder::default()
    }

    /// Returns the reliability policy.
    pub fn reliability(&self) -> Reliability {
        self.reliability
    }
}

/// Builder for [`QosProfile`].
#[derive(Debug, Clone, Default)]
pub struct QosProfileBuilder {
    reliability: Reliability,
}

impl QosProfileBuilder {
    /// Sets the reliability policy.
    #[must_use]
    pub fn reliability(mut self, reliability: Reliability) -> Self {
        self.reliability = reliability;
        self
    }

    /// Builds the [`QosProfile`].
    pub fn build(self) -> QosProfile {
        QosProfile {
            reliability: self.reliability,
        }
    }
}

/// Assigns a [`QosProfile`] to channels.
///
/// This callback is invoked during channel registration to determine the quality-of-service
/// profile for each channel.
pub trait QosClassifier: Sync + Send {
    /// Returns the QoS profile for the given channel.
    fn classify(&self, channel: &ChannelDescriptor) -> QosProfile;
}

pub(crate) struct QosClassifierFn<F>(pub F)
where
    F: Fn(&ChannelDescriptor) -> QosProfile + Sync + Send;

impl<F> QosClassifier for QosClassifierFn<F>
where
    F: Fn(&ChannelDescriptor) -> QosProfile + Sync + Send,
{
    fn classify(&self, channel: &ChannelDescriptor) -> QosProfile {
        self.0(channel)
    }
}