Trait Fetch 

pub trait Fetch:
    Send
    + Sync
    + FetchBytes {
    type T;

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

    // Provided methods
    fn try_fetch_local(&self) -> Result<Option<Self::T>> { ... }
    fn fetch_local(&self) -> Option<Self::T> { ... }
    fn get(&self) -> Option<&Self::T> { ... }
    fn get_mut(&mut self) -> Option<&mut Self::T> { ... }
    fn get_mut_finalize(&mut self) { ... }
    fn try_unwrap(self: Arc<Self>) -> Option<Self::T> { ... }
    fn into_dyn_fetch<'a>(self) -> Arc<dyn Fetch<T = Self::T> + 'a> 
       where Self: 'a + Sized { ... }
}

Application-facing traversal.

Required Associated Types

type T

Fetched object.

Required Methods

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

Main traversal method.

Provided Methods

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

Attempt to fetch the object locally.

Generally this is either Fetch::get+Clone::clone or FetchBytes::fetch_bytes_local+Parse::parse.

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.

Fetch::get_mut_finalize must be called to restore the state even if no mutations were made.

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.

Trait Implementations

impl<T> ByteOrd for dyn Fetch<T = T> + '_

fn bytes_cmp(&self, _: &Self) -> Ordering

impl<T> Eq for dyn Fetch<T = T> + '_

impl<T> Hash for dyn Fetch<T = T> + '_

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

Feeds this value into the given Hasher.

impl<T> InlineOutput for dyn Fetch<T = T> + '_

impl<T> Ord for dyn Fetch<T = T> + '_

fn cmp(&self, _: &Self) -> Ordering

This method returns an Ordering between self and other.

impl<T> PartialEq for dyn Fetch<T = T> + '_

fn eq(&self, _: &Self) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<T> PartialOrd for dyn Fetch<T = T> + '_

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T: Tagged> Tagged for dyn Fetch<T = T> + '_

const TAGS: Tags = T::TAGS

const HASH: Hash = T::HASH

impl<T> ToOutput for dyn Fetch<T = T> + '_

Even though we refer to something, we don’t know [Hash] for it. To match correctness, we don’t implement Parse/ParseInline.

fn to_output(&self, _: &mut (impl ?Sized + Output))

Provide object’s byte representation to an Output.

fn hasher(&self) -> Sha256

Return a Sha256 hasher pre-filled with data of this object.

fn data_hash(&self) -> Hash

[Hash] of (real, i.e. serialized) data of this object.

fn mangle_hash(&self) -> Hash

“Mangle hash” of the object. This is used to introduce runtime distinction between data-identical objects similarly to compile-time Tagged::HASH.

fn output<T: FromOutput<Output: Default>>(&self) -> T

Construct an Output, possibly finalising it afterwards.

fn vec(&self) -> Vec<u8>

Collect this object’s data (serialize the object).

Dyn Compatibility

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

impl<T: Fetch + Clone> Fetch for Arc<T>

type T = <T as Fetch>::T

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

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

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

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

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

fn get_mut_finalize(&mut self)

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

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

where Self: 'a + Sized,

impl<T> Fetch for Arc<dyn SingularFetch<T = T>>

type T = T

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

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

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

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

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

where Self: 'a + Sized,

Implementors

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

type T = <F as FetchFn>::T

impl<T: FullHash, Extra: Send + Sync + ExtraFor<T>> Fetch for Addressed<T, Extra>

type T = T

impl<T: Traversible + Clone> Fetch for Local<T>

type T = T