Trait AbstractVecMap 

pub trait AbstractVecMap<K, V> {
    // Required method
    fn as_slice(&self) -> &[(K, V)];

    // Provided methods
    fn is_empty(&self) -> bool { ... }
    fn iter(&self) -> VecMapIter<Iter<'_, (K, V)>> { ... }
    fn get<Q>(&self, key: &Q) -> Option<&V>
       where K: Borrow<Q> + 'static,
             Q: Ord + ?Sized { ... }
    fn outer_join<W, R, F, A>(
        &self,
        that: &impl AbstractVecMap<K, W>,
        f: F,
    ) -> VecMap<A>
       where K: Ord + Clone,
             A: Array<Item = (K, R)>,
             F: Fn(OuterJoinArg<&K, &V, &W>) -> Option<R> { ... }
    fn left_join<W, R, F, A>(
        &self,
        that: &impl AbstractVecMap<K, W>,
        f: F,
    ) -> VecMap<A>
       where K: Ord + Clone,
             F: Fn(&K, &V, Option<&W>) -> Option<R>,
             A: Array<Item = (K, R)> { ... }
    fn right_join<W, R, F, A>(
        &self,
        that: &impl AbstractVecMap<K, W>,
        f: F,
    ) -> VecMap<A>
       where K: Ord + Clone,
             F: Fn(&K, Option<&V>, &W) -> Option<R>,
             A: Array<Item = (K, R)> { ... }
    fn inner_join<W, R, F, A>(
        &self,
        that: &impl AbstractVecMap<K, W>,
        f: F,
    ) -> VecMap<A>
       where K: Ord + Clone,
             F: Fn(&K, &V, &W) -> Option<R>,
             A: Array<Item = (K, R)> { ... }
}

An abstract vec map

this is implemented by VecMap and ArchivedVecMap, so they are interoperable.

Required Methods

fn as_slice(&self) -> &[(K, V)]

Provided Methods

fn is_empty(&self) -> bool

fn iter(&self) -> VecMapIter<Iter<'_, (K, V)>>

fn get<Q>(&self, key: &Q) -> Option<&V>

where K: Borrow<Q> + 'static, Q: Ord + ?Sized,

lookup of a mapping. Time complexity is O(log N). Binary search.

fn outer_join<W, R, F, A>( &self, that: &impl AbstractVecMap<K, W>, f: F, ) -> VecMap<A>

where K: Ord + Clone, A: Array<Item = (K, R)>, F: Fn(OuterJoinArg<&K, &V, &W>) -> Option<R>,

Perform an outer join with another VecMap, producing a new result

fn left_join<W, R, F, A>( &self, that: &impl AbstractVecMap<K, W>, f: F, ) -> VecMap<A>

where K: Ord + Clone, F: Fn(&K, &V, Option<&W>) -> Option<R>, A: Array<Item = (K, R)>,

fn right_join<W, R, F, A>( &self, that: &impl AbstractVecMap<K, W>, f: F, ) -> VecMap<A>

where K: Ord + Clone, F: Fn(&K, Option<&V>, &W) -> Option<R>, A: Array<Item = (K, R)>,

fn inner_join<W, R, F, A>( &self, that: &impl AbstractVecMap<K, W>, f: F, ) -> VecMap<A>

where K: Ord + Clone, F: Fn(&K, &V, &W) -> Option<R>, A: Array<Item = (K, R)>,

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.

Implementors

impl<K, V, A: Array<Item = (K, V)>> AbstractVecMap<K, V> for VecMap<A>