Struct FieldCloner

#[repr(transparent)]
pub struct FieldCloner<T>(pub T);

Wrapper that emulates by-value access to fields by cloning them.

This allows using types that only provide shared access to fields (implementing GetField/GetVariantField) to be passed to functions expecting by-value access to them (requiring IntoField/IntoVariantField), by cloning those fields.

Struct Example

use structural::{FieldCloner, Structural, StructuralExt, fp, structural_alias};


let expected = ("what".to_string(), vec![0,1,2]);

let this = TheStruct{foo: "what".to_string(), bar: vec![0,1,2]};

// This doesn't compile,because `TheStruct` only provides shared access to the fields,
// implementing `GetField` to access both the `foo` and `bar` fields.
//
// assert_eq!( into_foo_bar(this), expected.clone() );

assert_eq!( into_foo_bar(FieldCloner(this.clone())), expected.clone() );

assert_eq!( into_foo_bar(FieldCloner(&this)), expected.clone() );

assert_eq!( into_foo_bar(FieldCloner(&&&&&this)), expected.clone() );


fn into_foo_bar<P, T>(this: P)-> (String, Vec<T>)
where
    P: TypeMove<String, Vec<T>>,
{
    this.into_fields(fp!(foo, bar))
}

#[derive(Structural,Clone)]
// Makes this struct only implement `GetField` for the fields,
// providing shared access to them.
#[struc(access="ref")]
struct TheStruct<T, U>{
    pub foo: T,
    pub bar: U,
}

structural::structural_alias!{
    // The same fields as `TheStruct`, with shared and by-value access to the fields.
    //
    // This trait isn't implemented by `TheStruct` because it only
    // provides shared access to the fields.
    trait TypeMove<T, U>{
        move foo: T,
        move bar: U,
    }
}

Enum Example

use structural::{FieldCloner, Structural, StructuralExt, fp, structural_alias};


{
    let expected = Some((vec!["foo","bar"], [0, 1, 2]));
    
    let this = TheEnum::Both(vec!["foo","bar"], [0, 1, 2]);
    
    // This doesn't compile,because `TheEnum` only provides shared access to the fields,
    // implementing `GetField` to access both the `foo` and `bar` fields.
    //
    // assert_eq!( into_both(Box::new(this)), expected.clone() );
    
    assert_eq!( into_both(Box::new(FieldCloner(this.clone()))), expected.clone() );
    
    assert_eq!( into_both(Box::new(FieldCloner(&this))), expected.clone() );
    
    assert_eq!( into_both(Box::new(FieldCloner(&&&&&this))), expected.clone() );
}
{
    let this = TheEnum::Left{left: vec!["foo","bar"]};
    
    assert_eq!( into_both(Box::new(FieldCloner(this.clone()))), None );
    
    assert_eq!( into_both(Box::new(FieldCloner(&this))), None );
    
    assert_eq!( into_both(Box::new(FieldCloner(&&&&&this))), None );
}


fn into_both<'a,T>(
    this: Box<dyn TypeMove<Vec<T>, [u32;3]> + 'a>
)-> Option<(Vec<T>, [u32;3])> {
    this.into_fields(fp!(::Both=>0,1))
}

#[derive(Structural, Clone)]
// Makes this enum only implement `GetVariantField` for the fields,
// providing shared access to them.
#[struc(access="ref")]
pub enum TheEnum<L, R> {
    Both(L, R),
    Left{left: L},
    Right{right: R},
}

structural::structural_alias!{
    // The same fields as `TheEnum`, with shared and by-value access to the fields.
    //
    // This trait isn't implemented by `TheEnum` because it only
    // provides shared access to the fields.
    trait TypeMove<L, R>{
        move Both(L, R),
        move Left{left: L},
        move Right{right: R},
    }
}

Tuple Fields

0: T

Implementations

impl<T> FieldCloner<T>

pub fn as_ref(&self) -> FieldCloner<&T>

Turns a &FieldCloner<T> into a FieldCloner<&T>.

Struct Example

use structural::{FieldCloner, StructuralExt, fp};
use structural::for_examples::{FooBarRef, FooBarMove_SI};

let this = FieldCloner(FooBarRef{foo: 100, bar: "baz"});

assert_eq!( into_foo(this.as_ref()), 100 );

fn into_foo<T, U>(this: impl FooBarMove_SI<T, U>)-> T {
    this.into_field(fp!(foo))
}

