Struct rustdds::dds::with_key::DataReader

pub struct DataReader<D: Keyed + DeserializeOwned, DA: DeserializerAdapter<D> = CDRDeserializerAdapter<D>> { /* private fields */ }

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

impl<D: 'static, DA> DataReader<D, DA> where
    D: DeserializeOwned + Keyed,
    <D as Keyed>::K: Key,
    DA: DeserializerAdapter<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 read
• read_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
  }
}

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 read
• read_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
  }
}

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
}

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
}

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
}

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
}

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
}

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
}

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
  }
}

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
  }
}

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

pub fn get_matched_publications(
    &self
) -> impl Iterator<Item = PublicationBuiltinTopicData>

Trait Implementations

impl<D, DA> Drop for DataReader<D, DA> where
    D: Keyed + DeserializeOwned,
    DA: DeserializerAdapter<D>, 

fn drop(&mut self)

Executes the destructor for this type.

impl<D, DA> Evented for DataReader<D, DA> where
    D: Keyed + DeserializeOwned,
    DA: DeserializerAdapter<D>, 

fn register(
    &self,
    poll: &Poll,
    token: Token,
    interest: Ready,
    opts: PollOpt
) -> Result<()>

Register self with the given Poll instance.

fn reregister(
    &self,
    poll: &Poll,
    token: Token,
    interest: Ready,
    opts: PollOpt
) -> Result<()>

Re-register self with the given Poll instance.

fn deregister(&self, poll: &Poll) -> Result<()>

Deregister self from the given Poll instance

impl<D, DA> HasQoSPolicy for DataReader<D, DA> where
    D: Keyed + DeserializeOwned,
    DA: DeserializerAdapter<D>, 

fn qos(&self) -> QosPolicies

impl<D, DA> RTPSEntity for DataReader<D, DA> where
    D: Keyed + DeserializeOwned,
    DA: DeserializerAdapter<D>, 

fn guid(&self) -> GUID

fn entity_id(&self) -> EntityId

fn guid_prefix(&self) -> GuidPrefix

impl<D, DA> StatusEvented<DataReaderStatus> for DataReader<D, DA> where
    D: Keyed + DeserializeOwned,
    DA: DeserializerAdapter<D>, 

fn as_status_evented(&mut self) -> &dyn Evented

fn try_recv_status(&self) -> Option<DataReaderStatus>