wtx 0.43.0

A collection of different transport implementations and related tools focused primarily on web technologies.
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

use core::{ops::Range, ptr};

/// Transfers sequential `iter` chunks delimited by indices to a region starting at `begin`.
///
/// ### Three delimited chunks shifted to the left
///
/// ```ignore
/// |00|01|02|03|04|05|06|07|08|09|10|11|
///        << <<
///
/// |02|03|02|03|04|05|06|07|08|09|10|11|
///  ^^ ^^             << <<
///
/// |02|03|06|07|04|05|06|07|08|09|10|11|
///  ^^ ^^ ^^ ^^                   << <<
///
/// |02|03|06|07|10|11|06|07|08|09|10|11|
///  ^^ ^^ ^^ ^^ ^^ ^^
///
/// |02|03|06|07|10|11|
/// ```
pub(crate) fn shift_copyable_chunks<T>(
  begin: usize,
  slice: &mut [T],
  iter: impl IntoIterator<Item = Range<usize>>,
) -> &mut [T]
where
  T: Copy,
{
  let mut new_len = begin;
  if new_len > slice.len() {
    return &mut [];
  }
  for Range { start, end } in iter {
    let Some((diff @ 1..=usize::MAX, local_new_len)) = end.checked_sub(start).and_then(|diff| {
      let local_new_len = new_len.checked_add(diff)?;
      if local_new_len > slice.len() {
        return None;
      }
      Some((diff, local_new_len))
    }) else {
      // SAFETY: top-level and loop-level checks enforce bounds
      return unsafe { slice.get_unchecked_mut(..new_len) };
    };
    let ptr = slice.as_mut_ptr();
    // SAFETY: loop-level check enforces bounds
    let src = unsafe { ptr.add(start) };
    // SAFETY: top-level check enforces bounds
    let dst = unsafe { ptr.add(new_len) };
    // SAFETY: loop-level check enforces a valid `diff`
    unsafe {
      ptr::copy(src, dst, diff);
    }
    new_len = local_new_len;
  }
  // SAFETY: top-level check enforces bounds
  unsafe { slice.get_unchecked_mut(..new_len) }
}

#[cfg(kani)]
mod kani {
  use crate::misc::bytes_transfer::shift_copyable_chunks;
  use alloc::vec::Vec;

  #[kani::proof]
  fn shift_bytes() {
    let begin = kani::any();
    let tuples = kani::vec::any_vec::<(usize, usize), 128>();
    let ranges: Vec<_> = tuples.into_iter().map(|el| el.0..el.1).collect();
    let mut slice = kani::vec::any_vec::<u8, 128>();
    let _ = shift_copyable_chunks(begin, &mut slice, ranges.into_iter());
  }
}

#[cfg(test)]
mod test {
  use crate::misc::bytes_transfer::shift_copyable_chunks;

  #[test]
  fn shift_bytes_has_correct_outputs() {
    let bytes = &mut [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15];
    assert_eq!(shift_copyable_chunks(2, bytes, [4..6, 8..10]), &mut [0, 1, 4, 5, 8, 9]);
    assert_eq!(bytes, &mut [0, 1, 4, 5, 8, 9, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]);
  }
}