@@ -212,21 +212,25 @@ impl<T> Default for ManualEventReader<T> {
212
212
#[ allow( clippy:: len_without_is_empty) ] // Check fails since the is_empty implementation has a signature other than `(&self) -> bool`
213
213
impl < T : Event > ManualEventReader < T > {
214
214
/// See [`EventReader::iter`]
215
- pub fn iter < ' a > ( & ' a mut self , events : & ' a Events < T > ) -> impl DoubleEndedIterator < Item = & ' a T > {
215
+ pub fn iter < ' a > (
216
+ & ' a mut self ,
217
+ events : & ' a Events < T > ,
218
+ ) -> impl DoubleEndedIterator < Item = & ' a T > + ExactSizeIterator < Item = & ' a T > {
216
219
internal_event_reader ( & mut self . last_event_count , events) . map ( |( e, _) | e)
217
220
}
218
221
219
222
/// See [`EventReader::iter_with_id`]
220
223
pub fn iter_with_id < ' a > (
221
224
& ' a mut self ,
222
225
events : & ' a Events < T > ,
223
- ) -> impl DoubleEndedIterator < Item = ( & ' a T , EventId < T > ) > {
226
+ ) -> impl DoubleEndedIterator < Item = ( & ' a T , EventId < T > ) >
227
+ + ExactSizeIterator < Item = ( & ' a T , EventId < T > ) > {
224
228
internal_event_reader ( & mut self . last_event_count , events)
225
229
}
226
230
227
231
/// See [`EventReader::len`]
228
232
pub fn len ( & self , events : & Events < T > ) -> usize {
229
- events . event_reader_len ( self . last_event_count )
233
+ internal_event_reader ( & mut self . last_event_count . clone ( ) , events ) . len ( )
230
234
}
231
235
232
236
/// See [`EventReader::is_empty`]
@@ -240,7 +244,8 @@ impl<T: Event> ManualEventReader<T> {
240
244
fn internal_event_reader < ' a , T > (
241
245
last_event_count : & ' a mut usize ,
242
246
events : & ' a Events < T > ,
243
- ) -> impl DoubleEndedIterator < Item = ( & ' a T , EventId < T > ) > {
247
+ ) -> impl DoubleEndedIterator < Item = ( & ' a T , EventId < T > ) > + ExactSizeIterator < Item = ( & ' a T , EventId < T > ) >
248
+ {
244
249
// if the reader has seen some of the events in a buffer, find the proper index offset.
245
250
// otherwise read all events in the buffer
246
251
let a_index = if * last_event_count > events. a_start_event_count {
@@ -263,19 +268,77 @@ fn internal_event_reader<'a, T>(
263
268
} ;
264
269
iterator
265
270
. map ( map_instance_event_with_id)
271
+ . with_exact_size ( unread_count)
266
272
. inspect ( move |( _, id) | * last_event_count = ( id. id + 1 ) . max ( * last_event_count) )
267
273
}
268
274
275
+ trait IteratorExt {
276
+ fn with_exact_size ( self , len : usize ) -> ExactSize < Self >
277
+ where
278
+ Self : Sized ,
279
+ {
280
+ ExactSize :: new ( self , len)
281
+ }
282
+ }
283
+ impl < I > IteratorExt for I where I : Iterator { }
284
+
285
+ #[ must_use = "iterators are lazy and do nothing unless consumed" ]
286
+ #[ derive( Clone ) ]
287
+ struct ExactSize < I > {
288
+ iter : I ,
289
+ len : usize ,
290
+ }
291
+ impl < I > ExactSize < I > {
292
+ fn new ( iter : I , len : usize ) -> Self {
293
+ ExactSize { iter, len }
294
+ }
295
+ }
296
+
297
+ impl < I : Iterator > Iterator for ExactSize < I > {
298
+ type Item = I :: Item ;
299
+
300
+ #[ inline]
301
+ fn next ( & mut self ) -> Option < I :: Item > {
302
+ self . iter . next ( ) . map ( |e| {
303
+ self . len -= 1 ;
304
+ e
305
+ } )
306
+ }
307
+
308
+ #[ inline]
309
+ fn size_hint ( & self ) -> ( usize , Option < usize > ) {
310
+ ( self . len , Some ( self . len ) )
311
+ }
312
+ }
313
+
314
+ impl < I : DoubleEndedIterator > DoubleEndedIterator for ExactSize < I > {
315
+ #[ inline]
316
+ fn next_back ( & mut self ) -> Option < I :: Item > {
317
+ self . iter . next_back ( ) . map ( |e| {
318
+ self . len -= 1 ;
319
+ e
320
+ } )
321
+ }
322
+ }
323
+ impl < I : Iterator > ExactSizeIterator for ExactSize < I > {
324
+ fn len ( & self ) -> usize {
325
+ self . len
326
+ }
327
+ }
328
+
269
329
impl < ' w , ' s , T : Event > EventReader < ' w , ' s , T > {
270
330
/// Iterates over the events this [`EventReader`] has not seen yet. This updates the
271
331
/// [`EventReader`]'s event counter, which means subsequent event reads will not include events
272
332
/// that happened before now.
273
- pub fn iter ( & mut self ) -> impl DoubleEndedIterator < Item = & T > {
333
+ pub fn iter ( & mut self ) -> impl DoubleEndedIterator < Item = & T > + ExactSizeIterator < Item = & T > {
274
334
self . iter_with_id ( ) . map ( |( event, _id) | event)
275
335
}
276
336
277
337
/// Like [`iter`](Self::iter), except also returning the [`EventId`] of the events.
278
- pub fn iter_with_id ( & mut self ) -> impl DoubleEndedIterator < Item = ( & T , EventId < T > ) > {
338
+ pub fn iter_with_id (
339
+ & mut self ,
340
+ ) -> impl DoubleEndedIterator < Item = ( & T , EventId < T > ) > + ExactSizeIterator < Item = ( & T , EventId < T > ) >
341
+ {
279
342
internal_event_reader ( & mut self . last_event_count . 0 , & self . events ) . map ( |( event, id) | {
280
343
trace ! ( "EventReader::iter() -> {}" , id) ;
281
344
( event, id)
@@ -284,7 +347,7 @@ impl<'w, 's, T: Event> EventReader<'w, 's, T> {
284
347
285
348
/// Determines the number of events available to be read from this [`EventReader`] without consuming any.
286
349
pub fn len ( & self ) -> usize {
287
- self . events . event_reader_len ( self . last_event_count . 0 )
350
+ internal_event_reader ( & mut self . last_event_count . 0 . clone ( ) , & self . events ) . len ( )
288
351
}
289
352
290
353
/// Determines if are any events available to be read without consuming any.
@@ -405,35 +468,14 @@ impl<T: Event> Events<T> {
405
468
/// between the last `update()` call and your call to `iter_current_update_events`.
406
469
/// If events happen outside that window, they will not be handled. For example, any events that
407
470
/// happen after this call and before the next `update()` call will be dropped.
408
- pub fn iter_current_update_events ( & self ) -> impl DoubleEndedIterator < Item = & T > {
471
+ pub fn iter_current_update_events (
472
+ & self ,
473
+ ) -> impl DoubleEndedIterator < Item = & T > + ExactSizeIterator < Item = & T > {
409
474
match self . state {
410
475
State :: A => self . events_a . iter ( ) . map ( map_instance_event) ,
411
476
State :: B => self . events_b . iter ( ) . map ( map_instance_event) ,
412
477
}
413
478
}
414
-
415
- /// Determines how many events are in the reader after the given `last_event_count` parameter
416
- fn event_reader_len ( & self , last_event_count : usize ) -> usize {
417
- let a_count = if last_event_count <= self . a_start_event_count {
418
- self . events_a . len ( )
419
- } else {
420
- self . events_a
421
- . len ( )
422
- . checked_sub ( last_event_count - self . a_start_event_count )
423
- . unwrap_or_default ( )
424
- } ;
425
-
426
- let b_count = if last_event_count <= self . b_start_event_count {
427
- self . events_b . len ( )
428
- } else {
429
- self . events_b
430
- . len ( )
431
- . checked_sub ( last_event_count - self . b_start_event_count )
432
- . unwrap_or_default ( )
433
- } ;
434
-
435
- a_count + b_count
436
- }
437
479
}
438
480
439
481
impl < T > std:: iter:: Extend < T > for Events < T > {
@@ -651,6 +693,21 @@ mod tests {
651
693
assert ! ( !events. get_reader( ) . is_empty( & events) ) ;
652
694
}
653
695
696
+ #[ test]
697
+ fn test_event_iter_len_updated ( ) {
698
+ let mut events = Events :: < TestEvent > :: default ( ) ;
699
+ events. send ( TestEvent { i : 0 } ) ;
700
+ events. send ( TestEvent { i : 1 } ) ;
701
+ events. send ( TestEvent { i : 2 } ) ;
702
+ let mut reader = events. get_reader ( ) ;
703
+ let mut iter = reader. iter ( & events) ;
704
+ assert_eq ! ( iter. len( ) , 3 ) ;
705
+ iter. next ( ) ;
706
+ assert_eq ! ( iter. len( ) , 2 ) ;
707
+ iter. next_back ( ) ;
708
+ assert_eq ! ( iter. len( ) , 1 ) ;
709
+ }
710
+
654
711
#[ test]
655
712
fn test_event_reader_len_current ( ) {
656
713
let mut events = Events :: < TestEvent > :: default ( ) ;
0 commit comments