lazy_observer/
observable.rs

1use std::borrow;
2use std::cmp::*;
3use std::fmt;
4use std::hash::*;
5use std::ops::*;
6use std::pin::Pin;
7use std::rc::Rc;
8
9use super::dirty_marker::DirtyMarker;
10use super::notify_updater;
11
12pub struct Observable<T> {
13    data: T,
14    dirty: Pin<Rc<DirtyMarker>>,
15}
16
17impl<T> Observable<T> {
18    #[inline]
19    pub fn new(data: T) -> Self {
20        Self {
21            data,
22            dirty: Rc::pin(DirtyMarker::new(false)),
23        }
24    }
25}
26
27impl<T> Drop for Observable<T> {
28    fn drop(&mut self) {
29        self.dirty.destroy();
30    }
31}
32
33impl<T> Deref for Observable<T> {
34    type Target = T;
35    #[inline]
36    fn deref(&self) -> &T {
37        notify_updater(&self.dirty);
38        &self.data
39    }
40}
41
42impl<T> DerefMut for Observable<T> {
43    #[inline]
44    fn deref_mut(&mut self) -> &mut T {
45        self.dirty.mark_connected_dirty();
46        notify_updater(&self.dirty);
47        &mut self.data
48    }
49}
50
51impl<T: PartialEq> PartialEq for Observable<T> {
52    fn eq(&self, other: &Self) -> bool {
53        self.data == other.data
54    }
55}
56
57impl<T: Eq> Eq for Observable<T> {}
58
59impl<T: PartialOrd> PartialOrd for Observable<T> {
60    #[inline]
61    fn partial_cmp(&self, other: &Observable<T>) -> Option<Ordering> {
62        PartialOrd::partial_cmp(&**self, &**other)
63    }
64    #[inline]
65    fn lt(&self, other: &Observable<T>) -> bool {
66        PartialOrd::lt(&**self, &**other)
67    }
68    #[inline]
69    fn le(&self, other: &Observable<T>) -> bool {
70        PartialOrd::le(&**self, &**other)
71    }
72    #[inline]
73    fn ge(&self, other: &Observable<T>) -> bool {
74        PartialOrd::ge(&**self, &**other)
75    }
76    #[inline]
77    fn gt(&self, other: &Observable<T>) -> bool {
78        PartialOrd::gt(&**self, &**other)
79    }
80}
81
82impl<T: Ord> Ord for Observable<T> {
83    #[inline]
84    fn cmp(&self, other: &Observable<T>) -> Ordering {
85        Ord::cmp(&**self, &**other)
86    }
87}
88
89impl<T: Hasher> Hasher for Observable<T> {
90    fn finish(&self) -> u64 {
91        (**self).finish()
92    }
93    fn write(&mut self, bytes: &[u8]) {
94        (**self).write(bytes)
95    }
96    fn write_u8(&mut self, i: u8) {
97        (**self).write_u8(i)
98    }
99    fn write_u16(&mut self, i: u16) {
100        (**self).write_u16(i)
101    }
102    fn write_u32(&mut self, i: u32) {
103        (**self).write_u32(i)
104    }
105    fn write_u64(&mut self, i: u64) {
106        (**self).write_u64(i)
107    }
108    fn write_u128(&mut self, i: u128) {
109        (**self).write_u128(i)
110    }
111    fn write_usize(&mut self, i: usize) {
112        (**self).write_usize(i)
113    }
114    fn write_i8(&mut self, i: i8) {
115        (**self).write_i8(i)
116    }
117    fn write_i16(&mut self, i: i16) {
118        (**self).write_i16(i)
119    }
120    fn write_i32(&mut self, i: i32) {
121        (**self).write_i32(i)
122    }
123    fn write_i64(&mut self, i: i64) {
124        (**self).write_i64(i)
125    }
126    fn write_i128(&mut self, i: i128) {
127        (**self).write_i128(i)
128    }
129    fn write_isize(&mut self, i: isize) {
130        (**self).write_isize(i)
131    }
132}
133
134impl<T: Hash> Hash for Observable<T> {
135    fn hash<H: Hasher>(&self, state: &mut H) {
136        (**self).hash(state);
137    }
138}
139
140impl<T> borrow::Borrow<T> for Observable<T> {
141    fn borrow(&self) -> &T {
142        &**self
143    }
144}
145
146impl<T> borrow::BorrowMut<T> for Observable<T> {
147    fn borrow_mut(&mut self) -> &mut T {
148        &mut **self
149    }
150}
151
152impl<T> AsRef<T> for Observable<T> {
153    fn as_ref(&self) -> &T {
154        &**self
155    }
156}
157
158impl<T> AsMut<T> for Observable<T> {
159    fn as_mut(&mut self) -> &mut T {
160        &mut **self
161    }
162}
163
164impl<T: Default> Default for Observable<T> {
165    fn default() -> Observable<T> {
166        Self {
167            data: Default::default(),
168            dirty: Rc::pin(DirtyMarker::new(false)),
169        }
170    }
171}
172
173impl<T: Clone> Clone for Observable<T> {
174    #[inline]
175    fn clone(&self) -> Observable<T> {
176        Self {
177            data: (**self).clone(),
178            dirty: Rc::pin(DirtyMarker::new(false)),
179        }
180    }
181}
182
183impl<T: fmt::Display> fmt::Display for Observable<T> {
184    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
185        fmt::Display::fmt(&**self, f)
186    }
187}
188
189impl<T: fmt::Debug> fmt::Debug for Observable<T> {
190    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
191        fmt::Debug::fmt(&**self, f)
192    }
193}
lazy_observer/observable.rs

lazy_observer/
observable.rs
