pub fn into_mut(self) -> Result<Mut<T>, AccessError> {
        // NB: we default to a "safer" mode with `AccessKind::Owned`, where
        // references cannot be converted to an `Mut<T>` in order to avoid
        // a potential soundness panic.
        self.internal_into_mut(AccessKind::Owned)
    }
/// Get a reference to the interior value while checking for exclusive
/// access that holds onto a reference count of the inner value.
///
/// This prevents other exclusive and shared accesses from being performed
/// while the guard returned from this function is live.
///
/// # Examples
///
/// ```rust
/// use runestick::Shared;
///
/// #[derive(Debug)]
/// struct Foo {
///     counter: isize,
/// }
///
/// let a = Shared::new(Foo { counter: 0 });
/// let b = a.clone();
///
/// {
///     // Consumes `a`.
///     let mut a = a.into_mut().unwrap();
///     a.counter += 1;
///
///     assert!(b.borrow_ref().is_err());
/// }
///
/// assert_eq!(b.borrow_ref().unwrap().counter, 1);
/// ```
Get a reference to the interior value while checking for exclusive
access that holds onto a reference count of the inner value.

This prevents other exclusive and shared accesses from being performed
while the guard returned from this function is live.
Get a reference to the interior value while checking for exclusive access that holds onto a reference count of the inner value . This prevents other exclusive and shared accesses from being performed while the guard returned from this function is live .
pub fn into_mut(self) -> Result<Mut<T>, AccessError> {
        // NB: we default to a "safer" mode with `AccessKind::Owned`, where
        // references cannot be converted to an `Mut<T>` in order to avoid
        // a potential soundness panic.
        self.internal_into_mut(AccessKind::Owned)
    }
pub fn into_mut ( self ) -> Result < Mut < T > , AccessError > { // NB: we default to a "safer" mode with `AccessKind::Owned`, where // references cannot be converted to an `Mut<T>` in order to avoid // a potential soundness panic. self . internal_into_mut ( AccessKind :: Owned ) }
Get a reference to the interior value while checking for exclusive
access that holds onto a reference count of the inner value.
Get a reference to the interior value while checking for exclusive access that holds onto a reference count of the inner value .
self
self
examples
```rust
use runestick::Shared.
` ` ` rust use runestick :: Shared .
[derive(debug)]
struct Foo {
counter: isize,
}

let a = Shared::new(Foo { counter: 0 });
let b = a.clone().

{
Consumes `a`.
let mut a = a.into_mut().unwrap();
a.counter += 1.




struct Foo { counter : isize } let a = Shared :: new ( Foo { counter : 0 } ) ; let b = a . clone () . { Consumes ` a ` . let mut a = a . into_mut () . unwrap () ; a . counter + = 1 .