dioxus_lazy/
lazy.rs

1use crate::{factory, use_lazy, use_lazy_async, UseLazy, UseLazyAsync};
2use dioxus::prelude::*;
3use futures::Future;
4use std::{collections::VecDeque, ops::Range};
5
6pub trait Values: Clone {
7    type Value;
8
9    fn values(&self) -> Signal<VecDeque<Self::Value>>;
10
11    fn set(&mut self, range: Range<usize>);
12
13    fn refresh(&mut self);
14}
15
16pub trait Lazy {
17    type Value;
18    type Values: Values<Value = Self::Value>;
19
20    fn values(self) -> Self::Values;
21}
22
23pub fn from_fn<F, V>(f: F) -> FromFn<F>
24where
25    F: FnMut(usize) -> V + 'static,
26    V: 'static,
27{
28    FromFn { f }
29}
30
31#[derive(Clone)]
32pub struct FromFn<F> {
33    f: F,
34}
35
36impl<F, V> Lazy for FromFn<F>
37where
38    F: FnMut(usize) -> V + 'static,
39    V: 'static,
40{
41    type Value = V;
42    type Values = UseLazy<Box<dyn FnMut(Range<usize>, bool) -> std::vec::IntoIter<V>>, V>;
43
44    fn values(mut self) -> Self::Values {
45        use_lazy(Box::new(move |range, is_rev| {
46            let mut values = Vec::new();
47            if is_rev {
48                for idx in range.rev() {
49                    values.push((self.f)(idx))
50                }
51            } else {
52                for idx in range {
53                    values.push((self.f)(idx))
54                }
55            }
56
57            values.into_iter()
58        }))
59    }
60}
61
62pub struct FromRangeFn<F> {
63    f: F,
64}
65
66impl<F, I, V> Lazy for FromRangeFn<F>
67where
68    F: FnMut(Range<usize>, bool) -> I + 'static,
69    I: IntoIterator<Item = V>,
70    V: 'static,
71{
72    type Value = V;
73    type Values = UseLazy<F, V>;
74
75    fn values(self) -> Self::Values {
76        use_lazy(self.f)
77    }
78}
79
80pub fn from_async_fn<F, Fut, V>(f: F) -> FromAsyncFn<F>
81where
82    F: Fn(usize) -> Fut + Clone + 'static,
83    Fut: Future<Output = V> + 'static,
84    V: 'static,
85{
86    FromAsyncFn { f }
87}
88
89#[derive(Clone, Copy)]
90pub struct FromAsyncFn<F> {
91    f: F,
92}
93
94impl<F, Fut, V> Lazy for FromAsyncFn<F>
95where
96    F: Fn(usize) -> Fut + Clone + 'static,
97    Fut: Future<Output = V> + 'static,
98    V: 'static,
99{
100    type Value = V;
101    type Values = UseLazyAsync<V>;
102
103    fn values(self) -> Self::Values {
104        use_lazy_async(factory::from_fn(self.f))
105    }
106}
107
108pub fn from_async_range_fn<F, Fut, I, V>(f: F) -> FromAsyncRangeFn<F>
109where
110    F: Fn(Range<usize>, bool) -> Fut + Clone + 'static,
111    Fut: Future<Output = I> + 'static,
112    I: IntoIterator<Item = V>,
113    V: 'static,
114{
115    FromAsyncRangeFn { f }
116}
117
118#[derive(Clone, Copy)]
119pub struct FromAsyncRangeFn<F> {
120    f: F,
121}
122
123impl<F, Fut, I, V> Lazy for FromAsyncRangeFn<F>
124where
125    F: Fn(Range<usize>, bool) -> Fut + Clone + 'static,
126    Fut: Future<Output = I> + 'static,
127    I: IntoIterator<Item = V>,
128    V: 'static,
129{
130    type Value = V;
131    type Values = UseLazyAsync<V>;
132
133    fn values(self) -> Self::Values {
134        use_lazy_async(factory::from_range_fn(self.f))
135    }
136}
dioxus_lazy/lazy.rs

dioxus_lazy/
lazy.rs
