rustdds 0.1.0

Rust DDS implementation with RTPS
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

//! ROS2 interface using DDS module
//!
//! # Examples
//!
//! ```
//! use rustdds::dds::DomainParticipant;
//! use rustdds::dds::data_types::TopicKind;
//! use rustdds::dds::traits::Entity;
//! use rustdds::ros2::RosContext;
//! use rustdds::ros2::RosParticipant;
//! use rustdds::ros2::NodeOptions;
//! use rustdds::ros2::RosNode;
//! use rustdds::ros2::IRosNodeControl;
//! use rustdds::ros2::RosNodeBuilder;
//! use rustdds::ros2::builtin_datatypes::NodeInfo;
//! use rustdds::dds::qos::QosPolicies;
//! use rustdds::serialization::CDRSerializerAdapter;
//!
//!
//! // DomainParticipant is always needed
//! let domain_participant = DomainParticipant::new(0);
//!
//! // RosContext should be defined for each thread and second parameter set true if RosParticipant
//! // is handled in this thread
//! let ros_context = RosContext::new(domain_participant.clone(), true).unwrap();
//!
//! // RosParticipant is needed for defined RosNodes to be visible in ROS2 network.
//! let mut ros_participant = RosParticipant::new(&ros_context).unwrap();
//!
//! // Node options simply adjust configuration of the node (as in ROS Client library (RCL)).
//! let ros_node_options = NodeOptions::new(domain_participant.domain_id(), false);
//!
//! // Creating some topic for RosNode
//! let some_topic = RosNode::create_ros_topic(
//!     &domain_participant,
//!     "some_topic_name",
//!     "NodeInfo",
//!     QosPolicies::builder().build(),
//!     TopicKind::NoKey)
//!   .unwrap();
//!
//! // Topic has to live longer that node or readers/writers
//! {
//!   // declaring ros node using builder
//!   let mut ros_node = RosNodeBuilder::new()
//!     .name("some_node_name")
//!     .namespace("/some_namespace")
//!     .node_options(ros_node_options)
//!     .ros_context(&ros_context)
//!     .build()
//!     .unwrap();
//!
//!   // declaring some writer that use non keyed types
//!   let some_writer = ros_node
//!     .create_ros_nokey_publisher::<NodeInfo, CDRSerializerAdapter<_>>(
//!       &some_topic, None)
//!     .unwrap();
//!
//!   // RosNode needs to be updated manually about our writers and readers (lifetime magic)
//!   ros_node.add_writer(some_writer.get_guid());
//!
//!   // Readers and RosParticipant implement mio Evented trait and thus function the same way as
//!   // std::sync::mpcs and can be handled the same way for reading the data
//!
//!   // When you add or remove nodes remember to update RosParticipant so others in the ROS2
//!   // network can find your nodes
//!   ros_participant.add_node_info(ros_node.generate_node_info());
//! }
//! ```

/// Some builtin datatypes needed for ROS2 communication
pub mod builtin_datatypes;
/// Some convenience topic infos for ROS2 communication
pub mod builtin_topics;

pub(crate) mod ros_node;

pub use ros_node::*;

pub type RosSubscriber<D, DA> = crate::dds::no_key::datareader::DataReader<D, DA>;

pub type KeyedRosSubscriber<D, DA> = crate::dds::with_key::datareader::DataReader<D, DA>;

pub type RosPublisher<D, SA> = crate::dds::no_key::datawriter::DataWriter<D, SA>;

pub type KeyedRosPublisher<D, SA> = crate::dds::with_key::datawriter::DataWriter<D, SA>;


// Short-hand notation for CDR serialization

pub type RosSubscriber_CDR<D> = 
  crate::dds::no_key::datareader::DataReader<D, crate::serialization::CDRDeserializerAdapter<D>>;

pub type KeyedRosSubscriber_CDR<D> = 
  crate::dds::with_key::datareader::DataReader<D, crate::serialization::CDRDeserializerAdapter<D>>;

pub type RosPublisher_CDR<D> = 
  crate::dds::no_key::datawriter::DataWriter<D, crate::serialization::CDRSerializerAdapter<D>>;

pub type KeyedRosPublisher_CDR<D> = 
  crate::dds::with_key::datawriter::DataWriter<D, crate::serialization::CDRSerializerAdapter<D>>;