Struct rustdds::dds::With_Key_DataWriter

pub struct With_Key_DataWriter<D: Keyed + Serialize, SA: SerializerAdapter<D> = CDRSerializerAdapter<D>> { /* fields omitted */ }

DDS DataWriter for keyed topics

Examples

use serde::{Serialize, Deserialize};
use rustdds::dds::DomainParticipant;
use rustdds::dds::qos::QosPolicyBuilder;
use rustdds::dds::data_types::TopicKind;
use rustdds::dds::With_Key_DataWriter as DataWriter;
use rustdds::dds::traits::Keyed;
use rustdds::serialization::CDRSerializerAdapter;

let domain_participant = DomainParticipant::new(0);
let qos = QosPolicyBuilder::new().build();
let publisher = domain_participant.create_publisher(&qos).unwrap();

#[derive(Serialize, Deserialize)]
struct SomeType { a: i32 }
impl Keyed for SomeType {
  type K = i32;

  fn get_key(&self) -> Self::K {
    self.a
  }
}

// WithKey is important
let topic = domain_participant.create_topic("some_topic", "SomeType", &qos, TopicKind::WithKey).unwrap();
let data_writer = publisher.create_datawriter::<SomeType, CDRSerializerAdapter<_>>(None, topic, None);

Implementations

impl<D, SA> DataWriter<D, SA> where
    D: Keyed + Serialize,
    <D as Keyed>::K: Key,
    SA: SerializerAdapter<D>, 

pub fn refresh_manual_liveliness(&self)

Manually refreshes liveliness if QoS allows it

Examples

let domain_participant = DomainParticipant::new(0);
let qos = QosPolicyBuilder::new().build();
let publisher = domain_participant.create_publisher(&qos).unwrap();

#[derive(Serialize, Deserialize)]
struct SomeType { a: i32 }
impl Keyed for SomeType {
  type K = i32;

  fn get_key(&self) -> Self::K {
    self.a
  }
}

// WithKey is important
let topic = domain_participant.create_topic("some_topic", "SomeType", &qos, TopicKind::WithKey).unwrap();
let data_writer = publisher.create_datawriter::<SomeType, CDRSerializerAdapter<_>>(None, topic, None).unwrap();

data_writer.refresh_manual_liveliness();

pub fn write(&self, data: D, source_timestamp: Option<Timestamp>) -> Result<()>

Writes single data instance to a topic.

Examples

let domain_participant = DomainParticipant::new(0);
let qos = QosPolicyBuilder::new().build();
let publisher = domain_participant.create_publisher(&qos).unwrap();

#[derive(Serialize, Deserialize)]
struct SomeType { a: i32 }
impl Keyed for SomeType {
  type K = i32;

  fn get_key(&self) -> Self::K {
    self.a
  }
}

// WithKey is important
let topic = domain_participant.create_topic("some_topic", "SomeType", &qos, TopicKind::WithKey).unwrap();
let data_writer = publisher.create_datawriter::<SomeType, CDRSerializerAdapter<_>>(None, topic, None).unwrap();

let some_data = SomeType { a: 1 };
data_writer.write(some_data, None).unwrap();

pub fn wait_for_acknowledgments(&self, _max_wait: Duration) -> Result<()>

Waits for all acknowledgements to finish

Examples

let domain_participant = DomainParticipant::new(0);
let qos = QosPolicyBuilder::new().build();
let publisher = domain_participant.create_publisher(&qos).unwrap();

#[derive(Serialize, Deserialize)]
struct SomeType { a: i32 }
impl Keyed for SomeType {
  type K = i32;

  fn get_key(&self) -> Self::K {
    self.a
  }
}

// WithKey is important
let topic = domain_participant.create_topic("some_topic", "SomeType", &qos, TopicKind::WithKey).unwrap();
let data_writer = publisher.create_datawriter::<SomeType, CDRSerializerAdapter<_>>(None, topic, None).unwrap();

let some_data = SomeType { a: 1 };
data_writer.write(some_data, None).unwrap();
data_writer.wait_for_acknowledgments(std::time::Duration::from_millis(100));

pub fn get_topic(&self) -> &Topic

Topic assigned to this DataWriter

Examples

let domain_participant = DomainParticipant::new(0);
let qos = QosPolicyBuilder::new().build();
let publisher = domain_participant.create_publisher(&qos).unwrap();

#[derive(Serialize, Deserialize)]
struct SomeType { a: i32 }
impl Keyed for SomeType {
  type K = i32;

  fn get_key(&self) -> Self::K {
    self.a
  }
}

// WithKey is important
let topic = domain_participant.create_topic("some_topic", "SomeType", &qos, TopicKind::WithKey).unwrap();
let data_writer = publisher.create_datawriter::<SomeType, CDRSerializerAdapter<_>>(None, topic.clone(), None).unwrap();

assert_eq!(data_writer.get_topic(), &topic);

pub fn get_publisher(&self) -> &Publisher

Publisher assigned to this DataWriter

Examples

