Trait zenoh_keyexpr::keyexpr_tree::traits::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

Object Safety

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

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

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

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

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

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

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

where Self: 'a,

type IterMut<'a> = IterMut<'a, T> 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)

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

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

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

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

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

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

type InclusionMut<'a> = FilterMap<IterMut<'a, T>, Inclusion<'a>> where Self: 'a, Self::Node: '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

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

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

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

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

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

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

where Self: 'a,

type IterMut<'a> = ValuesMut<'a, OwnedKeyExpr, T> 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)

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

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

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

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

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

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

type InclusionMut<'a> = FilterMap<IterMut<'a, OwnedKeyExpr, T>, Inclusion<'a>> where Self: 'a, Self::Node: '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

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

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

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

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

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

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

where Self: 'a,

type IterMut<'a> = IterMut<'a, T> 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)

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

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

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

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

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

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

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

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

Implementors