Struct Resource 

pub struct Resource<T: 'static> { /* private fields */ }

A handle to a reactive future spawned with use_resource that can be used to modify or read the result of the future.

Example

Reading the result of a resource:

fn App() -> Element {
    let mut revision = use_signal(|| "1d03b42");
    let mut resource = use_resource(move || async move {
        // This will run every time the revision signal changes because we read the count inside the future
        reqwest::get(format!("https://github.com/DioxusLabs/awesome-dioxus/blob/{revision}/awesome.json")).await
    });

    // Since our resource may not be ready yet, the value is an Option. Our request may also fail, so the get function returns a Result
    // The complete type we need to match is `Option<Result<String, reqwest::Error>>`
    // We can use `read_unchecked` to keep our matching code in one statement while avoiding a temporary variable error (this is still completely safe because dioxus checks the borrows at runtime)
    match &*resource.read_unchecked() {
        Some(Ok(value)) => rsx! { "{value:?}" },
        Some(Err(err)) => rsx! { "Error: {err}" },
        None => rsx! { "Loading..." },
    }
}

Implementations

impl<T> Resource<T>

pub fn restart(&mut self)

Restart the resource’s future.

This will cancel the current future and start a new one.

Example

fn App() -> Element {
    let mut revision = use_signal(|| "1d03b42");
    let mut resource = use_resource(move || async move {
        // This will run every time the revision signal changes because we read the count inside the future
        reqwest::get(format!("https://github.com/DioxusLabs/awesome-dioxus/blob/{revision}/awesome.json")).await
    });

    rsx! {
        button {
            // We can get a signal with the value of the resource with the `value` method
            onclick: move |_| resource.restart(),
            "Restart resource"
        }
        "{resource:?}"
    }
}

pub fn cancel(&mut self)

Forcefully cancel the resource’s future.

Example

fn App() -> Element {
    let mut revision = use_signal(|| "1d03b42");
    let mut resource = use_resource(move || async move {
        reqwest::get(format!("https://github.com/DioxusLabs/awesome-dioxus/blob/{revision}/awesome.json")).await
    });

    rsx! {
        button {
            // We can cancel the resource before it finishes with the `cancel` method
            onclick: move |_| resource.cancel(),
            "Cancel resource"
        }
        "{resource:?}"
    }
}

pub fn pause(&mut self)

Pause the resource’s future.

Example

fn App() -> Element {
    let mut revision = use_signal(|| "1d03b42");
    let mut resource = use_resource(move || async move {
        // This will run every time the revision signal changes because we read the count inside the future
        reqwest::get(format!("https://github.com/DioxusLabs/awesome-dioxus/blob/{revision}/awesome.json")).await
    });

    rsx! {
        button {
            // We can pause the future with the `pause` method
            onclick: move |_| resource.pause(),
            "Pause"
        }
        button {
            // And resume it with the `resume` method
            onclick: move |_| resource.resume(),
            "Resume"
        }
        "{resource:?}"
    }
}

pub fn resume(&mut self)

Resume the resource’s future.

Example

fn App() -> Element {
    let mut revision = use_signal(|| "1d03b42");
    let mut resource = use_resource(move || async move {
        // This will run every time the revision signal changes because we read the count inside the future
        reqwest::get(format!("https://github.com/DioxusLabs/awesome-dioxus/blob/{revision}/awesome.json")).await
    });

    rsx! {
        button {
            // We can pause the future with the `pause` method
            onclick: move |_| resource.pause(),
            "Pause"
        }
        button {
            // And resume it with the `resume` method
            onclick: move |_| resource.resume(),
            "Resume"
        }
        "{resource:?}"
    }
}

pub fn clear(&mut self)

Clear the resource’s value. This will just reset the value. It will not modify any running tasks.

Example

fn App() -> Element {
    let mut revision = use_signal(|| "1d03b42");
    let mut resource = use_resource(move || async move {
        // This will run every time the revision signal changes because we read the count inside the future
        reqwest::get(format!("https://github.com/DioxusLabs/awesome-dioxus/blob/{revision}/awesome.json")).await
    });

    rsx! {
        button {
            // We clear the value without modifying any running tasks with the `clear` method
            onclick: move |_| resource.clear(),
            "Clear"
        }
        "{resource:?}"
    }
}

pub fn task(&self) -> Task

Get a handle to the inner task backing this resource Modify the task through this handle will cause inconsistent state

pub fn pending(&self) -> bool

Is the resource’s future currently running?

pub fn finished(&self) -> bool

Is the resource’s future currently finished running?

Reading this does not subscribe to the future’s state

Example

fn App() -> Element {
    let mut revision = use_signal(|| "1d03b42");
    let mut resource = use_resource(move || async move {
        // This will run every time the revision signal changes because we read the count inside the future
        reqwest::get(format!("https://github.com/DioxusLabs/awesome-dioxus/blob/{revision}/awesome.json")).await
    });

    // We can use the `finished` method to check if the future is finished
    if resource.finished() {
        rsx! {
            "The resource is finished"
        }
    } else {
        rsx! {
            "The resource is still running"
        }
    }
}

