Struct FnFetch 

pub struct FnFetch<F> { /* private fields */ }

Implementations

impl<F: FetchFn> FnFetch<F>

pub fn new(fetch: F) -> Self

pub async fn fetch(&self) -> Result<F::T>

Trait Implementations

impl<F: FetchFn<T: Traversible>> Fetch for FnFetch<F>

type T = <F as FetchFn>::T

Fetched object.

fn fetch(&self) -> FailFuture<'_, Self::T>

Main traversal method.

fn try_fetch_local(&self) -> Result<Option<Self::T>>

Attempt to fetch the object locally.

fn fetch_local(&self) -> Option<Self::T>

Fetch locally if possible. Typically this is just Fetch::get+Clone::clone.

fn get(&self) -> Option<&Self::T>

Get a reference to a locally stored object.

fn get_mut(&mut self) -> Option<&mut Self::T>

Get a mutable reference to a locally stored object.

fn get_mut_finalize(&mut self)

Restore the inner state after mutations completed (for example, [Hash] of what’s stored).

fn try_unwrap(self: Arc<Self>) -> Option<Self::T>

Attempt unwrapping the object stored locally.

fn into_dyn_fetch<'a>(self) -> Arc<dyn Fetch<T = Self::T> + 'a>

where Self: 'a + Sized,

Convenience method to force a conversion to a trait object.

impl<F: FetchFn<T: Traversible>> FetchBytes for FnFetch<F>

fn fetch_bytes(&self) -> FailFuture<'_, ByteNode>

Central method for traversal of [Hash]-based pointers. Returns byte data and Resolve for use in Parse.

fn fetch_data(&self) -> FailFuture<'_, Vec<u8>>

Only fetch data.

fn fetch_bytes_local(&self) -> Result<Option<ByteNode>>

Attempt to fetch a node as if it’s local. Returns None if it’s not known to be local.

fn fetch_data_local(&self) -> Option<Vec<u8>>

Returns data if it’s local and trivially/infallibly available.

fn as_inner(&self) -> Option<&dyn Any>

Reduce to some known grounded value, preferably one implementing FetchBytes. Typically, this is addressed::AddressedBytes.

fn as_resolve(&self) -> Option<&Arc<dyn Resolve>>

Generalisation of FetchBytes::as_inner where we’re only interested in the Resolve component.

fn try_unwrap_resolve(self: Arc<Self>) -> Option<Arc<dyn Resolve>>

Attempt unwrapping a Resolve. Should be implemented when possible, as it’s use for some anti-stack-overflow machinery.