/// Downgrades the owned mutable guard to an owned immutable guard, allowing
/// access to the pooled value from other threads.
///
/// ## Examples
///
/// ```
/// # use sharded_slab::Pool;
/// # use std::{sync::Arc, thread};
/// let pool = Arc::new(Pool::<String>::new());
///
/// let mut guard_mut = pool.clone().create_owned().unwrap();
/// let key = guard_mut.key();
/// guard_mut.push_str("Hello");
///
/// // The pooled string is currently borrowed mutably, so other threads
/// // may not access it.
/// let pool2 = pool.clone();
/// thread::spawn(move || {
///     assert!(pool2.get(key).is_none())
/// }).join().unwrap();
///
/// // Downgrade the guard to an immutable reference.
/// let guard = guard_mut.downgrade();
///
/// // Now, other threads may also access the pooled value.
/// let pool2 = pool.clone();
/// thread::spawn(move || {
///     let guard = pool2.get(key)
///         .expect("the item may now be referenced by other threads");
///     assert_eq!(guard, String::from("Hello"));
/// }).join().unwrap();
///
/// // We can still access the value immutably through the downgraded guard.
/// assert_eq!(guard, String::from("Hello"));
/// ```
Downgrades the owned mutable guard to an owned immutable guard, allowing
access to the pooled value from other threads.
Downgrades the owned mutable guard to an owned immutable guard allowing access to the pooled value from other threads .
pub fn downgrade(mut self) -> OwnedRef<T, C> {
        let inner = unsafe { self.inner.downgrade() };
        OwnedRef {
            inner,
            pool: self.pool.clone(),
            key: self.key,
        }
    }
pub fn downgrade ( mut self ) -> OwnedRef < T , C > { let inner = unsafe { self . inner . downgrade ( ) } ; OwnedRef { inner , pool : self . pool . clone ( ) , key : self . key , } }
Downgrades the owned mutable guard to an owned immutable guard, allowing
access to the pooled value from other threads.
Downgrades the owned mutable guard to an owned immutable guard allowing access to the pooled value from other threads .
mut self
examples
None
use sharded_slab::pool;
None
use std::{sync::arc, thread};


let mut guard_mut = pool.clone().create_owned().unwrap();
let key = guard_mut.key();
guard_mut.push_str("Hello").

The pooled string is currently borrowed mutably, so other threads
may not access it.
let pool2 = pool.clone();
thread::spawn(move || {
assert!(pool2.get(key).is_none())
}).join().unwrap().

Downgrade the guard to an immutable reference.
let guard = guard_mut.downgrade().

Now, other threads may also access the pooled value.
let pool2 = pool.clone();
thread::spawn(move || {
let guard = pool2.get(key)
.expect("the item may now be referenced by other threads");
assert_eq!(guard, String::from("Hello"));
}).join().unwrap().

We can still access the value immutably through the downgraded guard.
assert_eq!(guard, String::from("Hello"));
```
let mut guard_mut = pool . clone () . create_owned () . unwrap () ; let key = guard_mut . key () ; guard_mut . push_str ( " Hello " ) . The pooled string is currently borrowed mutably so other threads may not access it . let pool2 = pool . clone () ; thread :: spawn ( move || { assert! ( pool2 . get ( key ) . is_none () ) } ) . join () . unwrap () . Downgrade the guard to an immutable reference . let guard = guard_mut . downgrade () . Now other threads may also access the pooled value . let pool2 = pool . clone () ; thread :: spawn ( move || { let guard = pool2 . get ( key ) . expect ( " the item may now be referenced by other threads " ) ; assert_eq! ( guard String :: from ( " Hello " )) ; } ) . join () . unwrap () . We can still access the value immutably through the downgraded guard . assert_eq! ( guard String :: from ( " Hello " )) ; ` ` `