Trait IChildren 

pub trait IChildren<T: ?Sized> {
    type Node: HasChunk + AsNode<T> + AsNodeMut<T>;
    type Entry<'a, 'b>: IEntry<'a, 'b, T>
       where Self: 'a,
             T: 'b,
             'a: 'b;
    type Iter<'a>: Iterator<Item = &'a Self::Node>
       where Self: 'a,
             Self::Node: 'a;
    type IterMut<'a>: Iterator<Item = &'a mut Self::Node>
       where Self: 'a,
             Self::Node: 'a;
    type Intersection<'a>: Iterator<Item = &'a Self::Node>
       where Self: 'a,
             Self::Node: 'a;
    type IntersectionMut<'a>: Iterator<Item = &'a mut Self::Node>
       where Self: 'a,
             Self::Node: 'a;
    type Inclusion<'a>: Iterator<Item = &'a Self::Node>
       where Self: 'a,
             Self::Node: 'a;
    type InclusionMut<'a>: Iterator<Item = &'a mut Self::Node>
       where Self: 'a,
             Self::Node: 'a;

    // Required methods
    fn len(&self) -> usize;
    fn child_at<'a>(&'a self, chunk: &keyexpr) -> Option<&'a Self::Node>;
    fn child_at_mut<'a>(
        &'a mut self,
        chunk: &keyexpr,
    ) -> Option<&'a mut Self::Node>;
    fn remove(&mut self, chunk: &keyexpr) -> Option<Self::Node>;
    fn entry<'a, 'b>(&'a mut self, chunk: &'b keyexpr) -> Self::Entry<'a, 'b>
       where Self: 'a + 'b,
             T: 'b;
    fn children<'a>(&'a self) -> Self::Iter<'a>
       where Self: 'a;
    fn children_mut<'a>(&'a mut self) -> Self::IterMut<'a>
       where Self: 'a;
    fn intersection<'a>(&'a self, key: &'a keyexpr) -> Self::Intersection<'a>;
    fn intersection_mut<'a>(
        &'a mut self,
        key: &'a keyexpr,
    ) -> Self::IntersectionMut<'a>;
    fn inclusion<'a>(&'a self, key: &'a keyexpr) -> Self::Inclusion<'a>;
    fn inclusion_mut<'a>(
        &'a mut self,
        key: &'a keyexpr,
    ) -> Self::InclusionMut<'a>;
    fn filter_out<F: FnMut(&mut T) -> bool>(&mut self, predicate: &mut F);

    // Provided method
    fn is_empty(&self) -> bool { ... }
}

Required Associated Types

type Node: HasChunk + AsNode<T> + AsNodeMut<T>

type Entry<'a, 'b>: IEntry<'a, 'b, T> where Self: 'a, T: 'b, 'a: 'b

type Iter<'a>: Iterator<Item = &'a Self::Node> where Self: 'a, Self::Node: 'a

type IterMut<'a>: Iterator<Item = &'a mut Self::Node> where Self: 'a, Self::Node: 'a

type Intersection<'a>: Iterator<Item = &'a Self::Node> where Self: 'a, Self::Node: 'a

type IntersectionMut<'a>: Iterator<Item = &'a mut Self::Node> where Self: 'a, Self::Node: 'a

type Inclusion<'a>: Iterator<Item = &'a Self::Node> where Self: 'a, Self::Node: 'a

type InclusionMut<'a>: Iterator<Item = &'a mut Self::Node> where Self: 'a, Self::Node: 'a

Required Methods

fn len(&self) -> usize

fn child_at<'a>(&'a self, chunk: &keyexpr) -> Option<&'a Self::Node>

fn child_at_mut<'a>(&'a mut self, chunk: &keyexpr) -> Option<&'a mut Self::Node>

fn remove(&mut self, chunk: &keyexpr) -> Option<Self::Node>

fn entry<'a, 'b>(&'a mut self, chunk: &'b keyexpr) -> Self::Entry<'a, 'b>

