1use crate::{private::Sealed, AppContext, Context, Entity, ModelContext};
2use anyhow::{anyhow, Result};
3use derive_more::{Deref, DerefMut};
4use parking_lot::{RwLock, RwLockUpgradableReadGuard};
5use slotmap::{SecondaryMap, SlotMap};
6use std::{
7 any::{type_name, Any, TypeId},
8 fmt::{self, Display},
9 hash::{Hash, Hasher},
10 marker::PhantomData,
11 mem,
12 sync::{
13 atomic::{AtomicUsize, Ordering::SeqCst},
14 Arc, Weak,
15 },
16 thread::panicking,
17};
18
19slotmap::new_key_type! { pub struct EntityId; }
20
21impl EntityId {
22 pub fn as_u64(self) -> u64 {
23 self.0.as_ffi()
24 }
25}
26
27impl Display for EntityId {
28 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
29 write!(f, "{}", self.as_u64())
30 }
31}
32
33pub(crate) struct EntityMap {
34 entities: SecondaryMap<EntityId, Box<dyn Any>>,
35 ref_counts: Arc<RwLock<EntityRefCounts>>,
36}
37
38struct EntityRefCounts {
39 counts: SlotMap<EntityId, AtomicUsize>,
40 dropped_entity_ids: Vec<EntityId>,
41}
42
43impl EntityMap {
44 pub fn new() -> Self {
45 Self {
46 entities: SecondaryMap::new(),
47 ref_counts: Arc::new(RwLock::new(EntityRefCounts {
48 counts: SlotMap::with_key(),
49 dropped_entity_ids: Vec::new(),
50 })),
51 }
52 }
53
54 /// Reserve a slot for an entity, which you can subsequently use with `insert`.
55 pub fn reserve<T: 'static>(&self) -> Slot<T> {
56 let id = self.ref_counts.write().counts.insert(1.into());
57 Slot(Model::new(id, Arc::downgrade(&self.ref_counts)))
58 }
59
60 /// Insert an entity into a slot obtained by calling `reserve`.
61 pub fn insert<T>(&mut self, slot: Slot<T>, entity: T) -> Model<T>
62 where
63 T: 'static,
64 {
65 let model = slot.0;
66 self.entities.insert(model.entity_id, Box::new(entity));
67 model
68 }
69
70 /// Move an entity to the stack.
71 #[track_caller]
72 pub fn lease<'a, T>(&mut self, model: &'a Model<T>) -> Lease<'a, T> {
73 self.assert_valid_context(model);
74 let entity = Some(self.entities.remove(model.entity_id).unwrap_or_else(|| {
75 panic!(
76 "Circular entity lease of {}. Is it already being updated?",
77 std::any::type_name::<T>()
78 )
79 }));
80 Lease {
81 model,
82 entity,
83 entity_type: PhantomData,
84 }
85 }
86
87 /// Return an entity after moving it to the stack.
88 pub fn end_lease<T>(&mut self, mut lease: Lease<T>) {
89 self.entities
90 .insert(lease.model.entity_id, lease.entity.take().unwrap());
91 }
92
93 pub fn read<T: 'static>(&self, model: &Model<T>) -> &T {
94 self.assert_valid_context(model);
95 self.entities[model.entity_id].downcast_ref().unwrap()
96 }
97
98 fn assert_valid_context(&self, model: &AnyModel) {
99 debug_assert!(
100 Weak::ptr_eq(&model.entity_map, &Arc::downgrade(&self.ref_counts)),
101 "used a model with the wrong context"
102 );
103 }
104
105 pub fn take_dropped(&mut self) -> Vec<(EntityId, Box<dyn Any>)> {
106 let mut ref_counts = self.ref_counts.write();
107 let dropped_entity_ids = mem::take(&mut ref_counts.dropped_entity_ids);
108
109 dropped_entity_ids
110 .into_iter()
111 .map(|entity_id| {
112 let count = ref_counts.counts.remove(entity_id).unwrap();
113 debug_assert_eq!(
114 count.load(SeqCst),
115 0,
116 "dropped an entity that was referenced"
117 );
118 (entity_id, self.entities.remove(entity_id).unwrap())
119 })
120 .collect()
121 }
122}
123
124pub struct Lease<'a, T> {
125 entity: Option<Box<dyn Any>>,
126 pub model: &'a Model<T>,
127 entity_type: PhantomData<T>,
128}
129
130impl<'a, T: 'static> core::ops::Deref for Lease<'a, T> {
131 type Target = T;
132
133 fn deref(&self) -> &Self::Target {
134 self.entity.as_ref().unwrap().downcast_ref().unwrap()
135 }
136}
137
138impl<'a, T: 'static> core::ops::DerefMut for Lease<'a, T> {
139 fn deref_mut(&mut self) -> &mut Self::Target {
140 self.entity.as_mut().unwrap().downcast_mut().unwrap()
141 }
142}
143
144impl<'a, T> Drop for Lease<'a, T> {
145 fn drop(&mut self) {
146 if self.entity.is_some() && !panicking() {
147 panic!("Leases must be ended with EntityMap::end_lease")
148 }
149 }
150}
151
152#[derive(Deref, DerefMut)]
153pub struct Slot<T>(Model<T>);
154
155pub struct AnyModel {
156 pub(crate) entity_id: EntityId,
157 pub(crate) entity_type: TypeId,
158 entity_map: Weak<RwLock<EntityRefCounts>>,
159}
160
161impl AnyModel {
162 fn new(id: EntityId, entity_type: TypeId, entity_map: Weak<RwLock<EntityRefCounts>>) -> Self {
163 Self {
164 entity_id: id,
165 entity_type,
166 entity_map,
167 }
168 }
169
170 pub fn entity_id(&self) -> EntityId {
171 self.entity_id
172 }
173
174 pub fn entity_type(&self) -> TypeId {
175 self.entity_type
176 }
177
178 pub fn downgrade(&self) -> AnyWeakModel {
179 AnyWeakModel {
180 entity_id: self.entity_id,
181 entity_type: self.entity_type,
182 entity_ref_counts: self.entity_map.clone(),
183 }
184 }
185
186 pub fn downcast<T: 'static>(self) -> Result<Model<T>, AnyModel> {
187 if TypeId::of::<T>() == self.entity_type {
188 Ok(Model {
189 any_model: self,
190 entity_type: PhantomData,
191 })
192 } else {
193 Err(self)
194 }
195 }
196}
197
198impl Clone for AnyModel {
199 fn clone(&self) -> Self {
200 if let Some(entity_map) = self.entity_map.upgrade() {
201 let entity_map = entity_map.read();
202 let count = entity_map
203 .counts
204 .get(self.entity_id)
205 .expect("detected over-release of a model");
206 let prev_count = count.fetch_add(1, SeqCst);
207 assert_ne!(prev_count, 0, "Detected over-release of a model.");
208 }
209
210 Self {
211 entity_id: self.entity_id,
212 entity_type: self.entity_type,
213 entity_map: self.entity_map.clone(),
214 }
215 }
216}
217
218impl Drop for AnyModel {
219 fn drop(&mut self) {
220 if let Some(entity_map) = self.entity_map.upgrade() {
221 let entity_map = entity_map.upgradable_read();
222 let count = entity_map
223 .counts
224 .get(self.entity_id)
225 .expect("detected over-release of a handle.");
226 let prev_count = count.fetch_sub(1, SeqCst);
227 assert_ne!(prev_count, 0, "Detected over-release of a model.");
228 if prev_count == 1 {
229 // We were the last reference to this entity, so we can remove it.
230 let mut entity_map = RwLockUpgradableReadGuard::upgrade(entity_map);
231 entity_map.dropped_entity_ids.push(self.entity_id);
232 }
233 }
234 }
235}
236
237impl<T> From<Model<T>> for AnyModel {
238 fn from(model: Model<T>) -> Self {
239 model.any_model
240 }
241}
242
243impl Hash for AnyModel {
244 fn hash<H: Hasher>(&self, state: &mut H) {
245 self.entity_id.hash(state);
246 }
247}
248
249impl PartialEq for AnyModel {
250 fn eq(&self, other: &Self) -> bool {
251 self.entity_id == other.entity_id
252 }
253}
254
255impl Eq for AnyModel {}
256
257impl std::fmt::Debug for AnyModel {
258 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
259 f.debug_struct("AnyModel")
260 .field("entity_id", &self.entity_id.as_u64())
261 .finish()
262 }
263}
264
265#[derive(Deref, DerefMut)]
266pub struct Model<T> {
267 #[deref]
268 #[deref_mut]
269 pub(crate) any_model: AnyModel,
270 pub(crate) entity_type: PhantomData<T>,
271}
272
273unsafe impl<T> Send for Model<T> {}
274unsafe impl<T> Sync for Model<T> {}
275impl<T> Sealed for Model<T> {}
276
277impl<T: 'static> Entity<T> for Model<T> {
278 type Weak = WeakModel<T>;
279
280 fn entity_id(&self) -> EntityId {
281 self.any_model.entity_id
282 }
283
284 fn downgrade(&self) -> Self::Weak {
285 WeakModel {
286 any_model: self.any_model.downgrade(),
287 entity_type: self.entity_type,
288 }
289 }
290
291 fn upgrade_from(weak: &Self::Weak) -> Option<Self>
292 where
293 Self: Sized,
294 {
295 Some(Model {
296 any_model: weak.any_model.upgrade()?,
297 entity_type: weak.entity_type,
298 })
299 }
300}
301
302impl<T: 'static> Model<T> {
303 fn new(id: EntityId, entity_map: Weak<RwLock<EntityRefCounts>>) -> Self
304 where
305 T: 'static,
306 {
307 Self {
308 any_model: AnyModel::new(id, TypeId::of::<T>(), entity_map),
309 entity_type: PhantomData,
310 }
311 }
312
313 /// Downgrade the this to a weak model reference
314 pub fn downgrade(&self) -> WeakModel<T> {
315 // Delegate to the trait implementation to keep behavior in one place.
316 // This method was included to improve method resolution in the presence of
317 // the Model's deref
318 Entity::downgrade(self)
319 }
320
321 /// Convert this into a dynamically typed model.
322 pub fn into_any(self) -> AnyModel {
323 self.any_model
324 }
325
326 pub fn read<'a>(&self, cx: &'a AppContext) -> &'a T {
327 cx.entities.read(self)
328 }
329
330 pub fn read_with<'a, R, C: Context>(
331 &self,
332 cx: &'a C,
333 f: impl FnOnce(&T, &AppContext) -> R,
334 ) -> C::Result<R> {
335 cx.read_model(self, f)
336 }
337
338 /// Update the entity referenced by this model with the given function.
339 ///
340 /// The update function receives a context appropriate for its environment.
341 /// When updating in an `AppContext`, it receives a `ModelContext`.
342 /// When updating an a `WindowContext`, it receives a `ViewContext`.
343 pub fn update<C, R>(
344 &self,
345 cx: &mut C,
346 update: impl FnOnce(&mut T, &mut ModelContext<'_, T>) -> R,
347 ) -> C::Result<R>
348 where
349 C: Context,
350 {
351 cx.update_model(self, update)
352 }
353}
354
355impl<T> Clone for Model<T> {
356 fn clone(&self) -> Self {
357 Self {
358 any_model: self.any_model.clone(),
359 entity_type: self.entity_type,
360 }
361 }
362}
363
364impl<T> std::fmt::Debug for Model<T> {
365 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
366 write!(
367 f,
368 "Model {{ entity_id: {:?}, entity_type: {:?} }}",
369 self.any_model.entity_id,
370 type_name::<T>()
371 )
372 }
373}
374
375impl<T> Hash for Model<T> {
376 fn hash<H: Hasher>(&self, state: &mut H) {
377 self.any_model.hash(state);
378 }
379}
380
381impl<T> PartialEq for Model<T> {
382 fn eq(&self, other: &Self) -> bool {
383 self.any_model == other.any_model
384 }
385}
386
387impl<T> Eq for Model<T> {}
388
389impl<T> PartialEq<WeakModel<T>> for Model<T> {
390 fn eq(&self, other: &WeakModel<T>) -> bool {
391 self.any_model.entity_id() == other.entity_id()
392 }
393}
394
395#[derive(Clone)]
396pub struct AnyWeakModel {
397 pub(crate) entity_id: EntityId,
398 entity_type: TypeId,
399 entity_ref_counts: Weak<RwLock<EntityRefCounts>>,
400}
401
402impl AnyWeakModel {
403 pub fn entity_id(&self) -> EntityId {
404 self.entity_id
405 }
406
407 pub fn is_upgradable(&self) -> bool {
408 let ref_count = self
409 .entity_ref_counts
410 .upgrade()
411 .and_then(|ref_counts| Some(ref_counts.read().counts.get(self.entity_id)?.load(SeqCst)))
412 .unwrap_or(0);
413 ref_count > 0
414 }
415
416 pub fn upgrade(&self) -> Option<AnyModel> {
417 let ref_counts = &self.entity_ref_counts.upgrade()?;
418 let ref_counts = ref_counts.read();
419 let ref_count = ref_counts.counts.get(self.entity_id)?;
420
421 // entity_id is in dropped_entity_ids
422 if ref_count.load(SeqCst) == 0 {
423 return None;
424 }
425 ref_count.fetch_add(1, SeqCst);
426
427 Some(AnyModel {
428 entity_id: self.entity_id,
429 entity_type: self.entity_type,
430 entity_map: self.entity_ref_counts.clone(),
431 })
432 }
433}
434
435impl<T> From<WeakModel<T>> for AnyWeakModel {
436 fn from(model: WeakModel<T>) -> Self {
437 model.any_model
438 }
439}
440
441impl Hash for AnyWeakModel {
442 fn hash<H: Hasher>(&self, state: &mut H) {
443 self.entity_id.hash(state);
444 }
445}
446
447impl PartialEq for AnyWeakModel {
448 fn eq(&self, other: &Self) -> bool {
449 self.entity_id == other.entity_id
450 }
451}
452
453impl Eq for AnyWeakModel {}
454
455#[derive(Deref, DerefMut)]
456pub struct WeakModel<T> {
457 #[deref]
458 #[deref_mut]
459 any_model: AnyWeakModel,
460 entity_type: PhantomData<T>,
461}
462
463unsafe impl<T> Send for WeakModel<T> {}
464unsafe impl<T> Sync for WeakModel<T> {}
465
466impl<T> Clone for WeakModel<T> {
467 fn clone(&self) -> Self {
468 Self {
469 any_model: self.any_model.clone(),
470 entity_type: self.entity_type,
471 }
472 }
473}
474
475impl<T: 'static> WeakModel<T> {
476 /// Upgrade this weak model reference into a strong model reference
477 pub fn upgrade(&self) -> Option<Model<T>> {
478 // Delegate to the trait implementation to keep behavior in one place.
479 Model::upgrade_from(self)
480 }
481
482 /// Update the entity referenced by this model with the given function if
483 /// the referenced entity still exists. Returns an error if the entity has
484 /// been released.
485 ///
486 /// The update function receives a context appropriate for its environment.
487 /// When updating in an `AppContext`, it receives a `ModelContext`.
488 /// When updating an a `WindowContext`, it receives a `ViewContext`.
489 pub fn update<C, R>(
490 &self,
491 cx: &mut C,
492 update: impl FnOnce(&mut T, &mut ModelContext<'_, T>) -> R,
493 ) -> Result<R>
494 where
495 C: Context,
496 Result<C::Result<R>>: crate::Flatten<R>,
497 {
498 crate::Flatten::flatten(
499 self.upgrade()
500 .ok_or_else(|| anyhow!("entity release"))
501 .map(|this| cx.update_model(&this, update)),
502 )
503 }
504}
505
506impl<T> Hash for WeakModel<T> {
507 fn hash<H: Hasher>(&self, state: &mut H) {
508 self.any_model.hash(state);
509 }
510}
511
512impl<T> PartialEq for WeakModel<T> {
513 fn eq(&self, other: &Self) -> bool {
514 self.any_model == other.any_model
515 }
516}
517
518impl<T> Eq for WeakModel<T> {}
519
520impl<T> PartialEq<Model<T>> for WeakModel<T> {
521 fn eq(&self, other: &Model<T>) -> bool {
522 self.entity_id() == other.any_model.entity_id()
523 }
524}
525
526#[cfg(test)]
527mod test {
528 use crate::EntityMap;
529
530 struct TestEntity {
531 pub i: i32,
532 }
533
534 #[test]
535 fn test_entity_map_slot_assignment_before_cleanup() {
536 // Tests that slots are not re-used before take_dropped.
537 let mut entity_map = EntityMap::new();
538
539 let slot = entity_map.reserve::<TestEntity>();
540 entity_map.insert(slot, TestEntity { i: 1 });
541
542 let slot = entity_map.reserve::<TestEntity>();
543 entity_map.insert(slot, TestEntity { i: 2 });
544
545 let dropped = entity_map.take_dropped();
546 assert_eq!(dropped.len(), 2);
547
548 assert_eq!(
549 dropped
550 .into_iter()
551 .map(|(_, entity)| entity.downcast::<TestEntity>().unwrap().i)
552 .collect::<Vec<i32>>(),
553 vec![1, 2],
554 );
555 }
556
557 #[test]
558 fn test_entity_map_weak_upgrade_before_cleanup() {
559 // Tests that weak handles are not upgraded before take_dropped
560 let mut entity_map = EntityMap::new();
561
562 let slot = entity_map.reserve::<TestEntity>();
563 let handle = entity_map.insert(slot, TestEntity { i: 1 });
564 let weak = handle.downgrade();
565 drop(handle);
566
567 let strong = weak.upgrade();
568 assert_eq!(strong, None);
569
570 let dropped = entity_map.take_dropped();
571 assert_eq!(dropped.len(), 1);
572
573 assert_eq!(
574 dropped
575 .into_iter()
576 .map(|(_, entity)| entity.downcast::<TestEntity>().unwrap().i)
577 .collect::<Vec<i32>>(),
578 vec![1],
579 );
580 }
581}