1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83
/// A pinned projection of a struct field. /// /// To make using this macro safe, two things need to be ensured: /// - If the struct implements [`Drop`], the [`drop`] method is not allowed to /// move the value of the field. /// - If the struct wants to implement [`Unpin`], it has to do so conditionally: /// The struct can only implement [`Unpin`] if the field's type is [`Unpin`]. /// /// ``` /// # #![feature(pin, arbitrary_self_types)] /// # use pin_utils::unsafe_pinned; /// # use std::pin::PinMut; /// # use std::marker::Unpin; /// struct Foo<T> { /// field: T, /// } /// /// impl<T> Foo<T> { /// unsafe_pinned!(field: T); /// /// fn baz(mut self: PinMut<Self>) { /// let _: PinMut<T> = self.field(); // Pinned reference to the field /// } /// } /// /// impl<T: Unpin> Unpin for Foo<T> {} // Conditional Unpin impl /// ``` /// /// [`Unpin`]: core::marker::Unpin /// [`drop`]: Drop::drop #[macro_export] macro_rules! unsafe_pinned { ($f:tt: $t:ty) => ( fn $f<'__a>( self: &'__a mut $crate::core_reexport::pin::PinMut<Self> ) -> $crate::core_reexport::pin::PinMut<'__a, $t> { unsafe { $crate::core_reexport::pin::PinMut::map_unchecked( self.reborrow(), |x| &mut x.$f ) } } ) } /// An unpinned projection of a struct field. /// /// This macro is unsafe because it creates a method that returns a normal /// non-pin reference to the struct field. It is up to the programmer to ensure /// that the contained value can be considered not pinned in the current /// context. /// /// ``` /// # #![feature(pin, arbitrary_self_types)] /// # use pin_utils::unsafe_unpinned; /// # use std::pin::PinMut; /// # struct Bar; /// struct Foo { /// field: Bar, /// } /// /// impl Foo { /// unsafe_unpinned!(field: Bar); /// /// fn baz(mut self: PinMut<Self>) { /// let _: &mut Bar = self.field(); // Normal reference to the field /// } /// } /// ``` #[macro_export] macro_rules! unsafe_unpinned { ($f:tt: $t:ty) => ( fn $f<'__a>( self: &'__a mut $crate::core_reexport::pin::PinMut<Self> ) -> &'__a mut $t { unsafe { &mut $crate::core_reexport::pin::PinMut::get_mut_unchecked( self.reborrow() ).$f } } ) }