pub struct DataReader<D: Keyed + DeserializeOwned, DA: DeserializerAdapter<D> = CDRDeserializerAdapter<D>> { /* private fields */ }
Expand description
DDS DataReader for with_key topics.
Examples
use serde::{Serialize, Deserialize};
use rustdds::dds::DomainParticipant;
use rustdds::dds::qos::QosPolicyBuilder;
use rustdds::dds::data_types::TopicKind;
use rustdds::dds::traits::Keyed;
use rustdds::with_key::DataReader;
use rustdds::serialization::CDRDeserializerAdapter;
let domain_participant = DomainParticipant::new(0).unwrap();
let qos = QosPolicyBuilder::new().build();
let subscriber = domain_participant.create_subscriber(&qos).unwrap();
#[derive(Serialize, Deserialize)]
struct SomeType { a: i32 }
impl Keyed for SomeType {
type K = i32;
fn key(&self) -> Self::K {
self.a
}
}
// WithKey is important
let topic = domain_participant.create_topic("some_topic".to_string(), "SomeType".to_string(), &qos, TopicKind::WithKey).unwrap();
let data_reader = subscriber.create_datareader::<SomeType, CDRDeserializerAdapter<_>>(&topic, None);
Implementations
sourceimpl<D: 'static, DA> DataReader<D, DA>where
D: DeserializeOwned + Keyed,
<D as Keyed>::K: Key,
DA: DeserializerAdapter<D>,
impl<D: 'static, DA> DataReader<D, DA>where
D: DeserializeOwned + Keyed,
<D as Keyed>::K: Key,
DA: DeserializerAdapter<D>,
sourcepub fn read(
&mut self,
max_samples: usize,
read_condition: ReadCondition
) -> Result<Vec<DataSample<&D>>>
pub fn read(
&mut self,
max_samples: usize,
read_condition: ReadCondition
) -> Result<Vec<DataSample<&D>>>
Reads amount of samples found with max_samples
and read_condition
parameters.
Arguments
max_samples
- Limits maximum amount of samples readread_condition
- Limits results by condition
Examples
use rustdds::dds::data_types::ReadCondition;
let domain_participant = DomainParticipant::new(0).unwrap();
let qos = QosPolicyBuilder::new().build();
let subscriber = domain_participant.create_subscriber(&qos).unwrap();
// WithKey is important
let topic = domain_participant.create_topic("some_topic".to_string(), "SomeType".to_string(), &qos, TopicKind::WithKey).unwrap();
let mut data_reader = subscriber.create_datareader::<SomeType, CDRDeserializerAdapter<_>>(&topic, None).unwrap();
// Wait for data to arrive...
if let Ok(datas) = data_reader.read(10, ReadCondition::not_read()) {
for data in datas.iter() {
// do something
}
}
sourcepub fn take(
&mut self,
max_samples: usize,
read_condition: ReadCondition
) -> Result<Vec<DataSample<D>>>
pub fn take(
&mut self,
max_samples: usize,
read_condition: ReadCondition
) -> Result<Vec<DataSample<D>>>
Takes amount of sample found with max_samples
and read_condition
parameters.
Arguments
max_samples
- Limits maximum amount of samples readread_condition
- Limits results by condition
Examples
use rustdds::dds::data_types::ReadCondition;
let domain_participant = DomainParticipant::new(0).unwrap();
let qos = QosPolicyBuilder::new().build();
let subscriber = domain_participant.create_subscriber(&qos).unwrap();
// WithKey is important
let topic = domain_participant.create_topic("some_topic".to_string(), "SomeType".to_string(), &qos, TopicKind::WithKey).unwrap();
let mut data_reader = subscriber.create_datareader::<SomeType, CDRDeserializerAdapter<_>>(&topic, None).unwrap();
// Wait for data to arrive...
if let Ok(datas) = data_reader.take(10, ReadCondition::not_read()) {
for data in datas.iter() {
// do something
}
}
sourcepub fn read_next_sample(&mut self) -> Result<Option<DataSample<&D>>>
pub fn read_next_sample(&mut self) -> Result<Option<DataSample<&D>>>
Reads next unread sample
Examples
let domain_participant = DomainParticipant::new(0).unwrap();
let qos = QosPolicyBuilder::new().build();
let subscriber = domain_participant.create_subscriber(&qos).unwrap();
// WithKey is important
let topic = domain_participant.create_topic("some_topic".to_string(), "SomeType".to_string(), &qos, TopicKind::WithKey).unwrap();
let mut data_reader = subscriber.create_datareader::<SomeType, CDRDeserializerAdapter<_>>(&topic, None).unwrap();
// Wait for data to arrive...
while let Ok(Some(data)) = data_reader.read_next_sample() {
// do something
}
sourcepub fn take_next_sample(&mut self) -> Result<Option<DataSample<D>>>
pub fn take_next_sample(&mut self) -> Result<Option<DataSample<D>>>
Takes next unread sample
Examples
let domain_participant = DomainParticipant::new(0).unwrap();
let qos = QosPolicyBuilder::new().build();
let subscriber = domain_participant.create_subscriber(&qos).unwrap();
// WithKey is important
let topic = domain_participant.create_topic("some_topic".to_string(), "SomeType".to_string(), &qos, TopicKind::WithKey).unwrap();
let mut data_reader = subscriber.create_datareader::<SomeType, CDRDeserializerAdapter<_>>(&topic, None).unwrap();
// Wait for data to arrive...
while let Ok(Some(data)) = data_reader.take_next_sample() {
// do something
}
sourcepub fn iterator(&mut self) -> Result<impl Iterator<Item = Result<&D, D::K>>>
pub fn iterator(&mut self) -> Result<impl Iterator<Item = Result<&D, D::K>>>
Produces an interator over the currently available NOT_READ samples.
Yields only payload data, not SampleInfo metadata
This is not called iter()
because it takes a mutable reference to self.
Examples
let domain_participant = DomainParticipant::new(0).unwrap();
let qos = QosPolicyBuilder::new().build();
let subscriber = domain_participant.create_subscriber(&qos).unwrap();
// WithKey is important
let topic = domain_participant.create_topic("some_topic".to_string(), "SomeType".to_string(), &qos, TopicKind::WithKey).unwrap();
let mut data_reader = subscriber.create_datareader::<SomeType, CDRDeserializerAdapter<_>>(&topic, None).unwrap();
// Wait for data to arrive...
for data in data_reader.iterator() {
// do something
}
sourcepub fn conditional_iterator(
&mut self,
read_condition: ReadCondition
) -> Result<impl Iterator<Item = Result<&D, D::K>>>
pub fn conditional_iterator(
&mut self,
read_condition: ReadCondition
) -> Result<impl Iterator<Item = Result<&D, D::K>>>
Produces an interator over the samples filtered b ygiven condition. Yields only payload data, not SampleInfo metadata
Examples
use rustdds::dds::data_types::ReadCondition;
let domain_participant = DomainParticipant::new(0).unwrap();
let qos = QosPolicyBuilder::new().build();
let subscriber = domain_participant.create_subscriber(&qos).unwrap();
// WithKey is important
let topic = domain_participant.create_topic("some_topic".to_string(), "SomeType".to_string(), &qos, TopicKind::WithKey).unwrap();
let mut data_reader = subscriber.create_datareader::<SomeType, CDRDeserializerAdapter<_>>(&topic, None).unwrap();
// Wait for data to arrive...
for data in data_reader.conditional_iterator(ReadCondition::any()) {
// do something
}
sourcepub fn into_iterator(&mut self) -> Result<impl Iterator<Item = Result<D, D::K>>>
pub fn into_iterator(&mut self) -> Result<impl Iterator<Item = Result<D, D::K>>>
Produces an interator over the currently available NOT_READ samples.
Yields only payload data, not SampleInfo metadata
Removes samples from DataReader
.
Note! If the iterator is only partially consumed, all the
samples it could have provided are still removed from the Datareader
.
Examples
let domain_participant = DomainParticipant::new(0).unwrap();
let qos = QosPolicyBuilder::new().build();
let subscriber = domain_participant.create_subscriber(&qos).unwrap();
// WithKey is important
let topic = domain_participant.create_topic("some_topic".to_string(), "SomeType".to_string(), &qos, TopicKind::WithKey).unwrap();
let mut data_reader = subscriber.create_datareader::<SomeType, CDRDeserializerAdapter<_>>(&topic, None).unwrap();
// Wait for data to arrive...
for data in data_reader.into_iterator() {
// do something
}
sourcepub fn into_conditional_iterator(
&mut self,
read_condition: ReadCondition
) -> Result<impl Iterator<Item = Result<D, D::K>>>
pub fn into_conditional_iterator(
&mut self,
read_condition: ReadCondition
) -> Result<impl Iterator<Item = Result<D, D::K>>>
Produces an interator over the samples filtered b ygiven condition.
Yields only payload data, not SampleInfo metadata
Note! If the iterator is only partially consumed, all the
samples it could have provided are still removed from the Datareader
.
Examples
use rustdds::dds::data_types::ReadCondition;
let domain_participant = DomainParticipant::new(0).unwrap();
let qos = QosPolicyBuilder::new().build();
let subscriber = domain_participant.create_subscriber(&qos).unwrap();
// WithKey is important
let topic = domain_participant.create_topic("some_topic".to_string(), "SomeType".to_string(), &qos, TopicKind::WithKey).unwrap();
let mut data_reader = subscriber.create_datareader::<SomeType, CDRDeserializerAdapter<_>>(&topic, None).unwrap();
// Wait for data to arrive...
for data in data_reader.into_conditional_iterator(ReadCondition::not_read()) {
// do something
}
sourcepub fn read_instance(
&mut self,
max_samples: usize,
read_condition: ReadCondition,
instance_key: Option<<D as Keyed>::K>,
this_or_next: SelectByKey
) -> Result<Vec<DataSample<&D>>>
pub fn read_instance(
&mut self,
max_samples: usize,
read_condition: ReadCondition,
instance_key: Option<<D as Keyed>::K>,
this_or_next: SelectByKey
) -> Result<Vec<DataSample<&D>>>
Works similarly to read(), but will return only samples from a specific instance. The instance is specified by an optional key. In case the key is not specified, the smallest (in key order) instance is selected. If a key is specified, then the parameter this_or_next specifies whether to access the instance with specified key or the following one, in key order.
This should cover DDS DataReader methods read_instance, read_next_instance, read_next_instance_w_condition.
Examples
use rustdds::dds::data_types::{ReadCondition,SelectByKey};
let domain_participant = DomainParticipant::new(0).unwrap();
let qos = QosPolicyBuilder::new().build();
let subscriber = domain_participant.create_subscriber(&qos).unwrap();
// WithKey is important
let topic = domain_participant.create_topic("some_topic".to_string(), "SomeType".to_string(), &qos, TopicKind::WithKey).unwrap();
let mut data_reader = subscriber.create_datareader::<SomeType, CDRDeserializerAdapter<_>>(&topic, None).unwrap();
// Wait for data to arrive...
if let Ok(datas) = data_reader.read_instance(10, ReadCondition::any(), Some(3), SelectByKey::This) {
for data in datas.iter() {
// do something
}
}
sourcepub fn take_instance(
&mut self,
max_samples: usize,
read_condition: ReadCondition,
instance_key: Option<<D as Keyed>::K>,
this_or_next: SelectByKey
) -> Result<Vec<DataSample<D>>>
pub fn take_instance(
&mut self,
max_samples: usize,
read_condition: ReadCondition,
instance_key: Option<<D as Keyed>::K>,
this_or_next: SelectByKey
) -> Result<Vec<DataSample<D>>>
Similar to read_instance, but will return owned datasamples This should cover DDS DataReader methods take_instance, take_next_instance, take_next_instance_w_condition.
Examples
use rustdds::dds::data_types::{ReadCondition,SelectByKey};
let domain_participant = DomainParticipant::new(0).unwrap();
let qos = QosPolicyBuilder::new().build();
let subscriber = domain_participant.create_subscriber(&qos).unwrap();
// WithKey is important
let topic = domain_participant.create_topic("some_topic".to_string(), "SomeType".to_string(), &qos, TopicKind::WithKey).unwrap();
let mut data_reader = subscriber.create_datareader::<SomeType, CDRDeserializerAdapter<_>>(&topic, None).unwrap();
// Wait for data to arrive...
if let Ok(datas) = data_reader.take_instance(10, ReadCondition::any(), Some(3), SelectByKey::Next) {
for data in datas.iter() {
// do something
}
}
sourcepub fn wait_for_historical_data(&self, _max_wait: Duration) -> bool
pub fn wait_for_historical_data(&self, _max_wait: Duration) -> bool
Return values: true - got all historical data false - timeout before all historical data was received