Trait ordered_iter::OrderedMapIterator

pub trait OrderedMapIterator: Iterator<Item = (Self::Key, Self::Val)> + Sized {
    type Key;
    type Val;
    fn inner_join_map<I>(self, map: I) -> InnerJoinMap<Self, I>
    where
        I: OrderedMapIterator<Key = Self::Key>,
    { ... }
    fn inner_join_set<I>(self, set: I) -> InnerJoinMapSet<Self, I>
    where
        I: OrderedSetIterator<Item = Self::Key>,
    { ... }
    fn outer_join<I>(self, other: I) -> OuterJoin<Self, I>
    where
        I: OrderedMapIterator<Key = Self::Key>,
    { ... }
}

Allows an iterator to do an inner join with another iterator to combine their values or filter based on their keys.

This trait is applied to an iterator over a map-like structure.

Associated Types

type Key

type Val

Provided Methods

Important traits for InnerJoinMap<A, B>

impl<A, B> Iterator for InnerJoinMap<A, B> where
    A: OrderedMapIterator,
    B: OrderedMapIterator<Key = A::Key>,
    A::Key: Ord,  type Item = (A::Key, (A::Val, B::Val));

fn inner_join_map<I>(self, map: I) -> InnerJoinMap<Self, I> where
    I: OrderedMapIterator<Key = Self::Key>, 

Joins two ordered maps together.

Important traits for InnerJoinMapSet<MapIter, SetIter>

impl<MapIter, SetIter> Iterator for InnerJoinMapSet<MapIter, SetIter> where
    SetIter: OrderedSetIterator,
    MapIter: OrderedMapIterator<Key = SetIter::Item>,
    MapIter::Key: Ord,  type Item = (MapIter::Key, MapIter::Val);

fn inner_join_set<I>(self, set: I) -> InnerJoinMapSet<Self, I> where
    I: OrderedSetIterator<Item = Self::Key>, 

Filters an ordered map with an ordered set.

Important traits for OuterJoin<A, B>

impl<A, B> Iterator for OuterJoin<A, B> where
    A: OrderedMapIterator,
    B: OrderedMapIterator<Key = A::Key>,
    A::Key: Ord + Eq,  type Item = (A::Key, (Option<A::Val>, Option<B::Val>));

fn outer_join<I>(self, other: I) -> OuterJoin<Self, I> where
    I: OrderedMapIterator<Key = Self::Key>, 

Joins an ordered iterator with another ordered iterator.

The new iterator will return a key-value pair for every key in either iterator. If a key is present in both iterators, they will be returned together (two values). If a value is in other but not self, it will be returned without the value in self. If the value is in self but not other, it will be returned without the value from other.

Implementations on Foreign Types

impl<'a, K: Ord, V> OrderedMapIterator for Iter<'a, K, V>

type Key = &'a K

type Val = &'a V

Important traits for InnerJoinMap<A, B>

impl<A, B> Iterator for InnerJoinMap<A, B> where
    A: OrderedMapIterator,
    B: OrderedMapIterator<Key = A::Key>,
    A::Key: Ord,  type Item = (A::Key, (A::Val, B::Val));

fn inner_join_map<I>(self, map: I) -> InnerJoinMap<Self, I> where
    I: OrderedMapIterator<Key = Self::Key>, 

Important traits for InnerJoinMapSet<MapIter, SetIter>

impl<MapIter, SetIter> Iterator for InnerJoinMapSet<MapIter, SetIter> where
    SetIter: OrderedSetIterator,
    MapIter: OrderedMapIterator<Key = SetIter::Item>,
    MapIter::Key: Ord,  type Item = (MapIter::Key, MapIter::Val);

fn inner_join_set<I>(self, set: I) -> InnerJoinMapSet<Self, I> where
    I: OrderedSetIterator<Item = Self::Key>, 

Important traits for OuterJoin<A, B>

impl<A, B> Iterator for OuterJoin<A, B> where
    A: OrderedMapIterator,
    B: OrderedMapIterator<Key = A::Key>,
    A::Key: Ord + Eq,  type Item = (A::Key, (Option<A::Val>, Option<B::Val>));

fn outer_join<I>(self, other: I) -> OuterJoin<Self, I> where
    I: OrderedMapIterator<Key = Self::Key>, 

impl<K: Ord, V> OrderedMapIterator for IntoIter<K, V>

type Key = K

type Val = V

Important traits for InnerJoinMap<A, B>

impl<A, B> Iterator for InnerJoinMap<A, B> where
    A: OrderedMapIterator,
    B: OrderedMapIterator<Key = A::Key>,
    A::Key: Ord,  type Item = (A::Key, (A::Val, B::Val));

fn inner_join_map<I>(self, map: I) -> InnerJoinMap<Self, I> where
    I: OrderedMapIterator<Key = Self::Key>, 

Important traits for InnerJoinMapSet<MapIter, SetIter>