let domain_participant = DomainParticipant::new(0);
let qos = QosPolicyBuilder::new().build();
let publisher = domain_participant.create_publisher(&qos).unwrap();

#[derive(Serialize, Deserialize)]
struct SomeType { a: i32 }
impl Keyed for SomeType {
  type K = i32;

  fn get_key(&self) -> Self::K {
    self.a
  }
}

// WithKey is important
let topic = domain_participant.create_topic("some_topic", "SomeType", &qos, TopicKind::WithKey).unwrap();
let data_writer = publisher.create_datawriter::<SomeType, CDRSerializerAdapter<_>>(None, topic, None).unwrap();

assert_eq!(data_writer.get_publisher(), &publisher);

pub fn assert_liveliness(&self) -> Result<()>

Manually asserts liveliness (use this instead of refresh) according to QoS

Examples

let domain_participant = DomainParticipant::new(0);
let qos = QosPolicyBuilder::new().build();
let publisher = domain_participant.create_publisher(&qos).unwrap();

#[derive(Serialize, Deserialize)]
struct SomeType { a: i32 }
impl Keyed for SomeType {
  type K = i32;

  fn get_key(&self) -> Self::K {
    self.a
  }
}

// WithKey is important
let topic = domain_participant.create_topic("some_topic", "SomeType", &qos, TopicKind::WithKey).unwrap();
let data_writer = publisher.create_datawriter::<SomeType, CDRSerializerAdapter<_>>(None, topic, None).unwrap();

data_writer.assert_liveliness().unwrap();

pub fn get_matched_subscriptions(&self) -> Vec<SubscriptionBuiltinTopicData>

Unimplemented. Do not use.

Examples

let domain_participant = DomainParticipant::new(0);
let qos = QosPolicyBuilder::new().build();
let publisher = domain_participant.create_publisher(&qos).unwrap();

#[derive(Serialize, Deserialize)]
struct SomeType { a: i32 }
impl Keyed for SomeType {
  type K = i32;

  fn get_key(&self) -> Self::K {
    self.a
  }
}

// WithKey is important
let topic = domain_participant.create_topic("some_topic", "SomeType", &qos, TopicKind::WithKey).unwrap();
let data_writer = publisher.create_datawriter::<SomeType, CDRSerializerAdapter<_>>(None, topic, None).unwrap();

for sub in data_writer.get_matched_subscriptions().iter() {
  // do something
}

pub fn dispose(
    &self,
    key: <D as Keyed>::K,
    source_timestamp: Option<Timestamp>
) -> Result<()>

Disposes data instance with specified key

Arguments

• key - Key of the instance
• source_timestamp - DDS source timestamp (None uses now as time as specified in DDS spec)

Examples

let domain_participant = DomainParticipant::new(0);
let qos = QosPolicyBuilder::new().build();
let publisher = domain_participant.create_publisher(&qos).unwrap();

#[derive(Serialize, Deserialize)]
struct SomeType { a: i32, val: usize }
impl Keyed for SomeType {
  type K = i32;

  fn get_key(&self) -> Self::K {
    self.a
  }
}

// WithKey is important
let topic = domain_participant.create_topic("some_topic", "SomeType", &qos, TopicKind::WithKey).unwrap();
let data_writer = publisher.create_datawriter::<SomeType, CDRSerializerAdapter<_>>(None, topic, None).unwrap();

let some_data_1_1 = SomeType { a: 1, val: 3};
let some_data_1_2 = SomeType { a: 1, val: 4};
// different key
let some_data_2_1 = SomeType { a: 2, val: 5};
let some_data_2_2 = SomeType { a: 2, val: 6};

data_writer.write(some_data_1_1, None).unwrap();
data_writer.write(some_data_1_2, None).unwrap();
data_writer.write(some_data_2_1, None).unwrap();
data_writer.write(some_data_2_2, None).unwrap();

// disposes both some_data_1_1 and some_data_1_2. They are no longer offered by this writer to this topic.
data_writer.dispose(1, None).unwrap();

Trait Implementations

impl<D, SA> DDSEntity for DataWriter<D, SA> where
    D: Keyed + Serialize,
    SA: SerializerAdapter<D>, 

impl<D, SA> Drop for DataWriter<D, SA> where
    D: Keyed + Serialize,
    SA: SerializerAdapter<D>, 

fn drop(&mut self)

Executes the destructor for this type.

impl<D, SA> HasQoSPolicy for DataWriter<D, SA> where
    D: Keyed + Serialize,
    SA: SerializerAdapter<D>, 

fn get_qos(&self) -> QosPolicies

impl<D, SA> RTPSEntity for DataWriter<D, SA> where
    D: Keyed + Serialize,
    SA: SerializerAdapter<D>, 

fn get_guid(&self) -> GUID

fn get_entity_id(&self) -> EntityId

fn get_guid_prefix(&self) -> GuidPrefix

impl<D, SA> StatusEvented<DataWriterStatus> for DataWriter<D, SA> where
    D: Keyed + Serialize,
    SA: SerializerAdapter<D>, 

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

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