rosrustext_rosrs 0.4.1

rclrs adapter for rosrustext ROS 2 lifecycle + parameters parity
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
151
152
153
154

use std::borrow::Cow;
use std::marker::PhantomData;
use std::sync::Arc;

use rclrs::{AnySubscriptionCallback, IntoNodeSubscriptionCallback, QoSProfile, RclrsError, SubscriptionOptions};

use super::{HasCallback, ManagedSubscription, NoCallback};

/// Builder for lifecycle-managed subscriptions (ungated by default).
///
/// This owns all configuration data; no borrowed references are retained.
pub struct ManagedSubscriptionBuilder<T, State>
where
    T: rclrs::MessageIDL,
{
    node: Arc<rclrs::Node>,
    topic: String,
    qos: QoSProfile,
    callback: Option<AnySubscriptionCallback<T, ()>>,
    _phantom: PhantomData<State>,
}

impl<T> ManagedSubscriptionBuilder<T, NoCallback>
where
    T: rclrs::MessageIDL,
{
    pub(crate) fn new<'a>(node: Arc<rclrs::Node>, topic: impl Into<Cow<'a, str>>) -> Self {
        Self {
            node,
            topic: topic.into().into_owned(),
            qos: QoSProfile::topics_default(),
            callback: None,
            _phantom: PhantomData,
        }
    }
}

impl<T, State> ManagedSubscriptionBuilder<T, State>
where
    T: rclrs::MessageIDL,
{
    /// Replace the topic name.
    pub fn topic<'a>(mut self, topic: impl Into<Cow<'a, str>>) -> Self {
        self.topic = topic.into().into_owned();
        self
    }

    /// Replace the QoS profile entirely.
    pub fn qos(mut self, profile: QoSProfile) -> Self {
        self.qos = profile;
        self
    }

    /// Replace topic + QoS from rclrs options.
    pub fn with_options<'a>(mut self, options: SubscriptionOptions<'a>) -> Self {
        self.topic = options.topic.to_string();
        self.qos = options.qos;
        self
    }

    /// Set reliability to Reliable.
    pub fn reliable(mut self) -> Self {
        self.qos = self.qos.reliable();
        self
    }

    /// Set reliability to BestEffort.
    pub fn best_effort(mut self) -> Self {
        self.qos = self.qos.best_effort();
        self
    }

    /// Set durability to TransientLocal.
    pub fn transient_local(mut self) -> Self {
        self.qos = self.qos.transient_local();
        self
    }

    /// Set durability to Volatile.
    pub fn volatile(mut self) -> Self {
        self.qos = self.qos.volatile();
        self
    }

    /// Set history to KeepLast(depth).
    pub fn history_keep_last(mut self, depth: u32) -> Self {
        self.qos = self.qos.keep_last(depth);
        self
    }

    /// Set or clear avoid_ros_namespace_conventions.
    pub fn avoid_ros_namespace_conventions(mut self, avoid: bool) -> Self {
        self.qos.avoid_ros_namespace_conventions = avoid;
        self
    }

    /// Set the subscription callback (erased and owned).
    pub fn callback<Args>(
        self, cb: impl IntoNodeSubscriptionCallback<T, Args>,
    ) -> ManagedSubscriptionBuilder<T, HasCallback> {
        let erased = cb.into_node_subscription_callback();
        ManagedSubscriptionBuilder {
            node: self.node,
            topic: self.topic,
            qos: self.qos,
            callback: Some(erased),
            _phantom: PhantomData,
        }
    }
}

impl<T> ManagedSubscriptionBuilder<T, HasCallback>
where
    T: rclrs::MessageIDL,
{
    /// Create the subscription (ungated by default).
    pub fn create(self) -> Result<ManagedSubscription<T>, RclrsError> {
        let Some(callback) = self.callback else {
            unreachable!("callback must be set in HasCallback state");
        };

        let mut options = SubscriptionOptions::new(&self.topic);
        options.qos = self.qos;

        let adapter = ErasedSubscriptionCallback::new(callback);
        let sub = self.node.create_subscription::<T, _>(options, adapter)?;
        Ok(sub)
    }
}

struct ErasedSubscriptionCallback<T>
where
    T: rclrs::MessageIDL,
{
    callback: AnySubscriptionCallback<T, ()>,
}

impl<T> ErasedSubscriptionCallback<T>
where
    T: rclrs::MessageIDL,
{
    fn new(callback: AnySubscriptionCallback<T, ()>) -> Self {
        Self { callback }
    }
}

impl<T> IntoNodeSubscriptionCallback<T, ()> for ErasedSubscriptionCallback<T>
where
    T: rclrs::MessageIDL,
{
    fn into_node_subscription_callback(self) -> AnySubscriptionCallback<T, ()> {
        self.callback
    }
}