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

use bit_set::BitSet;
use bit_vec::BitVec;
use log::debug;
use speedy::{Context, Readable, Reader, Writable, Writer};
use std::ops::{Deref, DerefMut};

#[derive(Debug, PartialEq)]
pub struct BitSetRef(BitSet);

impl BitSetRef {
  pub fn new() -> BitSetRef {
    BitSetRef(BitSet::with_capacity(0))
  }

  pub fn into_bit_set(self) -> BitSet {
    self.0
  }
}

impl Deref for BitSetRef {
  type Target = BitSet;

  fn deref(&self) -> &BitSet {
    &self.0
  }
}

impl DerefMut for BitSetRef {
  fn deref_mut(&mut self) -> &mut BitSet {
    &mut self.0
  }
}

impl<'a, C: Context> Readable<'a, C> for BitSetRef {
  #[inline]
  fn read_from<R: Reader<'a, C>>(reader: &mut R) -> Result<Self, C::Error> {
    let number_of_bits = reader.read_u32()?;
    if number_of_bits == 0 {
      return Ok(BitSetRef::new());
    }

    let mut bit_vec = BitVec::with_capacity(number_of_bits as usize);

    for _ in 0..(number_of_bits / 32) + 1 {
      // read value should be directly correct
      let byte = reader.read_u32()?.reverse_bits();
      unsafe {
        let inner = bit_vec.storage_mut();
        inner.push(byte);
      }
    }

    debug!("Full Bitvec: {:x?} :: {:?}", bit_vec, bit_vec);

    Ok(BitSetRef(BitSet::from_bit_vec(bit_vec)))
  }

  #[inline]
  fn minimum_bytes_needed() -> usize {
    4
  }
}

impl<C: Context> Writable<C> for BitSetRef {
  #[inline]
  fn write_to<T: ?Sized + Writer<C>>(&self, writer: &mut T) -> Result<(), C::Error> {
    let number_of_bytes = self.get_ref().iter().count();
    let mut values = Vec::new();

    for &value in self.get_ref().storage() {
      values.push(value);
    }

    writer.write_u32(number_of_bytes as u32)?;

    for val in values.iter_mut() {
      let foo = val.reverse_bits();
      writer.write_u32(foo)?;
    }

    Ok(())
  }
}

#[cfg(test)]
mod tests {
  use super::*;

  serialization_test!( type = BitSetRef,
  {
      bit_set_empty,
      BitSetRef::new(),
      le = [0x00, 0x00, 0x00, 0x00],
      be = [0x00, 0x00, 0x00, 0x00]
  },
  {
      bit_set_non_zero_size,
      (|| {
          let mut set = BitSetRef::new();
          set.insert(0);
          set.insert(42);
          set.insert(7);
          set
      })(),
      le = [0x2B, 0x00, 0x00, 0x00,
            0x00, 0x00, 0x00, 0x81,
            0x00, 0x00, 0x20, 0x00],
      be = [0x00, 0x00, 0x00, 0x2B,
            0x81, 0x00, 0x00, 0x00,
            0x00, 0x20, 0x00, 0x00]
  });
}