where Self: 'a + 'b, T: 'b,

fn children<'a>(&'a self) -> Self::Iter<'a>

where Self: 'a,

fn children_mut<'a>(&'a mut self) -> Self::IterMut<'a>

where Self: 'a,

fn intersection<'a>(&'a self, key: &'a keyexpr) -> Self::Intersection<'a>

fn intersection_mut<'a>( &'a mut self, key: &'a keyexpr, ) -> Self::IntersectionMut<'a>

fn inclusion<'a>(&'a self, key: &'a keyexpr) -> Self::Inclusion<'a>

fn inclusion_mut<'a>(&'a mut self, key: &'a keyexpr) -> Self::InclusionMut<'a>

fn filter_out<F: FnMut(&mut T) -> bool>(&mut self, predicate: &mut F)

Provided Methods

fn is_empty(&self) -> bool

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl<T: HasChunk + AsNode<T> + AsNodeMut<T> + 'static> IChildren<T> for Vec<T>

type Node = T

type Entry<'a, 'b> = Entry<'a, 'b, T> where Self: 'a, T: 'b, 'a: 'b

type Iter<'a> = Iter<'a, T> where Self: 'a

type IterMut<'a> = IterMut<'a, T> where Self: 'a

type Intersection<'a> = FilterMap<Iter<'a, T>, Intersection<'a>> where Self: 'a, Self::Node: 'a

type IntersectionMut<'a> = FilterMap<IterMut<'a, T>, Intersection<'a>> where Self: 'a, Self::Node: 'a

type Inclusion<'a> = FilterMap<Iter<'a, T>, Inclusion<'a>> where Self: 'a, Self::Node: 'a

type InclusionMut<'a> = FilterMap<IterMut<'a, T>, Inclusion<'a>> where Self: 'a, Self::Node: 'a

fn child_at(&self, chunk: &keyexpr) -> Option<&T>

fn child_at_mut(&mut self, chunk: &keyexpr) -> Option<&mut T>

fn remove(&mut self, chunk: &keyexpr) -> Option<Self::Node>

fn len(&self) -> usize

fn is_empty(&self) -> bool

fn entry<'a, 'b>(&'a mut self, chunk: &'b keyexpr) -> Self::Entry<'a, 'b>

where Self: 'a, T: 'b, 'a: 'b,

fn children<'a>(&'a self) -> Self::Iter<'a>

where Self: 'a,

fn children_mut<'a>(&'a mut self) -> Self::IterMut<'a>

where Self: 'a,

fn filter_out<F: FnMut(&mut T) -> bool>(&mut self, predicate: &mut F)

fn intersection<'a>(&'a self, key: &'a keyexpr) -> Self::Intersection<'a>

fn intersection_mut<'a>( &'a mut self, key: &'a keyexpr, ) -> Self::IntersectionMut<'a>

fn inclusion<'a>(&'a self, key: &'a keyexpr) -> Self::Inclusion<'a>

fn inclusion_mut<'a>(&'a mut self, key: &'a keyexpr) -> Self::InclusionMut<'a>

impl<T: HasChunk + AsNode<T> + AsNodeMut<T> + 'static, S: BuildHasher> IChildren<T> for HashMap<OwnedKeyExpr, T, S>

type Node = T

type Entry<'a, 'b> = Entry<'a, OwnedKeyExpr, T> where Self: 'a, T: 'b, 'a: 'b

type Iter<'a> = Values<'a, OwnedKeyExpr, T> where Self: 'a

type IterMut<'a> = ValuesMut<'a, OwnedKeyExpr, T> where Self: 'a

type Intersection<'a> = FilterMap<Iter<'a, OwnedKeyExpr, T>, Intersection<'a>> where Self: 'a, Self::Node: 'a

type IntersectionMut<'a> = FilterMap<IterMut<'a, OwnedKeyExpr, T>, Intersection<'a>> where Self: 'a, Self::Node: 'a

