pub unsafe trait GetFieldMut<FieldName>: GetField<FieldName> {
// Required methods
fn get_field_mut_(&mut self, field_name: FieldName) -> &mut Self::Ty;
unsafe fn get_field_raw_mut(
ptr: *mut (),
field_name: FieldName,
) -> *mut Self::Ty
where Self: Sized;
fn get_field_raw_mut_fn(&self) -> GetFieldRawMutFn<FieldName, Self::Ty>;
}Expand description
Allows accessing the FieldName field mutably.
§Safety
These are requirements for manual implementations.
Implementors ought not mutate fields inside their accessor trait impls, or the accessor trait impls of other fields.
It is recommended that you use the z_unsafe_impl_get_field_raw_mut macro
if you only borrow a field of the type.
§Implementing get_field_raw_mut
Your implementation of GetFieldMut::get_field_raw_mut must ensure these properties:
-
It must be side-effect free,
-
The method must return a pointer to a fully initialized field,
-
The field you access must always be the same one.
-
That no implementation returns a pointer to a field that (other) implementations for the same type also return,
-
That no implementation returns a pointer to a field that (other)
GetVariantFieldMutimplementations for the same type also return,
You can unerase the pointer by casting it to *mut Self
(you can also use any type that’s compatible with Self).
Your implementation of the get_field_raw_mut_fn method must only return a
function pointer to a function that ensures the properties listed
above.
§Example: Usage as Bound
use structural::{StructuralExt,GetFieldMut,FP,fp};
use structural::for_examples::{Struct2,Struct3};
fn example<T>(this:&mut T)
where
T: GetFieldMut<FP!(foo), Ty=Option<u32>> + GetFieldMut<FP!(bar), Ty=&'static str>
{
assert_eq!( this.field_(fp!(foo)), &Some(21) );
assert_eq!( this.field_(fp!(bar)), &"oh boy" );
assert_eq!( this.fields(fp!(foo,bar)), (&Some(21), &"oh boy") );
assert_eq!( this.cloned_fields(fp!(foo,bar)), (Some(21), "oh boy") );
assert_eq!( this.field_mut(fp!(foo)), &mut Some(21) );
assert_eq!( this.field_mut(fp!(bar)), &mut "oh boy" );
assert_eq!( this.fields_mut(fp!(foo,bar)), (&mut Some(21), &mut "oh boy") );
}
example(&mut Struct2{ foo:Some(21), bar: "oh boy" });
example(&mut Struct3{ foo:Some(21), bar: "oh boy", baz:5 });
§Example: Manual implementation
While this trait is intended to be implemented using the Structural derive macro,
you can also implement it like this:
use structural::{FieldType,GetField,GetFieldMut,Structural,FP};
struct Huh<T>{
value:T,
}
impl<T> Structural for Huh<T>{}
impl<T> FieldType<FP!(value)> for Huh<T>{
type Ty=T;
}
impl<T> GetField<FP!(value)> for Huh<T>{
fn get_field_(&self,_:FP!(value))->&Self::Ty{
&self.value
}
}
unsafe impl<T> GetFieldMut<FP!(value)> for Huh<T>{
fn get_field_mut_(&mut self,_:FP!(value))->&mut Self::Ty{
&mut self.value
}
structural::z_unsafe_impl_get_field_raw_mut!{
Self,
field_tstr=value,
name_generic=FP!(value),
}
}
Required Methods§
Sourcefn get_field_mut_(&mut self, field_name: FieldName) -> &mut Self::Ty
fn get_field_mut_(&mut self, field_name: FieldName) -> &mut Self::Ty
Accesses the FieldName field by mutable reference.
Sourceunsafe fn get_field_raw_mut(
ptr: *mut (),
field_name: FieldName,
) -> *mut Self::Tywhere
Self: Sized,
unsafe fn get_field_raw_mut(
ptr: *mut (),
field_name: FieldName,
) -> *mut Self::Tywhere
Self: Sized,
Gets a mutable pointer for the field.
§Safety
You must pass a pointer casted from *mut Self to *mut (),
pointing to a fully initialized instance of the type.
Sourcefn get_field_raw_mut_fn(&self) -> GetFieldRawMutFn<FieldName, Self::Ty>
fn get_field_raw_mut_fn(&self) -> GetFieldRawMutFn<FieldName, Self::Ty>
Gets the get_field_raw_mut associated function as a function pointer.