/rust/registry/src/index.crates.io-1949cf8c6b5b557f/range-collections-0.4.6/src/merge_state.rs

Source
#![allow(clippy::needless_lifetimes)]
use crate::iterators::SliceIterator;
use binary_merge::{MergeOperation, MergeState};
use core::fmt::Debug;
use inplace_vec_builder::InPlaceSmallVecBuilder;
use smallvec::{Array, SmallVec};

/// A typical write part for the merge state
pub(crate) trait MergeStateMut: MergeState {
    // Consume 1 elements from a and b, will copy from a
    fn advance_both(&mut self, copy: bool) -> bool {
        self.advance_a(1, copy) && self.advance_b(1, false)
    }
    /// Consume n elements of a, and update ac
    fn advance_a(&mut self, n: usize, take: bool) -> bool;
    /// Consume n elements of b, and update bc
    fn advance_b(&mut self, n: usize, take: bool) -> bool;

    fn ac(&self) -> bool;

    fn bc(&self) -> bool;
}

/// An in place merge state where the rhs is an owned smallvec
pub(crate) struct InPlaceMergeState<'a, A: Array, B: Array> {
    a: InPlaceSmallVecBuilder<'a, A>,
    b: smallvec::IntoIter<B>,
    ac: bool,
    bc: bool,
}

impl<'a, A: Array, B: Array> InPlaceMergeState<'a, A, B> {
    pub fn new(a: &'a mut SmallVec<A>, b: SmallVec<B>) -> Self {
        Self {
            a: a.into(),
            b: b.into_iter(),
            ac: false,
            bc: false,
        }
    }
}

impl<'a, A: Array, B: Array> MergeState for InPlaceMergeState<'a, A, B> {
    type A = A::Item;
    type B = B::Item;
    fn a_slice(&self) -> &[A::Item] {
        self.a.source_slice()
    }
    fn b_slice(&self) -> &[B::Item] {
        self.b.as_slice()
    }
}

impl<'a, A: Array> MergeStateMut for InPlaceMergeState<'a, A, A> {
    #[inline]
    fn advance_a(&mut self, n: usize, take: bool) -> bool {
        self.ac ^= is_odd(n);
        self.a.consume(n, take);
        true
    }
    #[inline]
    fn advance_b(&mut self, n: usize, take: bool) -> bool {
        self.bc ^= is_odd(n);
        if take {
            self.a.extend_from_iter(&mut self.b, n);
        } else {
            for _ in 0..n {
                let _ = self.b.next();
            }
        }
        true
    }
    fn ac(&self) -> bool {
        self.ac
    }
    fn bc(&self) -> bool {
        self.bc
    }
}

impl<'a, A: Array, B: Array> InPlaceMergeState<'a, A, B> {
    pub fn merge<O: MergeOperation<Self>>(a: &'a mut SmallVec<A>, b: SmallVec<B>, o: O) {
        let mut state = Self::new(a, b);
        o.merge(&mut state);
    }
}

/// An in place merge state where the rhs is a reference
pub(crate) struct InPlaceMergeStateRef<'a, A: Array, B> {
    a: InPlaceSmallVecBuilder<'a, A>,
    b: SliceIterator<'a, B>,
    ac: bool,
    bc: bool,
}

impl<'a, A: Array, B> InPlaceMergeStateRef<'a, A, B> {
    pub fn new(a: &'a mut SmallVec<A>, b: &'a impl AsRef<[B]>) -> Self {
        Self {
            a: a.into(),
            b: SliceIterator(b.as_ref()),
            ac: false,
            bc: false,
        }
    }
}

impl<'a, A: Array, B> MergeState for InPlaceMergeStateRef<'a, A, B> {
    type A = A::Item;
    type B = B;
    fn a_slice(&self) -> &[A::Item] {
        self.a.source_slice()
    }
    fn b_slice(&self) -> &[B] {
        self.b.as_slice()
    }
}

