rustdds 0.11.8

Native 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
102
103
104
105
106
107
108
109
110

use std::collections::BTreeMap;

use bytes::Bytes;
use speedy::{Context, Readable, Writable, Writer};

use crate::{
  messages::submessages::elements::parameter::Parameter,
  serialization::pl_cdr_adapters::PlCdrSerializeError, structure::parameter_id::ParameterId,
  RepresentationIdentifier,
};

/// ParameterList is used as part of several messages to encapsulate
/// QoS parameters that may affect the interpretation of the message.
/// The encapsulation of the parameters follows a mechanism that allows
/// extensions to the QoS without breaking backwards compatibility.
#[derive(Debug, PartialEq, Eq, Clone, Default)]
pub struct ParameterList {
  pub parameters: Vec<Parameter>,
}

impl ParameterList {
  pub fn new() -> Self {
    Self::default()
  }

  pub fn is_empty(&self) -> bool {
    self.parameters.is_empty()
  }

  pub fn len_serialized(&self) -> usize {
    self
      .parameters
      .iter()
      .map(|p| p.len_serialized())
      .sum::<usize>()
      + SENTINEL.len_serialized()
  }

  pub fn push(&mut self, p: Parameter) {
    self.parameters.push(p);
  }

  #[cfg(feature = "security")]
  pub fn concat(&mut self, other_parameter_list: ParameterList) {
    self.parameters = [self.parameters.clone(), other_parameter_list.parameters].concat();
  }

  pub fn serialize_to_bytes(&self, endianness: speedy::Endianness) -> Result<Bytes, speedy::Error> {
    let b = self.write_to_vec_with_ctx(endianness)?;
    Ok(Bytes::from(b))
  }

  pub fn to_map(&self) -> BTreeMap<ParameterId, Vec<&Parameter>> {
    self.parameters.iter().fold(BTreeMap::new(), |mut m, p| {
      m.entry(p.parameter_id).or_default().push(p);
      m
    })
  }
}

const SENTINEL: Parameter = Parameter {
  parameter_id: ParameterId::PID_SENTINEL,
  value: vec![],
};

impl<C: Context> Writable<C> for ParameterList {
  #[inline]
  fn write_to<T: ?Sized + Writer<C>>(&self, writer: &mut T) -> Result<(), C::Error> {
    for param in &self.parameters {
      writer.write_value(param)?;
    }
    // finally, write end marker.
    writer.write_value(&SENTINEL)?;

    Ok(())
  }
}

impl<'a, C: Context> Readable<'a, C> for ParameterList {
  #[inline]
  fn read_from<R: speedy::Reader<'a, C>>(reader: &mut R) -> Result<Self, C::Error> {
    let mut parameters = Self::default();

    // loop ends in failure to read something or catching sentinel
    loop {
      let parameter_id = ParameterId::read_from(reader)?;
      let length = u16::read_from(reader)?;

      if parameter_id == ParameterId::PID_SENTINEL {
        // This is parameter list end marker.
        // We do not read its Parameter contents ("value"),
        // because it is of size zero by definition.
        return Ok(parameters);
      }

      parameters.parameters.push(Parameter {
        parameter_id,
        value: reader.read_vec(length as usize)?,
      });
    }
  }
}

// Trait for structs which can be converted to a ParameterList
pub trait ParameterListable {
  fn to_parameter_list(
    &self,
    encoding: RepresentationIdentifier,
  ) -> Result<ParameterList, PlCdrSerializeError>;
}