Struct structural::NestedFieldPathSet

pub struct NestedFieldPathSet<F, S, U> { /* fields omitted */ }

Allows accessing multiple fields inside of some nested field.

This is most useful for accessing multiple fields inside of a (nested) enum.

This is the type that fp!(a.b => b, c, d) and fp!(::Foo => bar, baz, qux) construct.

Uniqueness

If the U type parameter is a:

• UniquePaths: all the field paths are unique, and this can be passed to StructuralExt::fields_mut and StructuralExt::into_fields.

• AliasedPaths: there might be repeated field paths. This cannot be passed to StructuralExt::fields_mut, because it might borrow the same field mutably twice. This can also not be passed to StructuralExt::into_fields, because a field cannot generally be moved out twice.

Construction

NestedFieldPathSet can be constructed in these ways:

• Using the fp macro.
  Example: fp!(::Foo=>a,b), this gets the a,and b fields from inside the Foo variant.
  Example: fp!(a.b=>uh,what), this gets the uh,and what fields from inside the a.b field.
  

• Constructing it from a NestedFieldPath and a FieldPathSet.
  Example: NestedFieldPathSet::new( fp!(a.b.c), fp!(foo,bar,baz) ), this gets the foo,bar,and baz fields from inside the a.b.c field.
  Example: NestedFieldPathSet::new( fp!(::Foo), fp!(a,b) ), this gets the a,and b fields from inside the Foo variant.

• Using the NEW associated constant, if F and S implements core_extensions::ConstDefault (reexported in structural::reexports::ConstDefault) Example: <FP!(::Foo=>a,b,c)>::NEW

Drop Types

To make all the inherent methods in this type const fn this type wraps the NestedFieldPath<F> inside a ManuallyDrop, which means that F won't be dropped inside. If that is a problem don't construct a NestedFieldPathSet with an F that owns some resource.

Examples

You can look for examples of using this in the multi-field StructuralExt methods, like fields,fields_mut,and into_fields (look for the enum examples).

Implementations

impl<F, S> NestedFieldPathSet<F, S, AliasedPaths> where
    F: ConstDefault,
    S: ConstDefault, 

pub const NEW: Self

Constructs a NestedFieldPathSet.

impl<F, S, U> NestedFieldPathSet<F, S, U> where
    F: ConstDefault,
    S: ConstDefault, 

pub const NEW_ALIASED: NestedFieldPathSet<F, S, AliasedPaths>

This can be used to construct a NestedFieldPathSet<T, UniquePaths> from a type alias, by doing unsafe{ FOO::NEW_ALIASED.upgrade_unchecked() } (read the docs for upgrade_unchecked first).

impl<F, S, U> NestedFieldPathSet<F, S, U>

pub const fn new(nested: F, set: FieldPathSet<S, U>) -> Self

Constructs a NestedFieldPathSet from an F and a FieldPathSet

pub const fn into_inner(self) -> (F, FieldPathSet<S, U>)

Unwraps a NestedFieldPathSet into a NestedFieldPath and a FieldPathSet

pub const fn into_nested(self) -> F

Unwraps a NestedFieldPathSet into the NestedFieldPath for the nested field.

pub const fn into_set(self) -> FieldPathSet<S, U>

Unwraps a NestedFieldPathSet into the FieldPathSet used to access the multiple fields inside a nested field.

impl<F, S> NestedFieldPathSet<F, S, UniquePaths>

pub const fn downgrade(self) -> NestedFieldPathSet<F, S, AliasedPaths>

Converts a NestedFieldPathSet<F, S, UniquePaths> to a NestedFieldPathSet<F, S, AliasedPaths>

impl<F, S> NestedFieldPathSet<F, S, AliasedPaths>

pub const unsafe fn upgrade_unchecked(
    self
) -> NestedFieldPathSet<F, S, UniquePaths>

Converts a NestedFieldPathSet<F, S, AliasedPaths> to a NestedFieldPathSet<F, S, UniquePaths>

Safety

You must ensure that all the field paths in in the S type parameter are unique, there must be no field path that is a prefix of any other field path.