impl<'a, A: Array> MergeStateMut for InPlaceMergeStateRef<'a, A, A::Item>
where
    A::Item: Clone,
{
    #[inline]
    fn advance_a(&mut self, n: usize, take: bool) -> bool {
        self.ac ^= is_odd(n);
        self.a.consume(n, take);
        true
    }
    #[inline]
    fn advance_b(&mut self, n: usize, take: bool) -> bool {
        self.bc ^= is_odd(n);
        if take {
            self.a.extend_from_iter((&mut self.b).cloned(), n);
        } else {
            for _ in 0..n {
                let _ = self.b.next();
            }
        }
        true
    }
    fn ac(&self) -> bool {
        self.ac
    }
    fn bc(&self) -> bool {
        self.bc
    }
}

impl<'a, A: Array, B: 'a> InPlaceMergeStateRef<'a, A, B> {
    pub fn merge<O: MergeOperation<Self>>(a: &'a mut SmallVec<A>, b: &'a impl AsRef<[B]>, o: O) {
        let mut state = Self::new(a, b);
        o.merge(&mut state);
    }
}

/// A merge state where we only track if elements have been produced, and abort as soon as the first element is produced
pub(crate) struct BoolOpMergeState<'a, A, B> {
    a: SliceIterator<'a, A>,
    b: SliceIterator<'a, B>,
    ac: bool,
    bc: bool,
    r: bool,
}

impl<'a, A: Debug, B: Debug> Debug for BoolOpMergeState<'a, A, B> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(
            f,
            "a: {:?}, b: {:?} r: {}",
            self.a_slice(),
            self.b_slice(),
            self.r
        )
    }
}

impl<'a, A, B> BoolOpMergeState<'a, A, B> {
    pub fn new(a: &'a [A], b: &'a [B]) -> Self {
        Self {
            a: SliceIterator(a),
            b: SliceIterator(b),
            ac: false,
            bc: false,
            r: false,
        }
    }

    pub fn result(self) -> bool {
        self.r
    }
}

impl<'a, A, B> BoolOpMergeState<'a, A, B> {
    pub fn merge<O: MergeOperation<Self>>(a: &'a [A], b: &'a [B], o: O) -> bool {
        let mut state = Self::new(a, b);
        o.merge(&mut state);
        state.r
    }
}

impl<'a, A, B> MergeState for BoolOpMergeState<'a, A, B> {
    type A = A;
    type B = B;
    fn a_slice(&self) -> &[A] {
        self.a.as_slice()
    }
    fn b_slice(&self) -> &[B] {
        self.b.as_slice()
    }
}

impl<'a, A, B> MergeStateMut for BoolOpMergeState<'a, A, B> {
    fn advance_a(&mut self, n: usize, take: bool) -> bool {
        self.ac ^= is_odd(n);
        if take {
            self.r = true;
            false
        } else {
            self.a.drop_front(n);
            true
        }
    }

    fn advance_b(&mut self, n: usize, take: bool) -> bool {
        self.bc ^= is_odd(n);
        if take {
            self.r = true;
            false
        } else {
            self.b.drop_front(n);
            true
        }
    }
    fn ac(&self) -> bool {
        self.ac
    }
    fn bc(&self) -> bool {
        self.bc
    }
}

/// A merge state where we build into a new vector
pub(crate) struct SmallVecMergeState<'a, A, B, Arr: Array> {
    a: SliceIterator<'a, A>,
    b: SliceIterator<'a, B>,
    ac: bool,
    bc: bool,
    r: SmallVec<Arr>,
}

impl<'a, A: Debug, B: Debug, Arr: Array> Debug for SmallVecMergeState<'a, A, B, Arr> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "a: {:?}, b: {:?}", self.a_slice(), self.b_slice(),)
    }
}

impl<'a, A, B, Arr: Array> SmallVecMergeState<'a, A, B, Arr> {
    pub fn new(a: &'a [A], b: &'a [B], r: SmallVec<Arr>) -> Self {
        Self {
            a: SliceIterator(a),
            b: SliceIterator(b),
            ac: false,
            bc: false,
            r,
        }
    }

    pub fn result(self) -> SmallVec<Arr> {
        self.r
    }

    pub fn merge<O: MergeOperation<Self>>(a: &'a [A], b: &'a [B], o: O) -> SmallVec<Arr> {
        let t: SmallVec<Arr> = SmallVec::new();
        let mut state = Self::new(a, b, t);
        o.merge(&mut state);
        state.result()
    }
}

