A derive for accessing a pinned field of a type.
#[derive(PinAccessor)]
struct Foo {
#[pin_accessor]
bar: i32,
}
Adds an inherent method to Foo
:
impl Foo {
fn bar_pinned<'a>(self: &'a mut Pin<Foo>) -> Pin<'a, i32> { ... }
}
The visibility of the method is, by default, the same as the visibility of the field.
The name of the method is, by default, the name of the field, with _pinned
as a suffix.
Both of these can be controlled by arguments to the pin_accessor
attribute:
#[derive(PinAccessor)]
pub struct Foo {
#[pin_accessor(vis = "pub", name = "bar")]
bar: i32,
}
This creates a public method called bar
, instead of a private method called bar_pinned
.
This derive creates a method that is safe. This requires you to uphold an invariant in any unsafe code you write using this field:
- If the field type implements
Unpin
, this method is always safe. - If the field type does not implement
Unpin
, you must never move out of it from aPin
of the type it belongs to.
In other words, unless you are messing around with moving potentially Unpin
data around, you are
definitely safe.
- This derive is not yet no_std compatible, but easily could be.
- This derive creates a method requiring the double indirection of
&mut Pin<Self>
. This is because of limitations on the std APIs ofPin
, which should probably be changed.