Struct ArcResource

pub struct ArcResource<T, Ser = JsonSerdeCodec> { /* private fields */ }

A reference-counted asynchronous resource.

Resources allow asynchronously loading data and serializing it from the server to the client, so that it loads on the server, and is then deserialized on the client. This improves performance by beginning data loading on the server when the request is made, rather than beginning it on the client after WASM has been loaded.

You can access the value of the resource either synchronously using .get() or asynchronously using .await.

Implementations

impl<T, Ser> ArcResource<T, Ser>

where Ser: Encoder<T> + Decoder<T>, <Ser as Encoder<T>>::Error: Debug, <Ser as Decoder<T>>::Error: Debug, <<Ser as Decoder<T>>::Encoded as FromEncodedStr>::DecodingError: Debug, <Ser as Encoder<T>>::Encoded: IntoEncodedString, <Ser as Decoder<T>>::Encoded: FromEncodedStr,

pub fn new_with_options<S, Fut>( source: impl Fn() -> S + Send + Sync + 'static, fetcher: impl Fn(S) -> Fut + Send + Sync + 'static, blocking: bool, ) -> ArcResource<T, Ser>

where S: PartialEq + Clone + Send + Sync + 'static, T: Send + Sync + 'static, Fut: Future<Output = T> + Send + 'static,

Creates a new resource with the encoding Ser.

This takes a source function and a fetcher. The resource memoizes and reactively tracks the value returned by source. Whenever that value changes, it will run the fetcher to generate a new Future to load data.

On creation, if you are on the server, this will run the fetcher once to generate a Future whose value will be serialized from the server to the client. If you are on the client, the initial value will be deserialized without re-running that async task.

If blocking is true, this is a blocking resource.

Blocking resources prevent any of the HTTP response from being sent until they have loaded. This is useful if you need their data to set HTML document metadata or information that needs to appear in HTTP headers.

pub fn map<U>(&self, f: impl FnOnce(&T) -> U) -> Option<U>

where T: Send + Sync + 'static,

Synchronously, reactively reads the current value of the resource and applies the function f to its value if it is Some(_).

pub fn refetch(&self)

Re-runs the async function with the current source data.

impl<T, E, Ser> ArcResource<Result<T, E>, Ser>

where Ser: Encoder<Result<T, E>> + Decoder<Result<T, E>>, <Ser as Encoder<Result<T, E>>>::Error: Debug, <Ser as Decoder<Result<T, E>>>::Error: Debug, <<Ser as Decoder<Result<T, E>>>::Encoded as FromEncodedStr>::DecodingError: Debug, <Ser as Encoder<Result<T, E>>>::Encoded: IntoEncodedString, <Ser as Decoder<Result<T, E>>>::Encoded: FromEncodedStr, T: Send + Sync + 'static, E: Send + Sync + Clone + 'static,

pub fn and_then<U>(&self, f: impl FnOnce(&T) -> U) -> Option<Result<U, E>>

Applies the given function when a resource that returns Result<T, E> has resolved and loaded an Ok(_), rather than requiring nested .map() calls over the Option<Result<_, _>> returned by the resource.

This is useful when used with features like server functions, in conjunction with <ErrorBoundary/> and <Suspense/>, when these other components are left to handle the None and Err(_) states.

impl<T> ArcResource<T>

where JsonSerdeCodec: Encoder<T> + Decoder<T>, <JsonSerdeCodec as Encoder<T>>::Error: Debug, <JsonSerdeCodec as Decoder<T>>::Error: Debug, <<JsonSerdeCodec as Decoder<T>>::Encoded as FromEncodedStr>::DecodingError: Debug, <JsonSerdeCodec as Encoder<T>>::Encoded: IntoEncodedString, <JsonSerdeCodec as Decoder<T>>::Encoded: FromEncodedStr,

pub fn new<S, Fut>( source: impl Fn() -> S + Send + Sync + 'static, fetcher: impl Fn(S) -> Fut + Send + Sync + 'static, ) -> ArcResource<T>

where S: PartialEq + Clone + Send + Sync + 'static, T: Send + Sync + 'static, Fut: Future<Output = T> + Send + 'static,

Creates a new resource with the encoding JsonSerdeCodec.

This takes a source function and a fetcher. The resource memoizes and reactively tracks the value returned by source. Whenever that value changes, it will run the fetcher to generate a new Future to load data.

On creation, if you are on the server, this will run the fetcher once to generate a Future whose value will be serialized from the server to the client. If you are on the client, the initial value will be deserialized without re-running that async task.

pub fn new_blocking<S, Fut>( source: impl Fn() -> S + Send + Sync + 'static, fetcher: impl Fn(S) -> Fut + Send + Sync + 'static, ) -> ArcResource<T>

where S: PartialEq + Clone + Send + Sync + 'static, T: Send + Sync + 'static, Fut: Future<Output = T> + Send + 'static,

Creates a new blocking resource with the encoding JsonSerdeCodec.

This takes a source function and a fetcher. The resource memoizes and reactively tracks the value returned by source. Whenever that value changes, it will run the fetcher to generate a new Future to load data.

On creation, if you are on the server, this will run the fetcher once to generate a Future whose value will be serialized from the server to the client. If you are on the client, the initial value will be deserialized without re-running that async task.