Enum Example

use structural::{FieldCloner, StructuralExt, fp};
use structural::for_examples::{EnumRef, EnumMove_SI};

let this = FieldCloner(EnumRef::Left{left: 10});

assert_eq!( into_left(this.as_ref()), Some(10) );

fn into_left(this: impl EnumMove_SI<u32, bool>)-> Option<u32> {
    this.into_field(fp!(::Left.left))
}

pub fn as_mut(&mut self) -> FieldCloner<&mut T>

Turns a &mut FieldCloner<T> into a FieldCloner<&mut T>.

Struct Example

use structural::{FieldCloner, StructuralExt, fp};
use structural::for_examples::{FooBarRef, FooBarMove_SI};

let this = FieldCloner(FooBarRef{foo: 100, bar: "baz"});

assert_eq!( into_bar(this.as_ref()), "baz" );

fn into_bar<T, U>(this: impl FooBarMove_SI<T, U>)-> U {
    this.into_field(fp!(bar))
}

Enum Example

use structural::{FieldCloner, StructuralExt, fp};
use structural::for_examples::{EnumRef, EnumMove_SI};

let mut this = FieldCloner(EnumRef::Right{right: false});

assert_eq!( into_right(this.as_mut()), Some(false) );

fn into_right(this: impl EnumMove_SI<u32, bool>)-> Option<bool> {
    this.into_field(fp!(::Right.right))
}

pub fn map<F, U>(self, f: F) -> FieldCloner<U>

where F: FnOnce(T) -> U,

Transforms the wrapped value with the func function.

pub fn then<F, U>(self, f: F) -> FieldCloner<U>

where F: FnOnce(Self) -> U,

Calls func with self,rewrapping its return value in a FieldCloner<U>

impl<T: Clone> FieldCloner<&T>

pub fn cloned(self) -> FieldCloner<T>

Maps the wrapped reference into a clone.

impl<T: Clone> FieldCloner<&mut T>

pub fn cloned(self) -> FieldCloner<T>

Maps the wrapped mutable reference into a clone.

Trait Implementations

impl<T: Clone> Clone for FieldCloner<T>

fn clone(&self) -> FieldCloner<T>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T> ConstDefault for FieldCloner<T>

where T: ConstDefault,

const DEFAULT: Self

The default value for Self.

impl<T: Debug> Debug for FieldCloner<T>

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

Formats the value using the given formatter.

impl<T: Default> Default for FieldCloner<T>

fn default() -> FieldCloner<T>

Returns the “default value” for a type.

impl<T> DropFields for FieldCloner<T>

fn pre_move(&mut self)

What this type does right before any field is moved.

unsafe fn drop_fields(&mut self, _: MovedOutFields)

Drops all the fields that were not moved out.

impl<T, NP, __Ty> FieldType<NP> for FieldCloner<T>

where T: FieldType<NP, Ty = __Ty>,

type Ty = <T as FieldType<NP>>::Ty

The type of the FieldPath field.

impl<T, __From> FromStructural<__From> for FieldCloner<T>

where T: FromStructural<__From>,

fn from_structural(from: __From) -> Self

Performs the conversion

impl<T, __F, __Ty> GetField<__F> for FieldCloner<T>

where T: GetField<__F, Ty = __Ty>,

fn get_field_(&self, fname: __F) -> &__Ty

Accesses the FieldName field by reference.

impl<T, __F, __Ty> GetFieldMut<__F> for FieldCloner<T>

where FieldCloner<T>: Sized, T: GetFieldMut<__F, Ty = __Ty>,

fn get_field_mut_(&mut self, fname: __F) -> &mut __Ty

Accesses the FieldName field by mutable reference.

unsafe fn get_field_raw_mut(this: *mut (), fname: __F) -> *mut __Ty

where Self: Sized,

Gets a mutable pointer for the field.

fn get_field_raw_mut_fn(&self) -> GetFieldRawMutFn<__F, __Ty>

Gets the get_field_raw_mut associated function as a function pointer.

impl<T, __V, __F, __Ty> GetVariantField<TStr<__V>, __F> for FieldCloner<T>

where T: GetVariantField<TStr<__V>, __F, Ty = __Ty>,

fn get_vfield_( &self, vname: TStr<__V>, fname: __F, ) -> Option<&GetVariantFieldType<T, TStr<__V>, __F>>

Accesses the F field in the V variant by reference.

