Revision control
Copy as Markdown
Other Tools
#[cfg(feature = "boxed")]
use crate::boxed::Box;
use crate::collections::{String, Vec};
use crate::Bump;
/// A trait for types that support being constructed from an iterator, parameterized by an allocator.
pub trait FromIteratorIn<A> {
/// The allocator type
type Alloc;
/// Similar to [`FromIterator::from_iter`][from_iter], but with a given allocator.
///
///
/// ```
/// # use bumpalo::collections::{FromIteratorIn, Vec};
/// # use bumpalo::Bump;
/// #
/// let five_fives = std::iter::repeat(5).take(5);
/// let bump = Bump::new();
///
/// let v = Vec::from_iter_in(five_fives, &bump);
///
/// assert_eq!(v, [5, 5, 5, 5, 5]);
/// ```
fn from_iter_in<I>(iter: I, alloc: Self::Alloc) -> Self
where
I: IntoIterator<Item = A>;
}
#[cfg(feature = "boxed")]
impl<'bump, T> FromIteratorIn<T> for Box<'bump, [T]> {
type Alloc = &'bump Bump;
fn from_iter_in<I>(iter: I, alloc: Self::Alloc) -> Self
where
I: IntoIterator<Item = T>,
{
Box::from_iter_in(iter, alloc)
}
}
impl<'bump, T> FromIteratorIn<T> for Vec<'bump, T> {
type Alloc = &'bump Bump;
fn from_iter_in<I>(iter: I, alloc: Self::Alloc) -> Self
where
I: IntoIterator<Item = T>,
{
Vec::from_iter_in(iter, alloc)
}
}
impl<T, V: FromIteratorIn<T>> FromIteratorIn<Option<T>> for Option<V> {
type Alloc = V::Alloc;
fn from_iter_in<I>(iter: I, alloc: Self::Alloc) -> Self
where
I: IntoIterator<Item = Option<T>>,
{
iter.into_iter()
.map(|x| x.ok_or(()))
.collect_in::<Result<_, _>>(alloc)
.ok()
}
}
impl<T, E, V: FromIteratorIn<T>> FromIteratorIn<Result<T, E>> for Result<V, E> {
type Alloc = V::Alloc;
/// Takes each element in the `Iterator`: if it is an `Err`, no further
/// elements are taken, and the `Err` is returned. Should no `Err` occur, a
/// container with the values of each `Result` is returned.
///
/// Here is an example which increments every integer in a vector,
/// checking for overflow:
///
/// ```
/// # use bumpalo::collections::{FromIteratorIn, CollectIn, Vec, String};
/// # use bumpalo::Bump;
/// #
/// let bump = Bump::new();
///
/// let v = vec![1, 2, u32::MAX];
/// let res: Result<Vec<u32>, &'static str> = v.iter().take(2).map(|x: &u32|
/// x.checked_add(1).ok_or("Overflow!")
/// ).collect_in(&bump);
/// assert_eq!(res, Ok(bumpalo::vec![in ≎ 2, 3]));
///
/// let res: Result<Vec<u32>, &'static str> = v.iter().map(|x: &u32|
/// x.checked_add(1).ok_or("Overflow!")
/// ).collect_in(&bump);
/// assert_eq!(res, Err("Overflow!"));
/// ```
fn from_iter_in<I>(iter: I, alloc: Self::Alloc) -> Self
where
I: IntoIterator<Item = Result<T, E>>,
{
let mut iter = iter.into_iter();
let mut error = None;
let container = core::iter::from_fn(|| match iter.next() {
Some(Ok(x)) => Some(x),
Some(Err(e)) => {
error = Some(e);
None
}
None => None,
})
.collect_in(alloc);
match error {
Some(e) => Err(e),
None => Ok(container),
}
}
}
impl<'bump> FromIteratorIn<char> for String<'bump> {
type Alloc = &'bump Bump;
fn from_iter_in<I>(iter: I, alloc: Self::Alloc) -> Self
where
I: IntoIterator<Item = char>,
{
String::from_iter_in(iter, alloc)
}
}
/// Extension trait for iterators, in order to allow allocator-parameterized collections to be constructed more easily.
pub trait CollectIn: Iterator + Sized {
/// Collect all items from an iterator, into a collection parameterized by an allocator.
/// Similar to [`Iterator::collect`][collect].
///
///
/// ```
/// # use bumpalo::collections::{FromIteratorIn, CollectIn, Vec, String};
/// # use bumpalo::Bump;
/// #
/// let bump = Bump::new();
///
/// let str = "hello, world!".to_owned();
/// let bump_str: String = str.chars().collect_in(&bump);
/// assert_eq!(&bump_str, &str);
///
/// let nums: Vec<i32> = (0..=3).collect_in::<Vec<_>>(&bump);
/// assert_eq!(&nums, &[0,1,2,3]);
/// ```
fn collect_in<C: FromIteratorIn<Self::Item>>(self, alloc: C::Alloc) -> C {
C::from_iter_in(self, alloc)
}
}
impl<I: Iterator> CollectIn for I {}