type Inclusion<'a> = FilterMap<Iter<'a, OwnedKeyExpr, T>, Inclusion<'a>> where Self: 'a, Self::Node: 'a

type InclusionMut<'a> = FilterMap<IterMut<'a, OwnedKeyExpr, T>, Inclusion<'a>> where Self: 'a, Self::Node: 'a

fn child_at(&self, chunk: &keyexpr) -> Option<&T>

fn child_at_mut(&mut self, chunk: &keyexpr) -> Option<&mut T>

fn remove(&mut self, chunk: &keyexpr) -> Option<Self::Node>

fn len(&self) -> usize

fn is_empty(&self) -> bool

fn entry<'a, 'b>(&'a mut self, chunk: &'b keyexpr) -> Self::Entry<'a, 'b>

where Self: 'a, T: 'b, 'a: 'b,

fn children<'a>(&'a self) -> Self::Iter<'a>

where Self: 'a,

fn children_mut<'a>(&'a mut self) -> Self::IterMut<'a>

where Self: 'a,

fn filter_out<F: FnMut(&mut T) -> bool>(&mut self, predicate: &mut F)

fn intersection<'a>(&'a self, key: &'a keyexpr) -> Self::Intersection<'a>

fn intersection_mut<'a>( &'a mut self, key: &'a keyexpr, ) -> Self::IntersectionMut<'a>

fn inclusion<'a>(&'a self, key: &'a keyexpr) -> Self::Inclusion<'a>

fn inclusion_mut<'a>(&'a mut self, key: &'a keyexpr) -> Self::InclusionMut<'a>

impl<T: HasChunk + AsNode<T> + AsNodeMut<T>> IChildren<T> for KeyedSet<T, ChunkExtractor>

type Node = T

type Entry<'a, 'b> = Entry<'a, T, ChunkExtractor, &'b keyexpr> where Self: 'a, T: 'b, 'a: 'b

type Iter<'a> = Iter<'a, T> where Self: 'a

type IterMut<'a> = IterMut<'a, T> where Self: 'a

type Intersection<'a> = FilterMap<Iter<'a, T>, Intersection<'a>> where Self: 'a, Self::Node: 'a

type IntersectionMut<'a> = FilterMap<IterMut<'a, T>, Intersection<'a>> where Self: 'a, Self::Node: 'a

type Inclusion<'a> = FilterMap<Iter<'a, T>, Inclusion<'a>> where Self: 'a, Self::Node: 'a

type InclusionMut<'a> = FilterMap<IterMut<'a, T>, Inclusion<'a>> where Self: 'a, Self::Node: 'a

fn child_at(&self, chunk: &keyexpr) -> Option<&T>

fn child_at_mut(&mut self, chunk: &keyexpr) -> Option<&mut T>

fn remove(&mut self, chunk: &keyexpr) -> Option<T>

fn len(&self) -> usize

fn is_empty(&self) -> bool

fn entry<'a, 'b>(&'a mut self, chunk: &'b keyexpr) -> Self::Entry<'a, 'b>

where Self: 'a, T: 'b, 'a: 'b,

fn children<'a>(&'a self) -> Self::Iter<'a>

where Self: 'a,

fn children_mut<'a>(&'a mut self) -> Self::IterMut<'a>

where Self: 'a,

fn filter_out<F: FnMut(&mut T) -> bool>(&mut self, predicate: &mut F)

fn intersection<'a>(&'a self, key: &'a keyexpr) -> Self::Intersection<'a>

fn intersection_mut<'a>( &'a mut self, key: &'a keyexpr, ) -> Self::IntersectionMut<'a>

fn inclusion<'a>(&'a self, key: &'a keyexpr) -> Self::Inclusion<'a>

fn inclusion_mut<'a>(&'a mut self, key: &'a keyexpr) -> Self::InclusionMut<'a>

Implementors