slimvec 0.4.9

Dynamic array with a smaller inline-size
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
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

// Copyright © ickk, 2026

use {
  crate::{Drain, SlimVec},
  ::core::{mem, mem::ManuallyDrop, ops::RangeBounds},
};

/// An iterator that moves out of a [`SlimVec`], replacing the removed elements
/// with another iterator
///
/// This may be created using [`SlimVec::splice`].
#[derive(Debug)]
pub struct Splice<'v, I>
where
  I: Iterator + 'v,
{
  // All the splicing magic happens in Drop, overriding Drain's Drop.
  drain: ManuallyDrop<Drain<'v, I::Item>>,
  replacements: I,
}

impl<I> Iterator for Splice<'_, I>
where
  I: Iterator,
{
  type Item = I::Item;

  #[inline]
  fn next(&mut self) -> Option<Self::Item> {
    self.drain.next()
  }

  #[inline]
  fn size_hint(&self) -> (usize, Option<usize>) {
    self.drain.size_hint()
  }
}

impl<I> DoubleEndedIterator for Splice<'_, I>
where
  I: Iterator,
{
  #[inline]
  fn next_back(&mut self) -> Option<Self::Item> {
    self.drain.next_back()
  }
}

impl<I> ExactSizeIterator for Splice<'_, I> where I: Iterator {}

/// Internal methods
impl<I, T> Splice<'_, I>
where
  I: Iterator<Item = T>,
{
  #[inline]
  pub(crate) fn new(
    slimvec: &mut SlimVec<T>,
    range: impl RangeBounds<usize>,
    replace_with: impl IntoIterator<IntoIter = I>,
  ) -> Splice<'_, I> {
    Splice {
      drain: ManuallyDrop::new(Drain::new(slimvec, range)),
      replacements: replace_with.into_iter(),
    }
  }
}

impl<I> Drop for Splice<'_, I>
where
  I: Iterator,
{
  fn drop(&mut self) {
    // Take the `yield_range`, for the sake of unwind-safety; prevent running
    // destructors twice if a destructor panics.
    let yield_range = mem::take(&mut self.drain.yield_range);
    unsafe { self.drain.slimvec.raw.drop_in_place(yield_range) };

    // If there is no tail, this reduces to `extend`.
    if self.drain.tail.is_empty() {
      self.drain.slimvec.extend(&mut self.replacements);
      return;
    }
    // At this point it is known that `capacity >= tail.len > 0`.

    // If the size-hint appears to be exact, then use the size-hint to resize
    // the void.
    if let (size_hint, Some(upper)) = self.replacements.size_hint()
      && size_hint == upper
      && size_hint != self.drain.void().len()
    {
      let len = self.drain.slimvec.len();
      let tail_len = self.drain.tail.len();
      // After this reserve, `capacity >= (len + tail_len + size_hint)`.
      self.drain.slimvec.reserve(size_hint + tail_len);
      // safety: `capacity > 0`.
      unsafe { self.drain.shift_tail(len + size_hint) }
    }

    // Fill the void. If there were too few replacements to fill the void
    // completely, then shift the tail back & return.
    self.drain.fill_void(&mut self.replacements);
    if !self.drain.void().is_empty() {
      let len = self.drain.slimvec.len();
      let tail_len = self.drain.tail.len();
      // safety: `capacity > 0`.
      unsafe { self.drain.shift_tail(len) };
      // safety: `capacity > 0`.
      unsafe { self.drain.slimvec.raw.set_length(len + tail_len) };
      return;
    }

    // Fallback; collect all remaining replacements into a temporary buffer,
    // reserve capacity, move the tail, and fill the void.
    // Does nothing if there are no more replacements.
    let mut replacements = self.replacements.by_ref().collect::<SlimVec<_>>();
    let len = self.drain.slimvec.len();
    let tail_len = self.drain.tail.len();
    let rep_len = replacements.len();
    if !replacements.is_empty() {
      self.drain.slimvec.reserve(rep_len + tail_len);
      // safety: `capacity > 0`.
      unsafe { self.drain.shift_tail(len + rep_len) };
      self.drain.slimvec.append(&mut replacements);
    }

    // safety: `capacity > 0`.
    unsafe { self.drain.slimvec.raw.set_length(len + rep_len + tail_len) };
  }
}