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