Blocking resources prevent any of the HTTP response from being sent until they have loaded. This is useful if you need their data to set HTML document metadata or information that needs to appear in HTTP headers.

impl<T> ArcResource<T, FromToStringCodec>

where FromToStringCodec: Encoder<T> + Decoder<T>, <FromToStringCodec as Encoder<T>>::Error: Debug, <FromToStringCodec as Decoder<T>>::Error: Debug, <<FromToStringCodec as Decoder<T>>::Encoded as FromEncodedStr>::DecodingError: Debug, <FromToStringCodec as Encoder<T>>::Encoded: IntoEncodedString, <FromToStringCodec as Decoder<T>>::Encoded: FromEncodedStr,

pub fn new_str<S, Fut>( source: impl Fn() -> S + Send + Sync + 'static, fetcher: impl Fn(S) -> Fut + Send + Sync + 'static, ) -> ArcResource<T, FromToStringCodec>

where S: PartialEq + Clone + Send + Sync + 'static, T: Send + Sync + 'static, Fut: Future<Output = T> + Send + 'static,

Creates a new resource with the encoding FromToStringCodec.

This takes a source function and a fetcher. The resource memoizes and reactively tracks the value returned by source. Whenever that value changes, it will run the fetcher to generate a new Future to load data.

On creation, if you are on the server, this will run the fetcher once to generate a Future whose value will be serialized from the server to the client. If you are on the client, the initial value will be deserialized without re-running that async task.

pub fn new_str_blocking<S, Fut>( source: impl Fn() -> S + Send + Sync + 'static, fetcher: impl Fn(S) -> Fut + Send + Sync + 'static, ) -> ArcResource<T, FromToStringCodec>

where S: PartialEq + Clone + Send + Sync + 'static, T: Send + Sync + 'static, Fut: Future<Output = T> + Send + 'static,

Creates a new blocking resource with the encoding FromToStringCodec.

This takes a source function and a fetcher. The resource memoizes and reactively tracks the value returned by source. Whenever that value changes, it will run the fetcher to generate a new Future to load data.

On creation, if you are on the server, this will run the fetcher once to generate a Future whose value will be serialized from the server to the client. If you are on the client, the initial value will be deserialized without re-running that async task.

Blocking resources prevent any of the HTTP response from being sent until they have loaded. This is useful if you need their data to set HTML document metadata or information that needs to appear in HTTP headers.

impl<T, Ser> ArcResource<T, Ser>

where T: 'static,

pub fn by_ref(&self) -> AsyncDerivedRefFuture<T>

Returns a new Future that is ready when the resource has loaded, and accesses its inner value by reference.

Methods from Deref<Target = ArcAsyncDerived<T>>

pub fn ready(&self) -> AsyncDerivedReadyFuture

Returns a Future that is ready when this resource has next finished loading.

pub fn by_ref(&self) -> AsyncDerivedRefFuture<T>

Returns a Future that resolves when the computation is finished, and accesses the inner value by reference rather than by cloning it.

Trait Implementations

impl<T, Ser> Clone for ArcResource<T, Ser>

fn clone(&self) -> ArcResource<T, Ser>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T, Ser> Debug for ArcResource<T, Ser>

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

Formats the value using the given formatter.

impl<T, Ser> DefinedAt for ArcResource<T, Ser>

fn defined_at(&self) -> Option<&'static Location<'static>>

Returns the location at which the signal was defined. This is usually simply None in release mode.

impl<T, Ser> Deref for ArcResource<T, Ser>

type Target = ArcAsyncDerived<T>

The resulting type after dereferencing.

fn deref(&self) -> &<ArcResource<T, Ser> as Deref>::Target

Dereferences the value.

impl<T, Ser> From<ArcResource<T, Ser>> for Resource<T, Ser>

where T: Send + Sync,

fn from(arc_resource: ArcResource<T, Ser>) -> Resource<T, Ser>

Converts to this type from the input type.

impl<T, Ser> From<Resource<T, Ser>> for ArcResource<T, Ser>

where T: Send + Sync,

fn from(resource: Resource<T, Ser>) -> ArcResource<T, Ser>

Converts to this type from the input type.

impl<T, Ser> IntoFuture for ArcResource<T, Ser>

where T: Clone + 'static,

type Output = T

The output that the future will produce on completion.

type IntoFuture = AsyncDerivedFuture<T>

Which kind of future are we turning this into?

fn into_future(self) -> <ArcResource<T, Ser> as IntoFuture>::IntoFuture

Creates a future from a value.

impl<T, Ser> ReadUntracked for ArcResource<T, Ser>

where T: 'static,

type Value = <ArcAsyncDerived<T> as ReadUntracked>::Value

The guard type that will be returned, which can be dereferenced to the value.

fn try_read_untracked( &self, ) -> Option<<ArcResource<T, Ser> as ReadUntracked>::Value>

Returns the guard, or None if the signal has already been disposed.

fn read_untracked(&self) -> Self::Value

Returns the guard.

fn custom_try_read(&self) -> Option<Option<Self::Value>>

This is a backdoor to allow overriding the Read::try_read implementation despite it being auto implemented.

impl<T, Ser> Track for ArcResource<T, Ser>

where T: 'static,

fn track(&self)

Subscribes to this signal in the current reactive scope without doing anything with its value.