// Because the range removal happens in Drop, if the Splice iterator is leaked,
// the removal will not happen.
let len = self.len();
- let start = *range.start().unwrap_or(&0);
- let end = *range.end().unwrap_or(&len);
+ let start = match range.start() {
+ Included(&n) => n,
+ Excluded(&n) => n + 1,
+ Unbounded => 0,
+ };
+ let end = match range.end() {
+ Included(&n) => n + 1,
+ Excluded(&n) => n,
+ Unbounded => len,
+ };
// Take out two simultaneous borrows. The &mut String won't be accessed
// until iteration is over, in Drop.
///
/// [`splice()`]: struct.String.html#method.splice
/// [`String`]: struct.String.html
+#[derive(Debug)]
#[unstable(feature = "splice", reason = "recently added", issue = "32310")]
pub struct Splice<'a, 'b> {
/// Will be used as &'a mut String in the destructor
}
-/// A splicing iterator for `Vec<T>`. See the [`Vec::splice`](struct.Vec.html#method.splice) method.
+/// A splicing iterator for `Vec`.
+///
+/// This struct is created by the [`splice()`] method on [`Vec`]. See its
+/// documentation for more.
+///
+/// [`splice()`]: struct.Vec.html#method.splice
+/// [`Vec`]: struct.Vec.html
+#[derive(Debug)]
#[unstable(feature = "splice", reason = "recently added", issue = "32310")]
pub struct Splice<'a, I: Iterator + 'a> {
drain: Drain<'a, I::Item>,
unsafe {
if self.drain.tail_len == 0 {
- let vec = &mut *self.drain.vec;
+ let vec = &mut *self.drain.vec.as_mut_ptr();
vec.extend(self.replace_with.by_ref());
return
}
/// Fill that range as much as possible with new elements from the `replace_with` iterator.
/// Return whether we filled the entire range. (`replace_with.next()` didn’t return `None`.)
unsafe fn fill<I: Iterator<Item=T>>(&mut self, replace_with: &mut I) -> bool {
- let vec = &mut *self.vec;
+ let vec = &mut *self.vec.as_mut_ptr();
let range_start = vec.len;
let range_end = self.tail_start;
let range_slice = slice::from_raw_parts_mut(
/// Make room for inserting more elements before the tail.
unsafe fn move_tail(&mut self, extra_capacity: usize) {
- let vec = &mut *self.vec;
+ let vec = &mut *self.vec.as_mut_ptr();
let used_capacity = self.tail_start + self.tail_len;
vec.buf.reserve(used_capacity, extra_capacity);