Lines Matching full:tracking

19 /// a [`ListArc`] exists or not. We refer to this logic as "the tracking inside `T`".
21 /// We allow the case where the tracking inside `T` thinks that a [`ListArc`] exists, but actually,
23 /// exists, but the tracking thinks it doesn't. This is because the former can at most result in us
28 /// A consequence of the above is that you may implement the tracking inside `T` by not actually
34     /// Informs the tracking inside this type that it now has a [`ListArc`] reference.
36     /// This method may be called even if the tracking inside this type thinks that a `ListArc`
44     /// Informs the tracking inside this type that there is no [`ListArc`] reference anymore.
48     /// Must only be called if there is no [`ListArc`] reference, but the tracking thinks there is.
66     /// Additionally, this call will have transitioned the tracking inside `Self` from not thinking
73 /// This macro supports a few different strategies for implementing the tracking inside the type:
77 /// * The `tracked_by` strategy defers the tracking to a field of the struct. The user much specify
78 ///   which field to defer the tracking to. The field must implement [`ListArcSafe`]. If the field
82 /// [`AtomicTracker`]. However, it is also possible to defer the tracking to another struct
112                 // promises that the tracking thinks there is a `ListArc` reference.
143 /// relevant tracking is referred to as "the tracking inside `T`", and the [`ListArcSafe`] trait
144 /// (and its subtraits) are used to update the tracking when a `ListArc` is created or destroyed.
146 /// Note that we allow the case where the tracking inside `T` thinks that a `ListArc` exists, but
148 /// `ListArc` exists, but the tracking thinks it doesn't. This is because the former can at most
158 /// * The tracking inside `T` is aware that a `ListArc` reference exists.
282             // SAFETY: The `try_new_list_arc` method returned true, so we made the tracking think  in try_from_arc()
298             // SAFETY: The `try_new_list_arc` method returned true, so we made the tracking think  in try_from_arc_borrow()
320     /// Transmutes an [`Arc`] into a `ListArc` without updating the tracking inside `T`.
325     /// * The tracking inside `T` must think that there is a `ListArc` reference.
332     /// Transmutes a `ListArc` into an [`Arc`] without updating the tracking inside `T`.
334     /// After this call, the tracking inside `T` will still think that there is a `ListArc`
347     /// tracking inside `T` will still think that a `ListArc` exists after this call.
359     /// * The tracking inside `T` must think that there is a `ListArc` reference.
364         // SAFETY: The value doesn't already have a `ListArc` reference, but the tracking thinks it  in from_raw()
373         // SAFETY: There is no longer a `ListArc`, but the tracking thinks there is.  in into_arc()
429         // SAFETY: There is no longer a `ListArc`, but the tracking thinks there is by the type  in drop()
465 /// A utility for tracking whether a [`ListArc`] exists using an atomic.