pub fn state(&self) -> ReadSignal<UseResourceState>

Get the current state of the resource’s future. This method returns a ReadSignal which can be read to get the current state of the resource or passed to other hooks and components.

Example

fn App() -> Element {
    let mut revision = use_signal(|| "1d03b42");
    let mut resource = use_resource(move || async move {
        // This will run every time the revision signal changes because we read the count inside the future
        reqwest::get(format!("https://github.com/DioxusLabs/awesome-dioxus/blob/{revision}/awesome.json")).await
    });

    // We can read the current state of the future with the `state` method
    match resource.state().cloned() {
        UseResourceState::Pending => rsx! {
            "The resource is still pending"
        },
        UseResourceState::Paused => rsx! {
            "The resource has been paused"
        },
        UseResourceState::Stopped => rsx! {
            "The resource has been stopped"
        },
        UseResourceState::Ready => rsx! {
            "The resource is ready!"
        },
    }
}

pub fn value(&self) -> ReadSignal<Option<T>>

Get the current value of the resource’s future. This method returns a ReadSignal which can be read to get the current value of the resource or passed to other hooks and components.

Example

fn App() -> Element {
    let mut revision = use_signal(|| "1d03b42");
    let mut resource = use_resource(move || async move {
        // This will run every time the revision signal changes because we read the count inside the future
        reqwest::get(format!("https://github.com/DioxusLabs/awesome-dioxus/blob/{revision}/awesome.json")).await
    });

    // We can get a signal with the value of the resource with the `value` method
    let value = resource.value();

    // Since our resource may not be ready yet, the value is an Option. Our request may also fail, so the get function returns a Result
    // The complete type we need to match is `Option<Result<String, reqwest::Error>>`
    // We can use `read_unchecked` to keep our matching code in one statement while avoiding a temporary variable error (this is still completely safe because dioxus checks the borrows at runtime)
    match &*value.read_unchecked() {
        Some(Ok(value)) => rsx! { "{value:?}" },
        Some(Err(err)) => rsx! { "Error: {err}" },
        None => rsx! { "Loading..." },
    }
}

pub fn suspend(&self) -> Result<MappedSignal<T, Signal<Option<T>>>, RenderError>

Suspend the resource’s future and only continue rendering when the future is ready

impl<T, E> Resource<Result<T, E>>

pub fn result( &self, ) -> Option<Result<MappedSignal<T, Signal<Option<Result<T, E>>>>, MappedSignal<E, Signal<Option<Result<T, E>>>>>>

Convert the Resource<Result<T, E>> into an Option<Result<MappedSignal<T>, MappedSignal<E>>>

Trait Implementations

impl<T> Clone for Resource<T>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug + 'static> Debug for Resource<T>

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

Formats the value using the given formatter.

impl<T: Clone> Deref for Resource<T>

Allow calling a signal with signal() syntax

Currently only limited to copy types, though could probably specialize for string/arc/rc

type Target = dyn Fn() -> Option<T>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T> From<Resource<T>> for ReadSignal<Option<T>>

fn from(val: Resource<T>) -> Self

Converts to this type from the input type.

impl<T> Future for Resource<T>

type Output = ()

The type of value produced on completion.

fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output>

Attempts to resolve the future to a final value, registering the current task for wakeup if the value is not yet available.

impl<T> IntoAttributeValue for Resource<T>

where T: Clone + IntoAttributeValue,

fn into_value(self) -> AttributeValue

Convert into an attribute value

impl<T> IntoDynNode for Resource<T>

where T: Clone + IntoDynNode,

fn into_dyn_node(self) -> DynamicNode

Consume this item and produce a DynamicNode

impl<T> PartialEq for Resource<T>

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T> Readable for Resource<T>

type Target = Option<T>

The target type of the reference.

type Storage = UnsyncStorage

The type of the storage this readable uses.

fn try_read_unchecked(&self) -> Result<ReadableRef<'static, Self>, BorrowError>

Try to get a reference to the value without checking the lifetime. This will subscribe the current scope to the signal.

fn try_peek_unchecked(&self) -> Result<ReadableRef<'static, Self>, BorrowError>

Try to peek the current value of the signal without subscribing to updates. If the value has been dropped, this will return an error.

fn subscribers(&self) -> Subscribers

Get the underlying subscriber list for this readable. This is used to track when the value changes and notify subscribers.

impl<T> Writable for Resource<T>

type WriteMetadata = <Signal<Option<T>> as Writable>::WriteMetadata

Additional data associated with the write reference.

fn try_write_unchecked( &self, ) -> Result<WritableRef<'static, Self>, BorrowMutError>

where Self::Target: 'static,

Try to get a mutable reference to the value without checking the lifetime. This will update any subscribers.

impl<T> Copy for Resource<T>