pub const unsafe fn set_uniqueness<U>(self) -> NestedFieldPathSet<F, S, U>

Converts a NestedFieldPathSet<F, S, AliasedPaths> to a NestedFieldPathSet<F, S, U>

Safety

If U == UniquePaths, you must ensure that all the field paths in the S type parameter are unique, there must be no field path that is a prefix of any other field path.

Trait Implementations

impl<F: Clone, S: Clone, U: Clone> Clone for NestedFieldPathSet<F, S, U>

fn clone(&self) -> NestedFieldPathSet<F, S, U>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<F, S> ConstDefault for NestedFieldPathSet<F, S, AliasedPaths> where
    F: ConstDefault,
    S: ConstDefault, 

const DEFAULT: Self

The default value for Self.

impl<F: Copy, S: Copy, U: Copy> Copy for NestedFieldPathSet<F, S, U>

impl<F: Debug, S: Debug, U: Debug> Debug for NestedFieldPathSet<F, S, U>

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

Formats the value using the given formatter.

impl<F, S> Default for NestedFieldPathSet<F, S, AliasedPaths> where
    F: Default,
    S: Default, 

fn default() -> Self

Returns the "default value" for a type.

impl<F, S, U> IntoAliasing for NestedFieldPathSet<F, S, U>

type Output = NestedFieldPathSet<F, S, AliasedPaths>

The return value of this trait.

impl<F, S, U> IsMultiFieldPath for NestedFieldPathSet<F, S, U>

type PathUniqueness = U

Whether the paths in the set can contain duplicate paths.

impl<F, S, U> IsSingleFieldPath for NestedFieldPathSet<F, (S,), U>

impl<This, A, B, U> RevFieldErr<This> for NestedFieldPathSet<A, (B,), U> where
    This: ?Sized,
    A: RevFieldErr<This>,
    B: RevFieldErr<A::Ty>,
    (A::Err, B::Err): CombinedErrs, 

type Err = CombinedErrsOut<(A::Err, B::Err)>

The error returned by rev_* methods.

impl<This, A, B, U> RevFieldType<This> for NestedFieldPathSet<A, (B,), U> where
    This: ?Sized,
    A: RevFieldType<This>,
    B: RevFieldType<A::Ty>, 

type Ty = B::Ty

The type of the field.

impl<'a, This: ?Sized, A, B, U> RevGetFieldImpl<'a, This> for NestedFieldPathSet<A, (B,), U> where
    This: 'a,
    A: RevGetFieldImpl<'a, This>,
    B: RevGetFieldImpl<'a, A::Ty>,
    A::Ty: 'a,
    Self: RevFieldErr<This, Ty = B::Ty>,
    A::Err: IntoFieldErr<Self::Err>,
    B::Err: IntoFieldErr<Self::Err>, 