impl<'a, A, B, Arr: Array> MergeState for SmallVecMergeState<'a, A, B, Arr> {
    type A = A;
    type B = B;
    fn a_slice(&self) -> &[A] {
        self.a.as_slice()
    }
    fn b_slice(&self) -> &[B] {
        self.b.as_slice()
    }
}

impl<'a, T: Clone, Arr: Array<Item = T>> MergeStateMut for SmallVecMergeState<'a, T, T, Arr> {
    fn advance_a(&mut self, n: usize, take: bool) -> bool {
        self.ac ^= is_odd(n);
        if take {
            self.r.reserve(n);
            for e in self.a.take_front(n).iter() {
                self.r.push(e.clone())
            }
        } else {
            self.a.drop_front(n);
        }
        true
    }

    fn advance_b(&mut self, n: usize, take: bool) -> bool {
        self.bc ^= is_odd(n);
        if take {
            self.r.reserve(n);
            for e in self.b.take_front(n).iter() {
                self.r.push(e.clone())
            }
        } else {
            self.b.drop_front(n);
        }
        true
    }
    fn ac(&self) -> bool {
        self.ac
    }
    fn bc(&self) -> bool {
        self.bc
    }
}

#[inline]
fn is_odd(x: usize) -> bool {
    (x & 1) != 0
}

Coverage Report

Created: 2026-11-11 06:34

