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, JsonSerdeCodec>

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, ) -> Self

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, ) -> Self

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, ) -> Self

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, ) -> Self

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) -> Self

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

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) -> &Self::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>) -> Self

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>) -> Self

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) -> Self::IntoFuture

Creates a future from a value.

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

where T: 'static,

fn notify(&self)

Notifies subscribers of a change in this signal.

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<Self::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.

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

where T: 'static,

type Value = Option<T>

The type of the signal’s value.

fn try_write(&self) -> Option<impl UntrackableGuard<Target = Self::Value>>

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

fn try_write_untracked(&self) -> Option<impl DerefMut<Target = Self::Value>>

or None if the signal has already been disposed.

fn write(&self) -> impl UntrackableGuard

Returns the guard.

fn write_untracked(&self) -> impl DerefMut

Returns a guard that will not notify subscribers when dropped.