Enum hdk::prelude::dependencies::holochain_integrity_types::ChainFilters

pub enum ChainFilters<H = HoloHash<Action>>where
    H: Eq + Ord + Hash,{
    ToGenesis,
    Take(u32),
    Until(HashSet<H, RandomState>),
    Both(u32, HashSet<H, RandomState>),
}

Specify which Actions to allow through this filter.

Variants

ToGenesis

Allow all up to genesis.

Take(u32)

Take this many (inclusive of the starting position).

Until(HashSet<H, RandomState>)

Continue until one of these hashes is found.

Both(u32, HashSet<H, RandomState>)

Combination of both take and until. Whichever is the smaller set.

Trait Implementations

impl<H> Clone for ChainFilters<H>where
    H: Clone + Eq + Ord + Hash,

fn clone(&self) -> ChainFilters<H>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<H> Debug for ChainFilters<H>where
    H: Debug + Eq + Ord + Hash,

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

Formats the value using the given formatter.

impl<H> Default for ChainFilters<H>where
    H: Eq + Ord + Hash,

fn default() -> ChainFilters<H>

Returns the “default value” for a type.

impl<'de, H> Deserialize<'de> for ChainFilters<H>where
    H: Eq + Ord + Hash + Deserialize<'de>,

fn deserialize<__D>(
    __deserializer: __D
) -> Result<ChainFilters<H>, <__D as Deserializer<'de>>::Error>where
    __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<H> Hash for ChainFilters<H>where
    H: Eq + Ord + Hash,

Create a deterministic hash to compare filters.

fn hash<HH>(&self, state: &mut HH)where
    HH: Hasher,

Feeds this value into the given Hasher.

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

Feeds a slice of this type into the given Hasher.

impl<H> PartialEq<ChainFilters<H>> for ChainFilters<H>where
    H: Eq + Ord + Hash,

Implement a deterministic partial eq to compare ChainFilters.

fn eq(&self, other: &ChainFilters<H>) -> bool

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

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<H> Serialize for ChainFilters<H>where
    H: Eq + Ord + Hash + Serialize,

fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
    __S: Serializer,

Serialize this value into the given Serde serializer.

impl<H> Eq for ChainFilters<H>where
    H: Eq + Ord + Hash,

impl<H> StructuralEq for ChainFilters<H>where
    H: Eq + Ord + Hash,