Struct hdk::prelude::ChainFilter

pub struct ChainFilter<H = HoloHash<Action>>
where
    H: Eq + Ord + Hash,
{
    pub chain_top: H,
    pub filters: ChainFilters<H>,
    pub include_cached_entries: bool,
}

Filter source chain items. Starting from some chain position given as an ActionHash the chain is walked backwards to genesis. The filter can stop early by specifying the number of chain items to take and / or an ActionHash to consume until.

Fields

chain_top: H

The starting position of the filter.

filters: ChainFilters<H>

The filters that have been applied. Defaults to ChainFilters::ToGenesis.

include_cached_entries: bool

Should the query return any entries that are cached at the agent activity to save network hops.

Implementations

impl<H> ChainFilter<H>

where H: Eq + Ord + Hash,

pub fn new(chain_top: H) -> ChainFilter<H>

Create a new filter using this ActionHash as the starting position and walking the chain towards the genesis Action.

pub fn take(self, n: u32) -> ChainFilter<H>

Take up to n actions including the starting position. This may return less then n actions.

pub fn include_cached_entries(self) -> ChainFilter<H>

Set this filter to include any cached entries at the agent activity authority.

pub fn until(self, action_hash: H) -> ChainFilter<H>

Take all actions until this action hash is found. Note that all actions specified as until hashes must be found so this filter can produce deterministic results. It is invalid to specify an until hash that is on a different fork then the starting position.

pub fn get_until(&self) -> Option<&HashSet<H>>

Get the until hashes if there are any.

pub fn get_take(&self) -> Option<u32>

Get the take number if there is one.

Trait Implementations

impl<H> Clone for ChainFilter<H>

where H: Clone + Eq + Ord + Hash,

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<H> Debug for ChainFilter<H>

where H: Debug + Eq + Ord + Hash,

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

Formats the value using the given formatter.

impl<'de, H> Deserialize<'de> for ChainFilter<H>

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

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<H> Hash for ChainFilter<H>

where H: Hash + Eq + Ord,

fn hash<__H>(&self, state: &mut __H)

where __H: 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 for ChainFilter<H>

where H: PartialEq + Eq + Ord + Hash,

fn eq(&self, other: &ChainFilter<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 ChainFilter<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 TryFrom<&ChainFilter> for SerializedBytes

type Error = SerializedBytesError

The type returned in the event of a conversion error.

fn try_from(t: &ChainFilter) -> Result<SerializedBytes, SerializedBytesError>

Performs the conversion.

impl TryFrom<ChainFilter> for SerializedBytes

type Error = SerializedBytesError

The type returned in the event of a conversion error.

fn try_from(t: ChainFilter) -> Result<SerializedBytes, SerializedBytesError>

Performs the conversion.

impl TryFrom<SerializedBytes> for ChainFilter

type Error = SerializedBytesError

The type returned in the event of a conversion error.

fn try_from(sb: SerializedBytes) -> Result<ChainFilter, SerializedBytesError>

Performs the conversion.

impl<H> Eq for ChainFilter<H>

where H: Eq + Ord + Hash,

impl<H> StructuralPartialEq for ChainFilter<H>

where H: Eq + Ord + Hash,