//! This module contains the parallel iterator types for owned strings
//! (`String`). You will rarely need to interact with it directly
//! unless you have need to name one of the iterator types.

use crate::iter::plumbing::*;
use crate::math::simplify_range;
use crate::prelude::*;
use std::ops::{Range, RangeBounds};

impl<'a> ParallelDrainRange<usize> for &'a mut String {
    type Iter = Drain<'a>;
    type Item = char;

    fn par_drain<R: RangeBounds<usize>>(self, range: R) -> Self::Iter {
        Drain {
            range: simplify_range(range, self.len()),
            string: self,
        }
    }
}

/// Draining parallel iterator that moves a range of characters out of a string,
/// but keeps the total capacity.
#[derive(Debug)]
pub struct Drain<'a> {
    string: &'a mut String,
    range: Range<usize>,
}

impl<'a> ParallelIterator for Drain<'a> {
    type Item = char;

    fn drive_unindexed<C>(self, consumer: C) -> C::Result
    where
        C: UnindexedConsumer<Self::Item>,
    {
        self.string[self.range.clone()]
            .par_chars()
            .drive_unindexed(consumer)
    }
}

impl<'a> Drop for Drain<'a> {
    fn drop(&mut self) {
        // Remove the drained range.
        self.string.drain(self.range.clone());
    }
}