fn drop(&mut self) {
        unsafe {
            let journal = &*Journal::<A>::current(true).unwrap().0;
            let inner = self.inner();

            // Because `fetch_sub` is already atomic, we do not need to synchronize
            // with other threads unless we are going to delete the object. This
            // same logic applies to the below `fetch_sub` to the `weak` count.
            if fetch_dec(inner.counter.lock.as_mut(),
                &mut inner.counter.strong, journal) != 1
            {
                return;
            }

            self.drop_slow(journal);
        }
    }
/// Drops the `Parc` safely
///
/// This will decrement the strong reference count. If the strong reference
/// count reaches zero then the only other references (if any) are
/// `Weak`, so we `drop` the inner value on commit using a `DropOnCommit` log.
///
/// # Examples
///
/// ```
/// use corundum::alloc::heap::*;
/// use corundum::sync::Parc;
/// use corundum::clone::PClone;
///
/// struct Foo;
///
/// impl Drop for Foo {
///     fn drop(&mut self) {
///         println!("dropped!");
///     }
/// }
///
/// Heap::transaction(|j| {
///     let foo  = Parc::new(Foo, j);
///     let foo2 = Parc::pclone(&foo, j);
///
///     drop(foo);    // Doesn't print anything
///     drop(foo2);   // Prints "dropped!"
/// }).unwrap();
/// ```
///
Drops the `Parc` safely
This will decrement the strong reference count.
Drops the ` Parc ` safely This will decrement the strong reference count .
fn drop(&mut self) {
        unsafe {
            let journal = &*Journal::<A>::current(true).unwrap().0;
            let inner = self.inner();
            // Because `fetch_sub` is already atomic, we do not need to synchronize
            // with other threads unless we are going to delete the object. This
            // same logic applies to the below `fetch_sub` to the `weak` count.
            if fetch_dec(inner.counter.lock.as_mut(),
                &mut inner.counter.strong, journal) != 1
            {
                return;
            }
            self.drop_slow(journal);
        }
    }
fn drop ( & mut self ) { unsafe { let journal = & * Journal :: < A > :: current ( true ) . unwrap ( ) . 0 ; let inner = self . inner ( ) ; // Because `fetch_sub` is already atomic, we do not need to synchronize // with other threads unless we are going to delete the object. This // same logic applies to the below `fetch_sub` to the `weak` count. if fetch_dec ( inner . counter . lock . as_mut ( ) , & mut inner . counter . strong , journal ) != 1 { return ; } self . drop_slow ( journal ) ; } }
Drops the `Parc` safely
This will decrement the strong reference count.
Drops the ` Parc ` safely This will decrement the strong reference count .
&mut self
examples
```
use corundum::alloc::heap::*;
use corundum::sync::Parc;
use corundum::clone::PClone.

struct Foo.

impl Drop for Foo {
fn drop(&mut self) {
println!("dropped!");
}
}

:transaction(|j| {
let foo  = Parc::new(Foo, j);
let foo2 = Parc::pclone(&foo, j).

drop(foo);    // Doesn't print anything
drop(foo2);   // Prints "dropped!"
}).unwrap();
```
` ` ` use corundum :: alloc :: heap :: * ; use corundum :: sync :: Parc ; use corundum :: clone :: PClone . struct Foo . impl Drop for Foo { fn drop ( &mut self ) { println! ( " dropped! " ) ; } } : transaction ( |j| { let foo = Parc :: new ( Foo j ) ; let foo2 = Parc :: pclone ( &foo j ) . drop ( foo ) ; // Doesn ' t print anything drop ( foo2 ) ; // Prints " dropped! " } ) . unwrap () ; ` ` `