Struct nested_containment_list::IterElement

pub struct IterElement<R, T> where
    R: RangeBounds<T>,
    T: Ord,  {
    pub value: R,
    /* private fields */
}

An element obtained from Iter.

This element allows access to its value, as well as providing an Iterator over all values nested within value through the sublist() method.

Example

use nested_containment_list::NestedContainmentList;
use std::iter::FromIterator;

let nclist = NestedContainmentList::from_iter(vec![1..2]);

let mut iter = nclist.into_iter();
assert_eq!(iter.next().unwrap().value, 1..2);

Fields

value: R

Implementations

impl<R, T> IterElement<R, T> where
    R: RangeBounds<T>,
    T: Ord, 

pub fn sublist(self) -> Iter<R, T>

Returns an Iter Iterator over this element’s sublist.

Note that this method consumes the IterElement.

Example

use nested_containment_list::NestedContainmentList;
use std::iter::FromIterator;

let nclist = NestedContainmentList::from_iter(vec![1..4, 2..3]);

let mut iter = nclist.into_iter();
let mut sublist = iter.next().unwrap().sublist();
assert_eq!(sublist.next().unwrap().value, 2..3);

Trait Implementations

impl<R: Debug, T: Debug> Debug for IterElement<R, T> where
    R: RangeBounds<T>,
    T: Ord, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<R, T> IntoIterator for IterElement<R, T> where
    R: RangeBounds<T>,
    T: Ord, 

fn into_iter(self) -> Self::IntoIter

Returns an Iterator over this element’s value, followed by its sublist().

This is useful if you want to iterate over all values including the enclosing value.

Example

use nested_containment_list::NestedContainmentList;
use std::iter::FromIterator;

let nclist = NestedContainmentList::from_iter(vec![1..4, 2..3]);
let mut iter = nclist.into_iter();
let first_element = iter.next().unwrap();
let mut first_element_iter = first_element.into_iter();

assert_eq!(first_element_iter.next().unwrap().value, 1..4);
assert_eq!(first_element_iter.next().unwrap().value, 2..3);

type Item = Self

The type of the elements being iterated over.

type IntoIter = Chain<Once<Self::Item>, Iter<R, T>>

Which kind of iterator are we turning this into?