Line	Count	Source
1		#![allow(clippy::needless_lifetimes)]
2		use crate::iterators::SliceIterator;
3		use binary_merge::{MergeOperation, MergeState};
4		use core::fmt::Debug;
5		use inplace_vec_builder::InPlaceSmallVecBuilder;
6		use smallvec::{Array, SmallVec};
7
8		/// A typical write part for the merge state
9		pub(crate) trait MergeStateMut: MergeState {
10		// Consume 1 elements from a and b, will copy from a
11	0	fn advance_both(&mut self, copy: bool) -> bool {
12	0	self.advance_a(1, copy) && self.advance_b(1, false)
13	0	} Unexecuted instantiation: <range_collections::merge_state::InPlaceMergeState<[u32; 2], [u32; 2]> as range_collections::merge_state::MergeStateMut>::advance_both Unexecuted instantiation: <range_collections::range_set::VecMergeState<u32, [u32; 2]> as range_collections::merge_state::MergeStateMut>::advance_both Unexecuted instantiation: <range_collections::range_set::RangeSetBoolOpMergeState<u32> as range_collections::merge_state::MergeStateMut>::advance_both Unexecuted instantiation: <_ as range_collections::merge_state::MergeStateMut>::advance_both
14		/// Consume n elements of a, and update ac
15		fn advance_a(&mut self, n: usize, take: bool) -> bool;
16		/// Consume n elements of b, and update bc
17		fn advance_b(&mut self, n: usize, take: bool) -> bool;
18
19		fn ac(&self) -> bool;
20
21		fn bc(&self) -> bool;
22		}
23
24		/// An in place merge state where the rhs is an owned smallvec
25		pub(crate) struct InPlaceMergeState<'a, A: Array, B: Array> {
26		a: InPlaceSmallVecBuilder<'a, A>,
27		b: smallvec::IntoIter<B>,
28		ac: bool,
29		bc: bool,
30		}
31
32		impl<'a, A: Array, B: Array> InPlaceMergeState<'a, A, B> {
33	0	pub fn new(a: &'a mut SmallVec<A>, b: SmallVec<B>) -> Self {
34	0	Self {
35	0	a: a.into(),
36	0	b: b.into_iter(),
37	0	ac: false,
38	0	bc: false,
39	0	}
40	0	} Unexecuted instantiation: <range_collections::merge_state::InPlaceMergeState<[u32; 2], [u32; 2]>>::new Unexecuted instantiation: <range_collections::merge_state::InPlaceMergeState<_, _>>::new
41		}
42
43		impl<'a, A: Array, B: Array> MergeState for InPlaceMergeState<'a, A, B> {
44		type A = A::Item;
45		type B = B::Item;
46	0	fn a_slice(&self) -> &[A::Item] {
47	0	self.a.source_slice()
48	0	} Unexecuted instantiation: <range_collections::merge_state::InPlaceMergeState<[u32; 2], [u32; 2]> as binary_merge::MergeState>::a_slice Unexecuted instantiation: <range_collections::merge_state::InPlaceMergeState<_, _> as binary_merge::MergeState>::a_slice
49	0	fn b_slice(&self) -> &[B::Item] {
50	0	self.b.as_slice()
51	0	} Unexecuted instantiation: <range_collections::merge_state::InPlaceMergeState<[u32; 2], [u32; 2]> as binary_merge::MergeState>::b_slice Unexecuted instantiation: <range_collections::merge_state::InPlaceMergeState<_, _> as binary_merge::MergeState>::b_slice
52		}
53
54		impl<'a, A: Array> MergeStateMut for InPlaceMergeState<'a, A, A> {
55		#[inline]
56	0	fn advance_a(&mut self, n: usize, take: bool) -> bool {
57	0	self.ac ^= is_odd(n);
58	0	self.a.consume(n, take);
59	0	true
60	0	} Unexecuted instantiation: <range_collections::merge_state::InPlaceMergeState<[u32; 2], [u32; 2]> as range_collections::merge_state::MergeStateMut>::advance_a Unexecuted instantiation: <range_collections::merge_state::InPlaceMergeState<_, _> as range_collections::merge_state::MergeStateMut>::advance_a
61		#[inline]
62	0	fn advance_b(&mut self, n: usize, take: bool) -> bool {
63	0	self.bc ^= is_odd(n);
64	0	if take {
65	0	self.a.extend_from_iter(&mut self.b, n);
66	0	} else {
67	0	for _ in 0..n {
68	0	let _ = self.b.next();
69	0	}
70		}
71	0	true
72	0	} Unexecuted instantiation: <range_collections::merge_state::InPlaceMergeState<[u32; 2], [u32; 2]> as range_collections::merge_state::MergeStateMut>::advance_b Unexecuted instantiation: <range_collections::merge_state::InPlaceMergeState<_, _> as range_collections::merge_state::MergeStateMut>::advance_b
73	0	fn ac(&self) -> bool {
74	0	self.ac
75	0	} Unexecuted instantiation: <range_collections::merge_state::InPlaceMergeState<[u32; 2], [u32; 2]> as range_collections::merge_state::MergeStateMut>::ac Unexecuted instantiation: <range_collections::merge_state::InPlaceMergeState<_, _> as range_collections::merge_state::MergeStateMut>::ac
76	0	fn bc(&self) -> bool {
77	0	self.bc
78	0	} Unexecuted instantiation: <range_collections::merge_state::InPlaceMergeState<[u32; 2], [u32; 2]> as range_collections::merge_state::MergeStateMut>::bc Unexecuted instantiation: <range_collections::merge_state::InPlaceMergeState<_, _> as range_collections::merge_state::MergeStateMut>::bc
79		}
80
81		impl<'a, A: Array, B: Array> InPlaceMergeState<'a, A, B> {
82	0	pub fn merge<O: MergeOperation<Self>>(a: &'a mut SmallVec<A>, b: SmallVec<B>, o: O) {
83	0	let mut state = Self::new(a, b);
84	0	o.merge(&mut state);
85	0	} Unexecuted instantiation: <range_collections::merge_state::InPlaceMergeState<[u32; 2], [u32; 2]>>::merge::<range_collections::range_set::UnionOp> Unexecuted instantiation: <range_collections::merge_state::InPlaceMergeState<_, _>>::merge::<_>
86		}
87
88		/// An in place merge state where the rhs is a reference
89		pub(crate) struct InPlaceMergeStateRef<'a, A: Array, B> {
90		a: InPlaceSmallVecBuilder<'a, A>,
91		b: SliceIterator<'a, B>,
92		ac: bool,
93		bc: bool,
94		}
95
96		impl<'a, A: Array, B> InPlaceMergeStateRef<'a, A, B> {
97	0	pub fn new(a: &'a mut SmallVec<A>, b: &'a impl AsRef<[B]>) -> Self {
98	0	Self {
99	0	a: a.into(),
100	0	b: SliceIterator(b.as_ref()),
101	0	ac: false,
102	0	bc: false,
103	0	}
104	0	}
105		}
106
107		impl<'a, A: Array, B> MergeState for InPlaceMergeStateRef<'a, A, B> {
108		type A = A::Item;
109		type B = B;
110	0	fn a_slice(&self) -> &[A::Item] {
111	0	self.a.source_slice()
112	0	}
113	0	fn b_slice(&self) -> &[B] {
114	0	self.b.as_slice()
115	0	}
116		}
117
118		impl<'a, A: Array> MergeStateMut for InPlaceMergeStateRef<'a, A, A::Item>
119		where
120		A::Item: Clone,
121		{
122		#[inline]
123	0	fn advance_a(&mut self, n: usize, take: bool) -> bool {
124	0	self.ac ^= is_odd(n);
125	0	self.a.consume(n, take);
126	0	true
127	0	}
128		#[inline]
129	0	fn advance_b(&mut self, n: usize, take: bool) -> bool {
130	0	self.bc ^= is_odd(n);
131	0	if take {
132	0	self.a.extend_from_iter((&mut self.b).cloned(), n);
133	0	} else {
134	0	for _ in 0..n {
135	0	let _ = self.b.next();
136	0	}
137		}
138	0	true
139	0	}
140	0	fn ac(&self) -> bool {
141	0	self.ac
142	0	}
143	0	fn bc(&self) -> bool {
144	0	self.bc
145	0	}
146		}
147
148		impl<'a, A: Array, B: 'a> InPlaceMergeStateRef<'a, A, B> {
149	0	pub fn merge<O: MergeOperation<Self>>(a: &'a mut SmallVec<A>, b: &'a impl AsRef<[B]>, o: O) {
150	0	let mut state = Self::new(a, b);
151	0	o.merge(&mut state);
152	0	}
153		}
154
155		/// A merge state where we only track if elements have been produced, and abort as soon as the first element is produced
156		pub(crate) struct BoolOpMergeState<'a, A, B> {
157		a: SliceIterator<'a, A>,
158		b: SliceIterator<'a, B>,
159		ac: bool,
160		bc: bool,
161		r: bool,
162		}
163
164		impl<'a, A: Debug, B: Debug> Debug for BoolOpMergeState<'a, A, B> {
165	0	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
166	0	write!(
167	0	f,
168	0	"a: {:?}, b: {:?} r: {}",
169	0	self.a_slice(),
170	0	self.b_slice(),
171		self.r
172		)
173	0	}
174		}
175
176		impl<'a, A, B> BoolOpMergeState<'a, A, B> {
177	0	pub fn new(a: &'a [A], b: &'a [B]) -> Self {
178	0	Self {
179	0	a: SliceIterator(a),
180	0	b: SliceIterator(b),
181	0	ac: false,
182	0	bc: false,
183	0	r: false,
184	0	}
185	0	} Unexecuted instantiation: <range_collections::merge_state::BoolOpMergeState<u32, u32>>::new Unexecuted instantiation: <range_collections::merge_state::BoolOpMergeState<_, _>>::new
186
187	0	pub fn result(self) -> bool {
188	0	self.r
189	0	} Unexecuted instantiation: <range_collections::merge_state::BoolOpMergeState<u32, u32>>::result Unexecuted instantiation: <range_collections::merge_state::BoolOpMergeState<_, _>>::result
190		}
191
192		impl<'a, A, B> BoolOpMergeState<'a, A, B> {
193	0	pub fn merge<O: MergeOperation<Self>>(a: &'a [A], b: &'a [B], o: O) -> bool {
194	0	let mut state = Self::new(a, b);
195	0	o.merge(&mut state);
196	0	state.r
197	0	}
198		}
199
200		impl<'a, A, B> MergeState for BoolOpMergeState<'a, A, B> {
201		type A = A;
202		type B = B;
203	0	fn a_slice(&self) -> &[A] {
204	0	self.a.as_slice()
205	0	} Unexecuted instantiation: <range_collections::merge_state::BoolOpMergeState<u32, u32> as binary_merge::MergeState>::a_slice Unexecuted instantiation: <range_collections::merge_state::BoolOpMergeState<_, _> as binary_merge::MergeState>::a_slice
206	0	fn b_slice(&self) -> &[B] {
207	0	self.b.as_slice()
208	0	} Unexecuted instantiation: <range_collections::merge_state::BoolOpMergeState<u32, u32> as binary_merge::MergeState>::b_slice Unexecuted instantiation: <range_collections::merge_state::BoolOpMergeState<_, _> as binary_merge::MergeState>::b_slice
209		}
210
211		impl<'a, A, B> MergeStateMut for BoolOpMergeState<'a, A, B> {
212	0	fn advance_a(&mut self, n: usize, take: bool) -> bool {
213	0	self.ac ^= is_odd(n);
214	0	if take {
215	0	self.r = true;
216	0	false
217		} else {
218	0	self.a.drop_front(n);
219	0	true
220		}
221	0	} Unexecuted instantiation: <range_collections::merge_state::BoolOpMergeState<u32, u32> as range_collections::merge_state::MergeStateMut>::advance_a Unexecuted instantiation: <range_collections::merge_state::BoolOpMergeState<_, _> as range_collections::merge_state::MergeStateMut>::advance_a
222
223	0	fn advance_b(&mut self, n: usize, take: bool) -> bool {
224	0	self.bc ^= is_odd(n);
225	0	if take {
226	0	self.r = true;
227	0	false
228		} else {
229	0	self.b.drop_front(n);
230	0	true
231		}
232	0	} Unexecuted instantiation: <range_collections::merge_state::BoolOpMergeState<u32, u32> as range_collections::merge_state::MergeStateMut>::advance_b Unexecuted instantiation: <range_collections::merge_state::BoolOpMergeState<_, _> as range_collections::merge_state::MergeStateMut>::advance_b
233	0	fn ac(&self) -> bool {
234	0	self.ac
235	0	} Unexecuted instantiation: <range_collections::merge_state::BoolOpMergeState<u32, u32> as range_collections::merge_state::MergeStateMut>::ac Unexecuted instantiation: <range_collections::merge_state::BoolOpMergeState<_, _> as range_collections::merge_state::MergeStateMut>::ac
236	0	fn bc(&self) -> bool {
237	0	self.bc
238	0	} Unexecuted instantiation: <range_collections::merge_state::BoolOpMergeState<u32, u32> as range_collections::merge_state::MergeStateMut>::bc Unexecuted instantiation: <range_collections::merge_state::BoolOpMergeState<_, _> as range_collections::merge_state::MergeStateMut>::bc
239		}
240
241		/// A merge state where we build into a new vector
242		pub(crate) struct SmallVecMergeState<'a, A, B, Arr: Array> {
243		a: SliceIterator<'a, A>,
244		b: SliceIterator<'a, B>,
245		ac: bool,
246		bc: bool,
247		r: SmallVec<Arr>,
248		}
249
250		impl<'a, A: Debug, B: Debug, Arr: Array> Debug for SmallVecMergeState<'a, A, B, Arr> {
251	0	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
252	0	write!(f, "a: {:?}, b: {:?}", self.a_slice(), self.b_slice(),)
253	0	}
254		}
255
256		impl<'a, A, B, Arr: Array> SmallVecMergeState<'a, A, B, Arr> {
257	0	pub fn new(a: &'a [A], b: &'a [B], r: SmallVec<Arr>) -> Self {
258	0	Self {
259	0	a: SliceIterator(a),
260	0	b: SliceIterator(b),
261	0	ac: false,
262	0	bc: false,
263	0	r,
264	0	}
265	0	} Unexecuted instantiation: <range_collections::merge_state::SmallVecMergeState<u32, u32, [u32; 2]>>::new Unexecuted instantiation: <range_collections::merge_state::SmallVecMergeState<_, _, _>>::new
266
267	0	pub fn result(self) -> SmallVec<Arr> {
268	0	self.r
269	0	} Unexecuted instantiation: <range_collections::merge_state::SmallVecMergeState<u32, u32, [u32; 2]>>::result Unexecuted instantiation: <range_collections::merge_state::SmallVecMergeState<_, _, _>>::result
270
271	0	pub fn merge<O: MergeOperation<Self>>(a: &'a [A], b: &'a [B], o: O) -> SmallVec<Arr> {
272	0	let t: SmallVec<Arr> = SmallVec::new();
273	0	let mut state = Self::new(a, b, t);
274	0	o.merge(&mut state);
275	0	state.result()
276	0	}
277		}
278
279		impl<'a, A, B, Arr: Array> MergeState for SmallVecMergeState<'a, A, B, Arr> {
280		type A = A;
281		type B = B;
282	0	fn a_slice(&self) -> &[A] {
283	0	self.a.as_slice()
284	0	} Unexecuted instantiation: <range_collections::merge_state::SmallVecMergeState<u32, u32, [u32; 2]> as binary_merge::MergeState>::a_slice Unexecuted instantiation: <range_collections::merge_state::SmallVecMergeState<_, _, _> as binary_merge::MergeState>::a_slice
285	0	fn b_slice(&self) -> &[B] {
286	0	self.b.as_slice()
287	0	} Unexecuted instantiation: <range_collections::merge_state::SmallVecMergeState<u32, u32, [u32; 2]> as binary_merge::MergeState>::b_slice Unexecuted instantiation: <range_collections::merge_state::SmallVecMergeState<_, _, _> as binary_merge::MergeState>::b_slice
288		}
289
290		impl<'a, T: Clone, Arr: Array<Item = T>> MergeStateMut for SmallVecMergeState<'a, T, T, Arr> {
291	0	fn advance_a(&mut self, n: usize, take: bool) -> bool {
292	0	self.ac ^= is_odd(n);
293	0	if take {
294	0	self.r.reserve(n);
295	0	for e in self.a.take_front(n).iter() {
296	0	self.r.push(e.clone())
297		}
298	0	} else {
299	0	self.a.drop_front(n);
300	0	}
301	0	true
302	0	} Unexecuted instantiation: <range_collections::merge_state::SmallVecMergeState<u32, u32, [u32; 2]> as range_collections::merge_state::MergeStateMut>::advance_a Unexecuted instantiation: <range_collections::merge_state::SmallVecMergeState<_, _, _> as range_collections::merge_state::MergeStateMut>::advance_a
303
304	0	fn advance_b(&mut self, n: usize, take: bool) -> bool {
305	0	self.bc ^= is_odd(n);
306	0	if take {
307	0	self.r.reserve(n);
308	0	for e in self.b.take_front(n).iter() {
309	0	self.r.push(e.clone())
310		}
311	0	} else {
312	0	self.b.drop_front(n);
313	0	}
314	0	true
315	0	} Unexecuted instantiation: <range_collections::merge_state::SmallVecMergeState<u32, u32, [u32; 2]> as range_collections::merge_state::MergeStateMut>::advance_b Unexecuted instantiation: <range_collections::merge_state::SmallVecMergeState<_, _, _> as range_collections::merge_state::MergeStateMut>::advance_b
316	0	fn ac(&self) -> bool {
317	0	self.ac
318	0	} Unexecuted instantiation: <range_collections::merge_state::SmallVecMergeState<u32, u32, [u32; 2]> as range_collections::merge_state::MergeStateMut>::ac Unexecuted instantiation: <range_collections::merge_state::SmallVecMergeState<_, _, _> as range_collections::merge_state::MergeStateMut>::ac
319	0	fn bc(&self) -> bool {
320	0	self.bc
321	0	} Unexecuted instantiation: <range_collections::merge_state::SmallVecMergeState<u32, u32, [u32; 2]> as range_collections::merge_state::MergeStateMut>::bc Unexecuted instantiation: <range_collections::merge_state::SmallVecMergeState<_, _, _> as range_collections::merge_state::MergeStateMut>::bc
322		}
323
324		#[inline]
325	0	fn is_odd(x: usize) -> bool {
326	0	(x & 1) != 0
327	0	} Unexecuted instantiation: range_collections::merge_state::is_odd Unexecuted instantiation: range_collections::merge_state::is_odd