phoxal 0.4.0

Phoxal — production-oriented autonomous robot framework (engine, model, typed bus, contracts).
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

use serde::{Deserialize, Serialize, de::DeserializeOwned};
use zenoh::key_expr::OwnedKeyExpr;

use crate::bus::zenoh::{
    TypedPublisher, TypedPublisherBuilder, TypedSchema, TypedSessionExt, TypedSubscriber,
    TypedSubscriberBuilder,
};
use crate::bus::{Bus, Error, Result};

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct Stamped<T> {
    pub timestamp_ns: u64,
    pub data: T,
}

impl<T> Stamped<T> {
    pub fn new(timestamp_ns: u64, data: T) -> Self {
        Self { timestamp_ns, data }
    }
}

pub fn publisher_builder<'a, T>(
    bus: &'a Bus,
    topic: &str,
) -> Result<TypedPublisherBuilder<'a, 'static, T>>
where
    T: Serialize + TypedSchema,
{
    let topic = OwnedKeyExpr::new(bus.topic(topic))
        .map_err(|error| Error::InvalidTopic(error.to_string()))?;
    Ok(bus
        .session()
        .declare_typed_publisher::<T, _>(topic)
        .schema_version(T::SCHEMA_VERSION))
}

pub async fn publisher<T>(bus: &Bus, topic: &str) -> Result<TypedPublisher<'static, T>>
where
    T: Serialize + TypedSchema,
{
    let topic = OwnedKeyExpr::new(bus.topic(topic))
        .map_err(|error| Error::InvalidTopic(error.to_string()))?;
    bus.cloned_session()
        .declare_typed_publisher::<T, _>(topic)
        .schema_version(T::SCHEMA_VERSION)
        .await
        .map_err(|error| Error::InvalidTopic(error.to_string()))
}

pub fn eager_publisher_builder<'a, T>(
    bus: &'a Bus,
    topic: &str,
) -> Result<TypedPublisherBuilder<'a, 'static, T>>
where
    T: Serialize + TypedSchema,
{
    publisher_builder::<T>(bus, topic).map(TypedPublisherBuilder::eager)
}

pub async fn eager_publisher<T>(bus: &Bus, topic: &str) -> Result<TypedPublisher<'static, T>>
where
    T: Serialize + TypedSchema,
{
    let topic = OwnedKeyExpr::new(bus.topic(topic))
        .map_err(|error| Error::InvalidTopic(error.to_string()))?;
    bus.cloned_session()
        .declare_typed_publisher::<T, _>(topic)
        .schema_version(T::SCHEMA_VERSION)
        .eager()
        .await
        .map_err(|error| Error::InvalidTopic(error.to_string()))
}

pub fn subscriber_builder<'a, T>(
    bus: &'a Bus,
    topic: &str,
) -> TypedSubscriberBuilder<'a, 'static, T>
where
    T: DeserializeOwned + TypedSchema,
{
    bus.session()
        .declare_typed_subscriber::<T, _>(bus.topic(topic))
        .schema_version(T::SCHEMA_VERSION)
}

pub async fn subscribe<T>(bus: &Bus, topic: &str) -> Result<TypedSubscriber<T>>
where
    T: DeserializeOwned + TypedSchema,
{
    subscriber_builder::<T>(bus, topic)
        .await
        .map_err(|error| Error::InvalidTopic(error.to_string()))
}