bevy_defer 0.17.0

A simple asynchronous runtime for executing async coroutines.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

//! Traits for adding extension methods on asynchronous accessors to the `World` through `deref`.

use bevy::asset::Asset;
use bevy::ecs::{
    component::Component,
    query::{QueryData, QueryFilter},
    resource::Resource,
};
use std::ops::Deref;

use super::{
    AsyncAsset, AsyncComponent, AsyncEntityQuery, AsyncNonSend, AsyncQuerySingle, AsyncResource,
};

/// Add method to [`struct@AsyncComponent`] through deref.
///
/// It is recommended to derive [`RefCast`](ref_cast) for this.
pub trait AsyncComponentDeref: Component + Sized {
    type Target;
    fn async_deref(this: &AsyncComponent<Self>) -> &Self::Target;
}

impl<C> Deref for AsyncComponent<C>
where
    C: AsyncComponentDeref,
{
    type Target = <C as AsyncComponentDeref>::Target;

    fn deref(&self) -> &Self::Target {
        AsyncComponentDeref::async_deref(self)
    }
}

/// Add method to [`struct@AsyncResource`] through deref.
///
/// It is recommended to derive [`RefCast`](ref_cast) for this.
pub trait AsyncResourceDeref: Resource + Sized {
    type Target;
    fn async_deref(this: &AsyncResource<Self>) -> &Self::Target;
}

impl<C> Deref for AsyncResource<C>
where
    C: AsyncResourceDeref,
{
    type Target = <C as AsyncResourceDeref>::Target;

    fn deref(&self) -> &Self::Target {
        AsyncResourceDeref::async_deref(self)
    }
}

/// Add method to [`struct@AsyncNonSend`] through deref.
///
/// It is recommended to derive [`RefCast`](ref_cast) for this.
pub trait AsyncNonSendDeref: 'static + Sized {
    type Target;
    fn async_deref(this: &AsyncNonSend<Self>) -> &Self::Target;
}

impl<C> Deref for AsyncNonSend<C>
where
    C: AsyncNonSendDeref,
{
    type Target = <C as AsyncNonSendDeref>::Target;

    fn deref(&self) -> &Self::Target {
        AsyncNonSendDeref::async_deref(self)
    }
}

/// Add method to [`AsyncAsset`] through deref.
///
/// It is recommended to derive [`RefCast`](ref_cast) for this.
pub trait AsyncAssetDeref: Asset + Sized {
    type Target;
    fn async_deref(this: &AsyncAsset<Self>) -> &Self::Target;
}

impl<C> Deref for AsyncAsset<C>
where
    C: AsyncAssetDeref,
{
    type Target = <C as AsyncAssetDeref>::Target;

    fn deref(&self) -> &Self::Target {
        AsyncAssetDeref::async_deref(self)
    }
}

/// Add method to [`AsyncQuerySingle`] through deref.
///
/// It is recommended to derive [`RefCast`](ref_cast) for this.
pub trait AsyncQuerySingleDeref: QueryData + Sized {
    type Target<F: QueryFilter>;
    fn async_deref<F: QueryFilter>(this: &AsyncQuerySingle<Self, F>) -> &Self::Target<F>;
}

impl<C, F> Deref for AsyncQuerySingle<C, F>
where
    C: AsyncQuerySingleDeref,
    F: QueryFilter,
{
    type Target = <C as AsyncQuerySingleDeref>::Target<F>;

    fn deref(&self) -> &Self::Target {
        AsyncQuerySingleDeref::async_deref(self)
    }
}

/// Add method to [`AsyncEntityQuery`] through deref.
///
/// It is recommended to derive [`RefCast`](ref_cast) for this.
pub trait AsyncEntityQueryDeref: QueryData + Sized {
    type Target<F: QueryFilter>;
    fn async_deref<F: QueryFilter>(this: &AsyncEntityQuery<Self, F>) -> &Self::Target<F>;
}

impl<C, F> Deref for AsyncEntityQuery<C, F>
where
    C: AsyncEntityQueryDeref,
    F: QueryFilter,
{
    type Target = <C as AsyncEntityQueryDeref>::Target<F>;

    fn deref(&self) -> &Self::Target {
        AsyncEntityQueryDeref::async_deref(self)
    }
}