unsafe fn get_vfield_unchecked(&self, variant: V, field: F) -> &Self::Ty

Accesses the F field in the V variant by reference, without checking that the enum is currently the V variant.

impl<T, __V, __F, __Ty> GetVariantFieldMut<TStr<__V>, __F> for FieldCloner<T>

where FieldCloner<T>: Sized, T: GetVariantFieldMut<TStr<__V>, __F, Ty = __Ty>,

fn get_vfield_mut_(&mut self, vname: TStr<__V>, fname: __F) -> Option<&mut __Ty>

Accesses the F field in the V variant by mutable reference.

unsafe fn get_vfield_raw_mut_( this: *mut (), vname: TStr<__V>, fname: __F, ) -> Option<NonNull<__Ty>>

where Self: Sized,

Accesses the F field in the V variant by raw pointer.

fn get_vfield_raw_mut_unchecked_fn(&self) -> GetFieldRawMutFn<__F, __Ty>

Gets a function pointer to the get_vfield_raw_mut_unchecked method.

fn get_vfield_raw_mut_fn(&self) -> GetVFieldRawMutFn<TStr<__V>, __F, __Ty>

Gets a function pointer to the get_vfield_raw_mut_ method.

unsafe fn get_vfield_mut_unchecked( &mut self, variant: V, field: F, ) -> &mut Self::Ty

Accesses the F field in the V variant by mutable reference, without checking that the enum is currently the V variant.

unsafe fn get_vfield_raw_mut_unchecked(ptr: *mut (), field: F) -> *mut Self::Ty

where Self: Sized, V: ConstDefault,

Accesses the F field in the V variant by raw pointer, without checking that the enum is currently the V variant.

impl<T: Hash> Hash for FieldCloner<T>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T, P> IntoField<P> for FieldCloner<T>

where T: GetField<P>, T::Ty: Clone,

fn into_field_(self, path: P) -> Self::Ty

Converts this into the field by value.

unsafe fn move_out_field_( &mut self, path: P, _: &mut MovedOutFields, ) -> Self::Ty

Moves out the field from self.

impl<T, V, F> IntoVariantField<TStr<V>, F> for FieldCloner<T>

where T: GetVariantField<TStr<V>, F>, T::Ty: Clone,

fn into_vfield_(self, variant_name: TStr<V>, field_name: F) -> Option<Self::Ty>

Converts this into the F field in the V variant by value.

unsafe fn move_out_vfield_( &mut self, variant_name: TStr<V>, field_name: F, _: &mut MovedOutFields, ) -> Option<Self::Ty>

Moves out the F field from the V variant.

unsafe fn into_vfield_unchecked_( self, variant_name: V, field_name: F, ) -> Self::Ty

where Self: Sized,

Converts this into the F field in the V variant by value.

unsafe fn move_out_vfield_unchecked_( &mut self, variant_name: V, field_name: F, moved_fields: &mut MovedOutFields, ) -> Self::Ty

Converts this into the F field in the V variant by value, without checking that the enum is currently the V variant.

impl<T, __V> IsVariant<TStr<__V>> for FieldCloner<T>

where T: IsVariant<TStr<__V>>,

fn is_variant_(&self, name: TStr<__V>) -> bool

Checks whether this enum is the variant that V stands for.

impl<T: Ord> Ord for FieldCloner<T>

fn cmp(&self, other: &FieldCloner<T>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<T: PartialEq> PartialEq for FieldCloner<T>

fn eq(&self, other: &FieldCloner<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: PartialOrd> PartialOrd for FieldCloner<T>

fn partial_cmp(&self, other: &FieldCloner<T>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T, __From, __Err> TryFromStructural<__From> for FieldCloner<T>

where T: TryFromStructural<__From, Error = __Err>,

type Error = __Err

The error parameter of TryFromError, returned from try_into_structural on conversion error.

fn try_from_structural( from: __From, ) -> Result<Self, TryFromError<__From, __Err>>

Performs the conversion

impl<T> VariantCount for FieldCloner<T>

where T: VariantCount,

type Count = <T as VariantCount>::Count

This is a TStr (eg:TS!(3)) representing the amount of variants of the enum.

impl<T: Copy> Copy for FieldCloner<T>

impl<T: Eq> Eq for FieldCloner<T>

impl<T> Structural for FieldCloner<T>

where T: Structural,

impl<T> StructuralPartialEq for FieldCloner<T>