# Struct rustc_data_structures::sync::lock::no_sync::LockGuard

1.0.0 · source ·

    pub struct LockGuard<'b, T>where
        T: 'b + ?Sized,{
        value: NonNull<T>,
        borrow: BorrowRefMut<'b>,
        marker: PhantomData<&'b mut T>,
    }

Expand description

A wrapper type for a mutably borrowed value from a `RefCell<T>`.

See the module-level documentation for more.

## Fields§

§`value: NonNull<T>`§`borrow: BorrowRefMut<'b>`§`marker: PhantomData<&'b mut T>`

## Implementations§

source§

### impl<'b, T> RefMut<'b, T>
where T: ?Sized,

1.8.0 · source

#### pub fn map<U, F>(orig: RefMut<'b, T>, f: F) -> RefMut<'b, U>
where F: FnOnce(&mut T) -> &mut U, U: ?Sized,

Makes a new `RefMut` for a component of the borrowed data, e.g., an enum variant.

The `RefCell` is already mutably borrowed, so this cannot fail.

This is an associated function that needs to be used as `RefMut::map(...)`. A method would interfere with methods of the same name on the contents of a `RefCell` used through `Deref`.

##### §Examples

    use std::cell::{RefCell, RefMut};

    let c = RefCell::new((5, 'b'));
    {
        let b1: RefMut<'_, (u32, char)> = c.borrow_mut();
        let mut b2: RefMut<'_, u32> = RefMut::map(b1, |t| &mut t.0);
        assert_eq!(*b2, 5);
        *b2 = 42;
    }
    assert_eq!(*c.borrow(), (42, 'b'));

1.63.0 · source

#### pub fn filter_map<U, F>( orig: RefMut<'b, T>, f: F ) -> Result<RefMut<'b, U>, RefMut<'b, T>>
where F: FnOnce(&mut T) -> Option<&mut U>, U: ?Sized,

Makes a new `RefMut` for an optional component of the borrowed data. The original guard is returned as an `Err(..)` if the closure returns `None`.

The `RefCell` is already mutably borrowed, so this cannot fail.

This is an associated function that needs to be used as `RefMut::filter_map(...)`. A method would interfere with methods of the same name on the contents of a `RefCell` used through `Deref`.

##### §Examples

    use std::cell::{RefCell, RefMut};

    let c = RefCell::new(vec![1, 2, 3]);

    {
        let b1: RefMut<'_, Vec<u32>> = c.borrow_mut();
        let mut b2: Result<RefMut<'_, u32>, _> = RefMut::filter_map(b1, |v| v.get_mut(1));

        if let Ok(mut b2) = b2 {
            *b2 += 2;
        }
    }

    assert_eq!(*c.borrow(), vec![1, 4, 3]);

1.35.0 · source

#### pub fn map_split<U, V, F>( orig: RefMut<'b, T>, f: F ) -> (RefMut<'b, U>, RefMut<'b, V>)
where F: FnOnce(&mut T) -> (&mut U, &mut V), U: ?Sized, V: ?Sized,

Splits a `RefMut` into multiple `RefMut`s for different components of the borrowed data.

The underlying `RefCell` will remain mutably borrowed until both returned `RefMut`s go out of scope.

The `RefCell` is already mutably borrowed, so this cannot fail.

This is an associated function that needs to be used as `RefMut::map_split(...)`. A method would interfere with methods of the same name on the contents of a `RefCell` used through `Deref`.

##### §Examples

    use std::cell::{RefCell, RefMut};

    let cell = RefCell::new([1, 2, 3, 4]);
    let borrow = cell.borrow_mut();
    let (mut begin, mut end) = RefMut::map_split(borrow, |slice| slice.split_at_mut(2));
    assert_eq!(*begin, [1, 2]);
    assert_eq!(*end, [3, 4]);
    begin.copy_from_slice(&[4, 3]);
    end.copy_from_slice(&[2, 1]);

source

#### pub fn leak(orig: RefMut<'b, T>) -> &'b mut T

🔬This is a nightly-only experimental API. (`cell_leak`)

Convert into a mutable reference to the underlying data.

The underlying `RefCell` can not be borrowed from again and will always appear already mutably borrowed, making the returned reference the only to the interior.

This is an associated function that needs to be used as `RefMut::leak(...)`. A method would interfere with methods of the same name on the contents of a `RefCell` used through `Deref`.

