39 /// of this: weak increments and strong increments. We call such increments "critical" because it
42 /// * One thread makes a zero-to-one strong increment, and another thread makes a zero-to-one weak
44 ///   thread doing the strong increment may have ended a long time ago when the command is actually
48 ///   a zero-to-one strong increment. If the strong increment gets sent to the thread that was
49 ///   about to drop the weak reference, then the strong increment could be processed after the
64     /// The wrapper is used only for strong zero2one increments.
72     /// Is the currently scheduled wrapper/`Node` scheduled due to a strong zero2one increment?
74     /// If `has_pushed_wrapper` is set, then the strong zero2one increment was scheduled using the
145     /// Strong refcounts held on this node by `NodeRef` objects.
146     strong: CountState,  field
217                     strong: CountState::new(),  in new()
260             inner.strong.has_count,  in full_debug_print()
262             inner.strong.count,  in full_debug_print()
346             let strong = inner.strong.count > 0;  in inc_ref_done_locked()  localVariable
347             let has_strong = inner.strong.has_count;  in inc_ref_done_locked()
348             let weak = strong || inner.weak.count > 0;  in inc_ref_done_locked()
352             let should_drop_strong = !strong && has_strong;  in inc_ref_done_locked()
373         strong: bool,  in update_refcount_locked()
381         let state = if strong {  in update_refcount_locked()
382             &mut inner.strong  in update_refcount_locked()
412         strong: bool,  in incr_refcount_allow_zero2one()
419         let state = if strong {  in incr_refcount_allow_zero2one()
420             &mut inner.strong  in incr_refcount_allow_zero2one()
432         if !strong && inner.delivery_state.should_push_weak_zero2one() {  in incr_refcount_allow_zero2one()
437         } else if strong && inner.delivery_state.should_push_strong_zero2one() {  in incr_refcount_allow_zero2one()
454         strong: bool,  in incr_refcount_allow_zero2one_with_wrapper()
458         match self.incr_refcount_allow_zero2one(strong, owner_inner) {  in incr_refcount_allow_zero2one_with_wrapper()
462                 assert!(strong);  in incr_refcount_allow_zero2one_with_wrapper()
464                 inner.strong.count += 1;  in incr_refcount_allow_zero2one_with_wrapper()
471     pub(crate) fn update_refcount(self: &DArc<Self>, inc: bool, count: usize, strong: bool) {  in update_refcount()
475             .update_node_refcount(self, inc, strong, count, None);  in update_refcount()
484         out.strong_count = inner.strong.count as _;  in populate_counts()
496         if inner.strong.has_count {  in populate_debug_info()
506         inner.strong.has_count = true;  in force_has_count()
603         let strong = inner.strong.count > 0;  in do_work_locked()  localVariable
604         let has_strong = inner.strong.has_count;  in do_work_locked()
605         let weak = strong || inner.weak.count > 0;  in do_work_locked()
613         if strong && !has_strong {  in do_work_locked()
614             inner.strong.has_count = true;  in do_work_locked()
620         let should_drop_strong = no_active_inc_refs && (!strong && has_strong);  in do_work_locked()
625             inner.strong.has_count = false;  in do_work_locked()
636         if strong && !has_strong {  in do_work_locked()
711             // increment, and the wrapper is a strong zero2one increment, so the wrapper always  in do_work()
795                 inner.strong.count -= self.strong_node_count - 1;  in absorb()
797                 assert_ne!(inner.strong.count, 0);  in absorb()
811     pub(crate) fn clone(&self, strong: bool) -> Result<NodeRef> {  in clone()
812         if strong && self.strong_count == 0 {  in clone()
820             .new_node_ref(self.node.clone(), strong, None))  in clone()
828     pub(crate) fn update(&mut self, inc: bool, strong: bool) -> bool {  in update()
829         if strong && self.strong_count == 0 {  in update()
832         let (count, node_count, other_count) = if strong {  in update()
848                 self.node.update_refcount(true, 1, strong);  in update()
861                 self.node.update_refcount(false, *node_count, strong);  in update()