Struct dashcache::arr::CachedArr

#[repr(transparent)]pub struct CachedArr<A, P = (), H = ()> { /* fields omitted */ }

A cached array satisfying a given predicate P

Implementations

impl<A, P, H> CachedArr<A, P, H>

pub fn as_ptr(&self) -> *const A

Get the pointer to the first element of this CachedArr, or null if there is none (i.e. the slice is empty)

pub fn as_slice(&self) -> &[A]

Get the slice underlying this CachedArr

pub fn iter(&self) -> Iter<'_, A>

Iterate over the items of this CachedArr

pub fn as_arr(&self) -> &CachedArr<A, (), H>

Strip the predicate from this CachedArr

pub fn into_arr(self) -> CachedArr<A, (), H>

Strip the predicate from this CachedArr, consuming it.

pub fn coerce<Q>(self) -> CachedArr<A, Q, H>

Coerce this array into one satisfying another predicate

pub fn coerce_ref<Q>(&self) -> &CachedArr<A, Q, H>

Coerce this array as a reference into one satisfying another predicate

impl<A> CachedArr<A>

pub fn from_exact<I: ExactSizeIterator + Iterator<Item = A>>(
    iter: I
) -> CachedArr<A>

Create a new cached array from an exact length iterator

impl<A, P: EmptyPredicate> CachedArr<A, P>

pub const EMPTY: CachedArr<A, P>

Get a constant empty CachedArr

impl<A: Deref, P, H> CachedArr<A, P, H>

pub fn is_sorted(&self) -> bool

Check if this array is sorted by address

pub fn is_set(&self) -> bool

Check if this array is strictly sorted by address

pub fn try_as_bag(&self) -> Result<&CachedBag<A, H>, &Self>

Try to cast this array into a bag if sorted

pub fn try_as_set(&self) -> Result<&CachedSet<A, H>, &Self>

Try to cast this array into a set if strictly sorted

pub fn sorted(&self) -> CachedBag<A> where
    A: Clone, 

Sort this array and return it

pub fn set(&self) -> CachedSet<A> where
    A: Clone, 

Sort and deduplicate this array and return it

pub fn try_into_bag(self) -> Result<CachedBag<A, H>, Self>

Try to cast this array into a bag if sorted

pub fn try_into_set(self) -> Result<CachedSet<A, H>, Self>

Try to cast this array into a set if strictly sorted

impl<A: Deref, P: BagMarker, H> CachedArr<A, P, H>

pub fn as_bag(&self) -> &CachedBag<A, H>

Cast this array into a bag

pub fn into_bag(self) -> CachedBag<A, H>

Cast this array into a bag

impl<A: Deref, P: SetMarker, H> CachedArr<A, P, H>

pub fn as_set(&self) -> &CachedSet<A, H>

Cast this array into a set

pub fn into_set(self) -> CachedSet<A, H>

Cast this array into a set

impl<A: Deref + Clone, H> CachedArr<A, Sorted, H>

pub fn contains_impl(&self, item: *const A::Target) -> Option<&A>

Check whether an item is in this bag. If it is, return a reference.

pub fn uniq_impl(&self) -> CachedSet<A>

Deduplicate this bag into a set

impl<A: Deref + Clone> CachedArr<A, Sorted, H>

pub fn merge_impl(&self, rhs: &CachedBag<A>) -> CachedBag<A>

Merge two bags

pub fn intersect_impl(&self, rhs: &CachedBag<A>) -> CachedBag<A>

Take the intersection of two bags

impl<A: Deref + Clone, P: BagMarker, H> CachedArr<A, P, H>

pub fn contains(&self, item: *const A::Target) -> Option<&A>

Check whether an item is in this bag. If it is, return a reference.

impl<A: Deref + Clone, P: BagMarker> CachedArr<A, P>

pub fn merge<Q: BagMarker>(&self, rhs: &CachedArr<A, Q>) -> CachedBag<A>

Merge two bags

pub fn intersect<Q: BagMarker>(&self, rhs: &CachedArr<A, Q>) -> CachedArr<A, P>

Take the intersection of two bags

pub fn uniq(&self) -> CachedSet<A>

Deduplicate this bag into a set

impl<A: Deref + Clone> CachedArr<A, Uniq, H>

pub fn union_impl(&self, rhs: &CachedSet<A>) -> CachedSet<A>

Take the union of two sets

impl<A: Deref + Clone, P: SetMarker> CachedArr<A, P>

pub fn union<Q: SetMarker>(&self, rhs: &CachedArr<A, Q>) -> CachedSet<A>

Take the union of two sets

Trait Implementations

impl<A: Eq + Deref, P> Caches<[A]> for CachedArr<A, P>

fn cached(&self) -> &[A]

Get a reference to the cached value of type T

impl<A: Eq + Deref, P> CanCollect for CachedArr<A, P>

fn can_collect(&self) -> bool

Is this handle unique or, if weak references are allowed, destroyed

fn can_collect_clone(&self) -> bool

Are there two strong copies or less of this handle?

impl<A, P, H> Clone for CachedArr<A, P, H>

fn clone(&self) -> CachedArr<A, P, H>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<A, P> Debug for CachedArr<A, P> where
    A: Debug, 

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

Formats the value using the given formatter.

impl<A, P: EmptyPredicate> Default for CachedArr<A, P>

fn default() -> CachedArr<A, P>

Returns the "default value" for a type.

impl<A, P> Deref for CachedArr<A, P>

type Target = [A]

The resulting type after dereferencing.

fn deref(&self) -> &[A]

Dereferences the value.

impl<A: Deref, P, H> Eq for CachedArr<A, P, H>

impl<A: Clone, '_> From<&'_ [A]> for CachedArr<A>

fn from(v: &[A]) -> CachedArr<A>

Performs the conversion.

impl<A> From<Vec<A>> for CachedArr<A>

fn from(v: Vec<A>) -> CachedArr<A>

Performs the conversion.

impl<A> FromIterator<A> for CachedArr<A>

fn from_iter<I: IntoIterator<Item = A>>(iter: I) -> CachedArr<A>

Creates a value from an iterator.

impl<A, P> Hash for CachedArr<A, P> where
    A: Deref, 

fn hash<H: Hasher>(&self, hasher: &mut H)

Feeds this value into the given [Hasher].

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given [Hasher].

impl<A: Deref, P, Q, H> PartialEq<CachedArr<A, P, H>> for CachedArr<A, Q, H>

fn eq(&self, other: &CachedArr<A, P, H>) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.