impl<MapIter, SetIter> Iterator for InnerJoinMapSet<MapIter, SetIter> where
    SetIter: OrderedSetIterator,
    MapIter: OrderedMapIterator<Key = SetIter::Item>,
    MapIter::Key: Ord,  type Item = (MapIter::Key, MapIter::Val);

fn inner_join_set<I>(self, set: I) -> InnerJoinMapSet<Self, I> where
    I: OrderedSetIterator<Item = Self::Key>, 

Important traits for OuterJoin<A, B>

impl<A, B> Iterator for OuterJoin<A, B> where
    A: OrderedMapIterator,
    B: OrderedMapIterator<Key = A::Key>,
    A::Key: Ord + Eq,  type Item = (A::Key, (Option<A::Val>, Option<B::Val>));

fn outer_join<I>(self, other: I) -> OuterJoin<Self, I> where
    I: OrderedMapIterator<Key = Self::Key>, 

impl<'a, K: Ord, V> OrderedMapIterator for IterMut<'a, K, V>

type Key = &'a K

type Val = &'a mut V

Important traits for InnerJoinMap<A, B>

impl<A, B> Iterator for InnerJoinMap<A, B> where
    A: OrderedMapIterator,
    B: OrderedMapIterator<Key = A::Key>,
    A::Key: Ord,  type Item = (A::Key, (A::Val, B::Val));

fn inner_join_map<I>(self, map: I) -> InnerJoinMap<Self, I> where
    I: OrderedMapIterator<Key = Self::Key>, 

Important traits for InnerJoinMapSet<MapIter, SetIter>

impl<MapIter, SetIter> Iterator for InnerJoinMapSet<MapIter, SetIter> where
    SetIter: OrderedSetIterator,
    MapIter: OrderedMapIterator<Key = SetIter::Item>,
    MapIter::Key: Ord,  type Item = (MapIter::Key, MapIter::Val);

fn inner_join_set<I>(self, set: I) -> InnerJoinMapSet<Self, I> where
    I: OrderedSetIterator<Item = Self::Key>, 

Important traits for OuterJoin<A, B>

impl<A, B> Iterator for OuterJoin<A, B> where
    A: OrderedMapIterator,
    B: OrderedMapIterator<Key = A::Key>,
    A::Key: Ord + Eq,  type Item = (A::Key, (Option<A::Val>, Option<B::Val>));

fn outer_join<I>(self, other: I) -> OuterJoin<Self, I> where
    I: OrderedMapIterator<Key = Self::Key>, 

impl<'a, V> OrderedMapIterator for Iter<'a, V>

type Key = usize

type Val = &'a V

Important traits for InnerJoinMap<A, B>

impl<A, B> Iterator for InnerJoinMap<A, B> where
    A: OrderedMapIterator,
    B: OrderedMapIterator<Key = A::Key>,
    A::Key: Ord,  type Item = (A::Key, (A::Val, B::Val));

fn inner_join_map<I>(self, map: I) -> InnerJoinMap<Self, I> where
    I: OrderedMapIterator<Key = Self::Key>, 

Important traits for InnerJoinMapSet<MapIter, SetIter>

impl<MapIter, SetIter> Iterator for InnerJoinMapSet<MapIter, SetIter> where
    SetIter: OrderedSetIterator,
    MapIter: OrderedMapIterator<Key = SetIter::Item>,
    MapIter::Key: Ord,  type Item = (MapIter::Key, MapIter::Val);

fn inner_join_set<I>(self, set: I) -> InnerJoinMapSet<Self, I> where
    I: OrderedSetIterator<Item = Self::Key>, 

Important traits for OuterJoin<A, B>

impl<A, B> Iterator for OuterJoin<A, B> where
    A: OrderedMapIterator,
    B: OrderedMapIterator<Key = A::Key>,
    A::Key: Ord + Eq,  type Item = (A::Key, (Option<A::Val>, Option<B::Val>));

fn outer_join<I>(self, other: I) -> OuterJoin<Self, I> where
    I: OrderedMapIterator<Key = Self::Key>, 

Implementors

• impl<A, B> OrderedMapIterator for InnerJoinMap<A, B> where
    A: OrderedMapIterator,
    B: OrderedMapIterator<Key = A::Key>,
    A::Key: Ord,  type Key = A::Key; type Val = (A::Val, B::Val);
• impl<A, B> OrderedMapIterator for InnerJoinMapSet<A, B> where
    A: OrderedMapIterator,
    B: OrderedSetIterator<Item = A::Key>,
    A::Key: Ord,  type Key = A::Key; type Val = A::Val;
• impl<A, B> OrderedMapIterator for OuterJoin<A, B> where
    A: OrderedMapIterator,
    B: OrderedMapIterator<Key = A::Key>,
    A::Key: Ord,  type Key = A::Key; type Val = (Option<A::Val>, Option<B::Val>);