fn rev_get_field(self, this: &'a This) -> Result<&'a B::Ty, Self::Err>

Accesses the field that self represents inside of this,by reference.

impl<'a, This: ?Sized, A, B, U> RevGetFieldMutImpl<'a, This> for NestedFieldPathSet<A, (B,), U> where
    This: 'a,
    A: RevGetFieldMutImpl<'a, This>,
    B: RevGetFieldMutImpl<'a, A::Ty>,
    A::Ty: 'a,
    Self: RevFieldErr<This, Ty = B::Ty>,
    A::Err: IntoFieldErr<Self::Err>,
    B::Err: IntoFieldErr<Self::Err>, 

fn rev_get_field_mut(
    self,
    this: &'a mut This
) -> Result<&'a mut B::Ty, Self::Err>

Accesses the field that self represents inside of this,by mutable reference.

unsafe fn rev_get_field_raw_mut(
    self,
    this: *mut This
) -> Result<*mut B::Ty, Self::Err>

Accesses the field that self represents inside of this,by raw pointer.

impl<'a, F, S, U, This: ?Sized, Mid: ?Sized, OutTy, OutErr> RevGetMultiFieldImpl<'a, This> for NestedFieldPathSet<F, S, U> where
    F: RevGetFieldImpl<'a, This, Ty = Mid, Err = OutErr>,
    FieldPathSet<S, U>: RevGetMultiFieldImpl<'a, Mid, UnnormFields = OutTy>,
    OutErr: IsFieldErr,
    This: 'a,
    Mid: 'a,
    OutTy: 'a + NormalizeFields,
    NestedFieldPathSetOutput<OutTy, OutErr>: 'a + NormalizeFields, 

type UnnormFields = NestedFieldPathSetOutput<OutTy, OutErr>

A collection of Results<&'a _,_>s referencing fields.

fn rev_get_multi_field_impl(
    self,
    this: &'a This
) -> NestedFieldPathSetOutput<OutTy, OutErr>

Gets references to multiple fields from this.

impl<'a, F, S, This: ?Sized, Mid: ?Sized, OutTy, OutRawTy, OutErr> RevGetMultiFieldMutImpl<'a, This> for NestedFieldPathSet<F, S, UniquePaths> where
    F: RevGetFieldMutImpl<'a, This, Ty = Mid, Err = OutErr>,
    FieldPathSet<S, UniquePaths>: RevGetMultiFieldMutImpl<'a, Mid, UnnormFieldsMut = OutTy, UnnormFieldsRawMut = OutRawTy>,
    This: 'a,
    OutErr: IsFieldErr,
    Mid: 'a,
    OutTy: 'a + NormalizeFields,
    OutRawTy: 'a + NormalizeFields,
    NestedFieldPathSetOutput<OutTy, OutErr>: 'a + NormalizeFields,
    NestedFieldPathSetOutput<OutRawTy, OutErr>: 'a + NormalizeFields, 

type UnnormFieldsMut = NestedFieldPathSetOutput<OutTy, OutErr>

This is usually a tuple of Result<&mut _,E: IsFieldErr>s.

type UnnormFieldsRawMut = NestedFieldPathSetOutput<OutRawTy, OutErr>

This is usually a tuple of Result<*mut _,E: IsFieldErr>s.

fn rev_get_multi_field_mut_impl(
    self,
    this: &'a mut This
) -> NestedFieldPathSetOutput<OutTy, OutErr>

Gets mutable references to multiple fields from this, usually a tuple of Result<&mut _,E: IsFieldErr>s.

unsafe fn rev_get_multi_field_raw_mut_impl(
    self,
    this: *mut This
) -> NestedFieldPathSetOutput<OutRawTy, OutErr>

Gets raw pointers to multiple fields from this, usually a tuple of Result<*mut _,E: IsFieldErr>s.

impl<This, A, B, U> RevIntoFieldImpl<This> for NestedFieldPathSet<A, (B,), U> where
    This: ?Sized,
    A: RevIntoFieldImpl<This>,
    B: RevIntoFieldImpl<A::Ty>,
    A::Ty: Sized,
    Self: RevFieldErr<This, Ty = B::Ty>,
    A::Err: IntoFieldErr<Self::Err>,
    B::Err: IntoFieldErr<Self::Err>, 

fn rev_into_field(self, this: This) -> Result<B::Ty, Self::Err> where
    This: Sized,
    B::Ty: Sized, 

Accesses the field that self represents inside of this,by value.

impl<F, S, This, Mid, OutTy, OutErr> RevIntoMultiFieldImpl<This> for NestedFieldPathSet<F, S, UniquePaths> where
    F: RevIntoFieldImpl<This, Ty = Mid, Err = OutErr>,
    FieldPathSet<S, UniquePaths>: RevIntoMultiFieldImpl<Mid, UnnormIntoFields = OutTy>,
    OutTy: NormalizeFields,
    OutErr: IsFieldErr,
    NestedFieldPathSetOutput<OutTy, OutErr>: NormalizeFields, 

type UnnormIntoFields = NestedFieldPathSetOutput<OutTy, OutErr>

This is usually a tuple of Result<_, E: IsFieldErr>s.

fn rev_into_multi_field_impl(self, this: This) -> Self::UnnormIntoFields

Converts this into multiple fields by value, usually a tuple of Result<_, E: IsFieldErr>s.