##### §Examples

    #![feature(cell_leak)]
    use std::cell::{RefCell, RefMut};
    let cell = RefCell::new(0);

    let value = RefMut::leak(cell.borrow_mut());
    assert_eq!(*value, 0);
    *value = 1;

    assert!(cell.try_borrow_mut().is_err());

## Trait Implementations§

§

### impl<'a> ByteSlice for RefMut<'a, [u8]>

§

#### fn split_at(self, mid: usize) -> (RefMut<'a, [u8]>, RefMut<'a, [u8]>)

Splits the slice at the midpoint. Read more
§

#### fn as_ptr(&self) -> *const u8

Gets a raw pointer to the first byte in the slice.
§

### impl<'a> ByteSliceMut for RefMut<'a, [u8]>

§

#### fn as_mut_ptr(&mut self) -> *mut u8

Gets a mutable raw pointer to the first byte in the slice.
source§

### impl<T> Debug for RefMut<'_, T>
where T: Debug + ?Sized,

source§

#### fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter. Read more
source§

### impl<T> Deref for RefMut<'_, T>
where T: ?Sized,

§

#### type Target = T

The resulting type after dereferencing.
source§

#### fn deref(&self) -> &T

Dereferences the value.
source§

### impl<T> DerefMut for RefMut<'_, T>
where T: ?Sized,

source§

#### fn deref_mut(&mut self) -> &mut T

Mutably dereferences the value.
1.20.0 · source§

### impl<T> Display for RefMut<'_, T>
where T: Display + ?Sized,

source§

#### fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter. Read more
source§

### impl<'b, T, U> CoerceUnsized<RefMut<'b, U>> for RefMut<'b, T>
where T: Unsize<U> + ?Sized, U: ?Sized,

§

### impl<'a, T> StableDeref for RefMut<'a, T>
where T: ?Sized,

## Auto Trait Implementations§

§

### impl<'b, T> !DynSend for RefMut<'b, T>

§

### impl<'b, T> !DynSync for RefMut<'b, T>

§

### impl<'b, T: ?Sized> Freeze for RefMut<'b, T>

§

### impl<'b, T> !RefUnwindSafe for RefMut<'b, T>

§

### impl<'b, T> !Send for RefMut<'b, T>

§

### impl<'b, T> !Sync for RefMut<'b, T>

§

### impl<'b, T: ?Sized> Unpin for RefMut<'b, T>

§

### impl<'b, T> !UnwindSafe for RefMut<'b, T>

## Blanket Implementations§

source§

### impl<T> Aligned for T

source§

#### const ALIGN: Alignment = const ALIGN: Alignment = Alignment::of::<Self>();

Alignment of `Self`.
source§

### impl<T> Any for T
where T: 'static + ?Sized,

source§

#### fn type_id(&self) -> TypeId

Gets the `TypeId` of `self`. Read more
source§

### impl<T> Borrow<T> for T
where T: ?Sized,

source§

#### fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

### impl<T> BorrowMut<T> for T
where T: ?Sized,

source§

#### fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

### impl<T> From<T> for T

source§

#### fn from(t: T) -> T

Returns the argument unchanged.

source§

### impl<T> Instrument for T

source§

#### fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided `Span`, returning an `Instrumented` wrapper. Read more
source§

#### fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current `Span`, returning an `Instrumented` wrapper. Read more
source§

### impl<T, U> Into<U> for T
where U: From<T>,

source§

#### fn into(self) -> U

Calls `U::from(self)`.

That is, this conversion is whatever the implementation of `From<T> for U` chooses to do.

§

### impl<T> Pointable for T

§

#### const ALIGN: usize = _

The alignment of pointer.
§

#### type Init = T

The type for initializers.
§

#### unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
§

#### unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
§

#### unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
§

#### unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
source§

### impl<T> ToString for T
where T: Display + ?Sized,

source§

#### default fn to_string(&self) -> String

Converts the given value to a `String`. Read more
source§

### impl<T, U> TryFrom<U> for T
where U: Into<T>,

§

#### type Error = Infallible

The type returned in the event of a conversion error.
source§

#### fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

### impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

§

#### type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

#### fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
source§

### impl<T> WithSubscriber for T

source§

#### fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,

Attaches the provided `Subscriber` to this type, returning a `WithDispatch` wrapper. Read more
source§

#### fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default `Subscriber` to this type, returning a `WithDispatch` wrapper. Read more
source§

### impl<'a, T> Captures<'a> for T
where T: ?Sized,

## Layout§

Note: Unable to compute type layout, possibly due to this type having generic parameters. Layout can only be computed for concrete, fully-instantiated types.