1use super::core::IndexMapCore;
2use super::{Bucket, Entries, IndexMap, Slice};
3
4use alloc::vec::{self, Vec};
5use core::fmt;
6use core::hash::{BuildHasher, Hash};
7use core::iter::FusedIterator;
8use core::ops::{Index, RangeBounds};
9use core::slice;
10
11impl<'a, K, V, S> IntoIterator for &'a IndexMap<K, V, S> {
12 type Item = (&'a K, &'a V);
13 type IntoIter = Iter<'a, K, V>;
14
15 fn into_iter(self) -> Self::IntoIter {
16 self.iter()
17 }
18}
19
20impl<'a, K, V, S> IntoIterator for &'a mut IndexMap<K, V, S> {
21 type Item = (&'a K, &'a mut V);
22 type IntoIter = IterMut<'a, K, V>;
23
24 fn into_iter(self) -> Self::IntoIter {
25 self.iter_mut()
26 }
27}
28
29impl<K, V, S> IntoIterator for IndexMap<K, V, S> {
30 type Item = (K, V);
31 type IntoIter = IntoIter<K, V>;
32
33 fn into_iter(self) -> Self::IntoIter {
34 IntoIter::new(self.into_entries())
35 }
36}
37
38/// An iterator over the entries of an [`IndexMap`].
39///
40/// This `struct` is created by the [`IndexMap::iter`] method.
41/// See its documentation for more.
42pub struct Iter<'a, K, V> {
43 iter: slice::Iter<'a, Bucket<K, V>>,
44}
45
46impl<'a, K, V> Iter<'a, K, V> {
47 pub(super) fn new(entries: &'a [Bucket<K, V>]) -> Self {
48 Self {
49 iter: entries.iter(),
50 }
51 }
52
53 /// Returns a slice of the remaining entries in the iterator.
54 pub fn as_slice(&self) -> &'a Slice<K, V> {
55 Slice::from_slice(self.iter.as_slice())
56 }
57}
58
59impl<'a, K, V> Iterator for Iter<'a, K, V> {
60 type Item = (&'a K, &'a V);
61
62 iterator_methods!(Bucket::refs);
63}
64
65impl<K, V> DoubleEndedIterator for Iter<'_, K, V> {
66 double_ended_iterator_methods!(Bucket::refs);
67}
68
69impl<K, V> ExactSizeIterator for Iter<'_, K, V> {
70 fn len(&self) -> usize {
71 self.iter.len()
72 }
73}
74
75impl<K, V> FusedIterator for Iter<'_, K, V> {}
76
77// FIXME(#26925) Remove in favor of `#[derive(Clone)]`
78impl<K, V> Clone for Iter<'_, K, V> {
79 fn clone(&self) -> Self {
80 Iter {
81 iter: self.iter.clone(),
82 }
83 }
84}
85
86impl<K: fmt::Debug, V: fmt::Debug> fmt::Debug for Iter<'_, K, V> {
87 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
88 f.debug_list().entries(self.clone()).finish()
89 }
90}
91
92impl<K, V> Default for Iter<'_, K, V> {
93 fn default() -> Self {
94 Self { iter: [].iter() }
95 }
96}
97
98/// A mutable iterator over the entries of an [`IndexMap`].
99///
100/// This `struct` is created by the [`IndexMap::iter_mut`] method.
101/// See its documentation for more.
102pub struct IterMut<'a, K, V> {
103 iter: slice::IterMut<'a, Bucket<K, V>>,
104}
105
106impl<'a, K, V> IterMut<'a, K, V> {
107 pub(super) fn new(entries: &'a mut [Bucket<K, V>]) -> Self {
108 Self {
109 iter: entries.iter_mut(),
110 }
111 }
112
113 /// Returns a slice of the remaining entries in the iterator.
114 pub fn as_slice(&self) -> &Slice<K, V> {
115 Slice::from_slice(self.iter.as_slice())
116 }
117
118 /// Returns a mutable slice of the remaining entries in the iterator.
119 ///
120 /// To avoid creating `&mut` references that alias, this is forced to consume the iterator.
121 pub fn into_slice(self) -> &'a mut Slice<K, V> {
122 Slice::from_mut_slice(self.iter.into_slice())
123 }
124}
125
126impl<'a, K, V> Iterator for IterMut<'a, K, V> {
127 type Item = (&'a K, &'a mut V);
128
129 iterator_methods!(Bucket::ref_mut);
130}
131
132impl<K, V> DoubleEndedIterator for IterMut<'_, K, V> {
133 double_ended_iterator_methods!(Bucket::ref_mut);
134}
135
136impl<K, V> ExactSizeIterator for IterMut<'_, K, V> {
137 fn len(&self) -> usize {
138 self.iter.len()
139 }
140}
141
142impl<K, V> FusedIterator for IterMut<'_, K, V> {}
143
144impl<K: fmt::Debug, V: fmt::Debug> fmt::Debug for IterMut<'_, K, V> {
145 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
146 let iter: impl Iterator = self.iter.as_slice().iter().map(Bucket::refs);
147 f.debug_list().entries(iter).finish()
148 }
149}
150
151impl<K, V> Default for IterMut<'_, K, V> {
152 fn default() -> Self {
153 Self {
154 iter: [].iter_mut(),
155 }
156 }
157}
158
159/// A mutable iterator over the entries of an [`IndexMap`].
160///
161/// This `struct` is created by the [`MutableKeys::iter_mut2`][super::MutableKeys::iter_mut2] method.
162/// See its documentation for more.
163pub struct IterMut2<'a, K, V> {
164 iter: slice::IterMut<'a, Bucket<K, V>>,
165}
166
167impl<'a, K, V> IterMut2<'a, K, V> {
168 pub(super) fn new(entries: &'a mut [Bucket<K, V>]) -> Self {
169 Self {
170 iter: entries.iter_mut(),
171 }
172 }
173
174 /// Returns a slice of the remaining entries in the iterator.
175 pub fn as_slice(&self) -> &Slice<K, V> {
176 Slice::from_slice(self.iter.as_slice())
177 }
178
179 /// Returns a mutable slice of the remaining entries in the iterator.
180 ///
181 /// To avoid creating `&mut` references that alias, this is forced to consume the iterator.
182 pub fn into_slice(self) -> &'a mut Slice<K, V> {
183 Slice::from_mut_slice(self.iter.into_slice())
184 }
185}
186
187impl<'a, K, V> Iterator for IterMut2<'a, K, V> {
188 type Item = (&'a mut K, &'a mut V);
189
190 iterator_methods!(Bucket::muts);
191}
192
193impl<K, V> DoubleEndedIterator for IterMut2<'_, K, V> {
194 double_ended_iterator_methods!(Bucket::muts);
195}
196
197impl<K, V> ExactSizeIterator for IterMut2<'_, K, V> {
198 fn len(&self) -> usize {
199 self.iter.len()
200 }
201}
202
203impl<K, V> FusedIterator for IterMut2<'_, K, V> {}
204
205impl<K: fmt::Debug, V: fmt::Debug> fmt::Debug for IterMut2<'_, K, V> {
206 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
207 let iter: impl Iterator = self.iter.as_slice().iter().map(Bucket::refs);
208 f.debug_list().entries(iter).finish()
209 }
210}
211
212impl<K, V> Default for IterMut2<'_, K, V> {
213 fn default() -> Self {
214 Self {
215 iter: [].iter_mut(),
216 }
217 }
218}
219
220/// An owning iterator over the entries of an [`IndexMap`].
221///
222/// This `struct` is created by the [`IndexMap::into_iter`] method
223/// (provided by the [`IntoIterator`] trait). See its documentation for more.
224#[derive(Clone)]
225pub struct IntoIter<K, V> {
226 iter: vec::IntoIter<Bucket<K, V>>,
227}
228
229impl<K, V> IntoIter<K, V> {
230 pub(super) fn new(entries: Vec<Bucket<K, V>>) -> Self {
231 Self {
232 iter: entries.into_iter(),
233 }
234 }
235
236 /// Returns a slice of the remaining entries in the iterator.
237 pub fn as_slice(&self) -> &Slice<K, V> {
238 Slice::from_slice(self.iter.as_slice())
239 }
240
241 /// Returns a mutable slice of the remaining entries in the iterator.
242 pub fn as_mut_slice(&mut self) -> &mut Slice<K, V> {
243 Slice::from_mut_slice(self.iter.as_mut_slice())
244 }
245}
246
247impl<K, V> Iterator for IntoIter<K, V> {
248 type Item = (K, V);
249
250 iterator_methods!(Bucket::key_value);
251}
252
253impl<K, V> DoubleEndedIterator for IntoIter<K, V> {
254 double_ended_iterator_methods!(Bucket::key_value);
255}
256
257impl<K, V> ExactSizeIterator for IntoIter<K, V> {
258 fn len(&self) -> usize {
259 self.iter.len()
260 }
261}
262
263impl<K, V> FusedIterator for IntoIter<K, V> {}
264
265impl<K: fmt::Debug, V: fmt::Debug> fmt::Debug for IntoIter<K, V> {
266 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
267 let iter: impl Iterator = self.iter.as_slice().iter().map(Bucket::refs);
268 f.debug_list().entries(iter).finish()
269 }
270}
271
272impl<K, V> Default for IntoIter<K, V> {
273 fn default() -> Self {
274 Self {
275 iter: Vec::new().into_iter(),
276 }
277 }
278}
279
280/// A draining iterator over the entries of an [`IndexMap`].
281///
282/// This `struct` is created by the [`IndexMap::drain`] method.
283/// See its documentation for more.
284pub struct Drain<'a, K, V> {
285 iter: vec::Drain<'a, Bucket<K, V>>,
286}
287
288impl<'a, K, V> Drain<'a, K, V> {
289 pub(super) fn new(iter: vec::Drain<'a, Bucket<K, V>>) -> Self {
290 Self { iter }
291 }
292
293 /// Returns a slice of the remaining entries in the iterator.
294 pub fn as_slice(&self) -> &Slice<K, V> {
295 Slice::from_slice(self.iter.as_slice())
296 }
297}
298
299impl<K, V> Iterator for Drain<'_, K, V> {
300 type Item = (K, V);
301
302 iterator_methods!(Bucket::key_value);
303}
304
305impl<K, V> DoubleEndedIterator for Drain<'_, K, V> {
306 double_ended_iterator_methods!(Bucket::key_value);
307}
308
309impl<K, V> ExactSizeIterator for Drain<'_, K, V> {
310 fn len(&self) -> usize {
311 self.iter.len()
312 }
313}
314
315impl<K, V> FusedIterator for Drain<'_, K, V> {}
316
317impl<K: fmt::Debug, V: fmt::Debug> fmt::Debug for Drain<'_, K, V> {
318 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
319 let iter: impl Iterator = self.iter.as_slice().iter().map(Bucket::refs);
320 f.debug_list().entries(iter).finish()
321 }
322}
323
324/// An iterator over the keys of an [`IndexMap`].
325///
326/// This `struct` is created by the [`IndexMap::keys`] method.
327/// See its documentation for more.
328pub struct Keys<'a, K, V> {
329 iter: slice::Iter<'a, Bucket<K, V>>,
330}
331
332impl<'a, K, V> Keys<'a, K, V> {
333 pub(super) fn new(entries: &'a [Bucket<K, V>]) -> Self {
334 Self {
335 iter: entries.iter(),
336 }
337 }
338}
339
340impl<'a, K, V> Iterator for Keys<'a, K, V> {
341 type Item = &'a K;
342
343 iterator_methods!(Bucket::key_ref);
344}
345
346impl<K, V> DoubleEndedIterator for Keys<'_, K, V> {
347 double_ended_iterator_methods!(Bucket::key_ref);
348}
349
350impl<K, V> ExactSizeIterator for Keys<'_, K, V> {
351 fn len(&self) -> usize {
352 self.iter.len()
353 }
354}
355
356impl<K, V> FusedIterator for Keys<'_, K, V> {}
357
358// FIXME(#26925) Remove in favor of `#[derive(Clone)]`
359impl<K, V> Clone for Keys<'_, K, V> {
360 fn clone(&self) -> Self {
361 Keys {
362 iter: self.iter.clone(),
363 }
364 }
365}
366
367impl<K: fmt::Debug, V> fmt::Debug for Keys<'_, K, V> {
368 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
369 f.debug_list().entries(self.clone()).finish()
370 }
371}
372
373impl<K, V> Default for Keys<'_, K, V> {
374 fn default() -> Self {
375 Self { iter: [].iter() }
376 }
377}
378
379/// Access [`IndexMap`] keys at indexed positions.
380///
381/// While [`Index<usize> for IndexMap`][values] accesses a map's values,
382/// indexing through [`IndexMap::keys`] offers an alternative to access a map's
383/// keys instead.
384///
385/// [values]: IndexMap#impl-Index<usize>-for-IndexMap<K,+V,+S>
386///
387/// Since `Keys` is also an iterator, consuming items from the iterator will
388/// offset the effective indexes. Similarly, if `Keys` is obtained from
389/// [`Slice::keys`], indexes will be interpreted relative to the position of
390/// that slice.
391///
392/// # Examples
393///
394/// ```
395/// use indexmap::IndexMap;
396///
397/// let mut map = IndexMap::new();
398/// for word in "Lorem ipsum dolor sit amet".split_whitespace() {
399/// map.insert(word.to_lowercase(), word.to_uppercase());
400/// }
401///
402/// assert_eq!(map[0], "LOREM");
403/// assert_eq!(map.keys()[0], "lorem");
404/// assert_eq!(map[1], "IPSUM");
405/// assert_eq!(map.keys()[1], "ipsum");
406///
407/// map.reverse();
408/// assert_eq!(map.keys()[0], "amet");
409/// assert_eq!(map.keys()[1], "sit");
410///
411/// map.sort_keys();
412/// assert_eq!(map.keys()[0], "amet");
413/// assert_eq!(map.keys()[1], "dolor");
414///
415/// // Advancing the iterator will offset the indexing
416/// let mut keys = map.keys();
417/// assert_eq!(keys[0], "amet");
418/// assert_eq!(keys.next().map(|s| &**s), Some("amet"));
419/// assert_eq!(keys[0], "dolor");
420/// assert_eq!(keys[1], "ipsum");
421///
422/// // Slices may have an offset as well
423/// let slice = &map[2..];
424/// assert_eq!(slice[0], "IPSUM");
425/// assert_eq!(slice.keys()[0], "ipsum");
426/// ```
427///
428/// ```should_panic
429/// use indexmap::IndexMap;
430///
431/// let mut map = IndexMap::new();
432/// map.insert("foo", 1);
433/// println!("{:?}", map.keys()[10]); // panics!
434/// ```
435impl<'a, K, V> Index<usize> for Keys<'a, K, V> {
436 type Output = K;
437
438 /// Returns a reference to the key at the supplied `index`.
439 ///
440 /// ***Panics*** if `index` is out of bounds.
441 fn index(&self, index: usize) -> &K {
442 &self.iter.as_slice()[index].key
443 }
444}
445
446/// An owning iterator over the keys of an [`IndexMap`].
447///
448/// This `struct` is created by the [`IndexMap::into_keys`] method.
449/// See its documentation for more.
450pub struct IntoKeys<K, V> {
451 iter: vec::IntoIter<Bucket<K, V>>,
452}
453
454impl<K, V> IntoKeys<K, V> {
455 pub(super) fn new(entries: Vec<Bucket<K, V>>) -> Self {
456 Self {
457 iter: entries.into_iter(),
458 }
459 }
460}
461
462impl<K, V> Iterator for IntoKeys<K, V> {
463 type Item = K;
464
465 iterator_methods!(Bucket::key);
466}
467
468impl<K, V> DoubleEndedIterator for IntoKeys<K, V> {
469 double_ended_iterator_methods!(Bucket::key);
470}
471
472impl<K, V> ExactSizeIterator for IntoKeys<K, V> {
473 fn len(&self) -> usize {
474 self.iter.len()
475 }
476}
477
478impl<K, V> FusedIterator for IntoKeys<K, V> {}
479
480impl<K: fmt::Debug, V> fmt::Debug for IntoKeys<K, V> {
481 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
482 let iter: impl Iterator = self.iter.as_slice().iter().map(Bucket::key_ref);
483 f.debug_list().entries(iter).finish()
484 }
485}
486
487impl<K, V> Default for IntoKeys<K, V> {
488 fn default() -> Self {
489 Self {
490 iter: Vec::new().into_iter(),
491 }
492 }
493}
494
495/// An iterator over the values of an [`IndexMap`].
496///
497/// This `struct` is created by the [`IndexMap::values`] method.
498/// See its documentation for more.
499pub struct Values<'a, K, V> {
500 iter: slice::Iter<'a, Bucket<K, V>>,
501}
502
503impl<'a, K, V> Values<'a, K, V> {
504 pub(super) fn new(entries: &'a [Bucket<K, V>]) -> Self {
505 Self {
506 iter: entries.iter(),
507 }
508 }
509}
510
511impl<'a, K, V> Iterator for Values<'a, K, V> {
512 type Item = &'a V;
513
514 iterator_methods!(Bucket::value_ref);
515}
516
517impl<K, V> DoubleEndedIterator for Values<'_, K, V> {
518 double_ended_iterator_methods!(Bucket::value_ref);
519}
520
521impl<K, V> ExactSizeIterator for Values<'_, K, V> {
522 fn len(&self) -> usize {
523 self.iter.len()
524 }
525}
526
527impl<K, V> FusedIterator for Values<'_, K, V> {}
528
529// FIXME(#26925) Remove in favor of `#[derive(Clone)]`
530impl<K, V> Clone for Values<'_, K, V> {
531 fn clone(&self) -> Self {
532 Values {
533 iter: self.iter.clone(),
534 }
535 }
536}
537
538impl<K, V: fmt::Debug> fmt::Debug for Values<'_, K, V> {
539 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
540 f.debug_list().entries(self.clone()).finish()
541 }
542}
543
544impl<K, V> Default for Values<'_, K, V> {
545 fn default() -> Self {
546 Self { iter: [].iter() }
547 }
548}
549
550/// A mutable iterator over the values of an [`IndexMap`].
551///
552/// This `struct` is created by the [`IndexMap::values_mut`] method.
553/// See its documentation for more.
554pub struct ValuesMut<'a, K, V> {
555 iter: slice::IterMut<'a, Bucket<K, V>>,
556}
557
558impl<'a, K, V> ValuesMut<'a, K, V> {
559 pub(super) fn new(entries: &'a mut [Bucket<K, V>]) -> Self {
560 Self {
561 iter: entries.iter_mut(),
562 }
563 }
564}
565
566impl<'a, K, V> Iterator for ValuesMut<'a, K, V> {
567 type Item = &'a mut V;
568
569 iterator_methods!(Bucket::value_mut);
570}
571
572impl<K, V> DoubleEndedIterator for ValuesMut<'_, K, V> {
573 double_ended_iterator_methods!(Bucket::value_mut);
574}
575
576impl<K, V> ExactSizeIterator for ValuesMut<'_, K, V> {
577 fn len(&self) -> usize {
578 self.iter.len()
579 }
580}
581
582impl<K, V> FusedIterator for ValuesMut<'_, K, V> {}
583
584impl<K, V: fmt::Debug> fmt::Debug for ValuesMut<'_, K, V> {
585 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
586 let iter: impl Iterator = self.iter.as_slice().iter().map(Bucket::value_ref);
587 f.debug_list().entries(iter).finish()
588 }
589}
590
591impl<K, V> Default for ValuesMut<'_, K, V> {
592 fn default() -> Self {
593 Self {
594 iter: [].iter_mut(),
595 }
596 }
597}
598
599/// An owning iterator over the values of an [`IndexMap`].
600///
601/// This `struct` is created by the [`IndexMap::into_values`] method.
602/// See its documentation for more.
603pub struct IntoValues<K, V> {
604 iter: vec::IntoIter<Bucket<K, V>>,
605}
606
607impl<K, V> IntoValues<K, V> {
608 pub(super) fn new(entries: Vec<Bucket<K, V>>) -> Self {
609 Self {
610 iter: entries.into_iter(),
611 }
612 }
613}
614
615impl<K, V> Iterator for IntoValues<K, V> {
616 type Item = V;
617
618 iterator_methods!(Bucket::value);
619}
620
621impl<K, V> DoubleEndedIterator for IntoValues<K, V> {
622 double_ended_iterator_methods!(Bucket::value);
623}
624
625impl<K, V> ExactSizeIterator for IntoValues<K, V> {
626 fn len(&self) -> usize {
627 self.iter.len()
628 }
629}
630
631impl<K, V> FusedIterator for IntoValues<K, V> {}
632
633impl<K, V: fmt::Debug> fmt::Debug for IntoValues<K, V> {
634 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
635 let iter: impl Iterator = self.iter.as_slice().iter().map(Bucket::value_ref);
636 f.debug_list().entries(iter).finish()
637 }
638}
639
640impl<K, V> Default for IntoValues<K, V> {
641 fn default() -> Self {
642 Self {
643 iter: Vec::new().into_iter(),
644 }
645 }
646}
647
648/// A splicing iterator for `IndexMap`.
649///
650/// This `struct` is created by [`IndexMap::splice()`].
651/// See its documentation for more.
652pub struct Splice<'a, I, K, V, S>
653where
654 I: Iterator<Item = (K, V)>,
655 K: Hash + Eq,
656 S: BuildHasher,
657{
658 map: &'a mut IndexMap<K, V, S>,
659 tail: IndexMapCore<K, V>,
660 drain: vec::IntoIter<Bucket<K, V>>,
661 replace_with: I,
662}
663
664impl<'a, I, K, V, S> Splice<'a, I, K, V, S>
665where
666 I: Iterator<Item = (K, V)>,
667 K: Hash + Eq,
668 S: BuildHasher,
669{
670 pub(super) fn new<R>(map: &'a mut IndexMap<K, V, S>, range: R, replace_with: I) -> Self
671 where
672 R: RangeBounds<usize>,
673 {
674 let (tail: IndexMapCore, drain: IntoIter>) = map.core.split_splice(range);
675 Self {
676 map,
677 tail,
678 drain,
679 replace_with,
680 }
681 }
682}
683
684impl<I, K, V, S> Drop for Splice<'_, I, K, V, S>
685where
686 I: Iterator<Item = (K, V)>,
687 K: Hash + Eq,
688 S: BuildHasher,
689{
690 fn drop(&mut self) {
691 // Finish draining unconsumed items. We don't strictly *have* to do this
692 // manually, since we already split it into separate memory, but it will
693 // match the drop order of `vec::Splice` items this way.
694 let _ = self.drain.nth(usize::MAX);
695
696 // Now insert all the new items. If a key matches an existing entry, it
697 // keeps the original position and only replaces the value, like `insert`.
698 while let Some((key: K, value: V)) = self.replace_with.next() {
699 // Since the tail is disjoint, we can try to update it first,
700 // or else insert (update or append) the primary map.
701 let hash: HashValue = self.map.hash(&key);
702 if let Some(i: usize) = self.tail.get_index_of(hash, &key) {
703 self.tail.as_entries_mut()[i].value = value;
704 } else {
705 self.map.core.insert_full(hash, key, value);
706 }
707 }
708
709 // Finally, re-append the tail
710 self.map.core.append_unchecked(&mut self.tail);
711 }
712}
713
714impl<I, K, V, S> Iterator for Splice<'_, I, K, V, S>
715where
716 I: Iterator<Item = (K, V)>,
717 K: Hash + Eq,
718 S: BuildHasher,
719{
720 type Item = (K, V);
721
722 fn next(&mut self) -> Option<Self::Item> {
723 self.drain.next().map(Bucket::key_value)
724 }
725
726 fn size_hint(&self) -> (usize, Option<usize>) {
727 self.drain.size_hint()
728 }
729}
730
731impl<I, K, V, S> DoubleEndedIterator for Splice<'_, I, K, V, S>
732where
733 I: Iterator<Item = (K, V)>,
734 K: Hash + Eq,
735 S: BuildHasher,
736{
737 fn next_back(&mut self) -> Option<Self::Item> {
738 self.drain.next_back().map(Bucket::key_value)
739 }
740}
741
742impl<I, K, V, S> ExactSizeIterator for Splice<'_, I, K, V, S>
743where
744 I: Iterator<Item = (K, V)>,
745 K: Hash + Eq,
746 S: BuildHasher,
747{
748 fn len(&self) -> usize {
749 self.drain.len()
750 }
751}
752
753impl<I, K, V, S> FusedIterator for Splice<'_, I, K, V, S>
754where
755 I: Iterator<Item = (K, V)>,
756 K: Hash + Eq,
757 S: BuildHasher,
758{
759}
760
761impl<'a, I, K, V, S> fmt::Debug for Splice<'a, I, K, V, S>
762where
763 I: fmt::Debug + Iterator<Item = (K, V)>,
764 K: fmt::Debug + Hash + Eq,
765 V: fmt::Debug,
766 S: BuildHasher,
767{
768 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
769 // Follow `vec::Splice` in only printing the drain and replacement
770 f&mut DebugStruct<'_, '_>.debug_struct("Splice")
771 .field("drain", &self.drain)
772 .field(name:"replace_with", &self.replace_with)
773 .finish()
774 }
775}
776