Struct libre_pvz_resources::cached::Cached

pub struct Cached<K, I> {
    pub raw_key: K,
    pub cached: OnceCell<I>,
}

Raw key storage with cached handle.

Fields

raw_key: K

Raw key to be serialized to the storage.

cached: OnceCell<I>

Cached shortcut version for this key.

Implementations

impl<K, I> Cached<K, I>

pub const fn new(raw_key: K) -> Self

Create a new Cached key.

pub fn get_handle_or_lazy_init<'a, C>( &self, container: impl FnOnce() -> &'a C ) -> Option<I>

where C: ContainerWithKey<Handle = I> + 'a, K: Borrow<C::Key>, I: Clone,

Get handle from a container, and cache the handle for shortcut. If the result is a Some, the handle is properly cached.

This is the lazy version of Cached::get_handle_or_init, avoiding fetching the container if the handle is already cached. This should be useful when the handle itself is used for fast comparison, especially when the container itself is behind e.g. a Handle.

pub fn get_handle_or_init<C>(&self, container: &C) -> Option<I>

where C: ContainerWithKey<Handle = I>, K: Borrow<C::Key>, I: Clone,

Get handle from a container, and cache the handle for shortcut. If the result is a Some, the handle is properly cached.

pub fn get_or_init<'a, C>(&self, container: &'a C) -> Option<&'a C::Value>

where C: ContainerWithKey<Handle = I>, K: Borrow<C::Key>, I: Clone,

Get from a container, and cache the handle for shortcut. If the result is a Some, the handle is properly cached.

impl<T: Asset> Cached<PathBuf, Handle<T>>

pub fn asset_path(&self) -> AssetPath<'_>

Get as an AssetPath for use in the asset manager.

pub fn init_handle(&self, load_context: &mut LoadContext<'_>)

Initialise and cache the handle. Panics if called more than once.

pub fn get<'a>(&self, assets: &'a Assets<T>) -> Option<&'a T>

Get the asset managed by Bevy.

pub fn get_mut<'a>(&self, assets: &'a mut Assets<T>) -> Option<&'a mut T>

Get a mutable borrow of the asset managed by Bevy.

Trait Implementations

impl<'de, K: BorrowDecode<'de>, I> BorrowDecode<'de> for Cached<K, I>

fn borrow_decode<D: BorrowDecoder<'de>>( decoder: &mut D ) -> Result<Self, DecodeError>

Attempt to decode this type with the given BorrowDecode.

impl<K: Clone, I: Clone> Clone for Cached<K, I>

fn clone(&self) -> Cached<K, I>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<K, I> Debug for Cached<K, I>

where K: Debug,

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

Formats the value using the given formatter.

impl<K: Decode, I> Decode for Cached<K, I>

fn decode<D: Decoder>(decoder: &mut D) -> Result<Self, DecodeError>

Attempt to decode this type with the given Decode.

impl<K, I> Default for Cached<K, I>

where K: Default,

fn default() -> Self

Returns the “default value” for a type.

impl<'de, K, I> Deserialize<'de> for Cached<K, I>

where K: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<K: Encode, I> Encode for Cached<K, I>

fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError>

Encode a given type.

impl<K, I> From<K> for Cached<K, I>

fn from(raw_key: K) -> Self

Converts to this type from the input type.

impl<K, I> Hash for Cached<K, I>

where K: Hash,

fn hash<__HKI>(&self, __state: &mut __HKI)

where __HKI: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<K, I> PartialEq for Cached<K, I>

where K: PartialEq,

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<K, I> Serialize for Cached<K, I>

where K: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<K, I> Eq for Cached<K, I>

where K: Eq,