Enum ActiveHasMany 

#[non_exhaustive]
pub enum ActiveHasMany<E>
where
    E: EntityTrait,
{
    NotSet,
    Replace(Vec<<E as EntityTrait>::ActiveModelEx>),
    Append(Vec<<E as EntityTrait>::ActiveModelEx>),
}

State carried by a has_many (or many-to-many) field on an ActiveModelEx. Chooses between “leave alone”, “additive write”, and “destructive replace” semantics.

Unstable: nested-ActiveModel relation mutation is exempt from semver — the semantics of replacing or removing related records may change in a minor (2.x) release.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

NotSet

Field is absent; existing related models are left as-is on save.

Replace(Vec<<E as EntityTrait>::ActiveModelEx>)

Persist exactly this list of related models, deleting any existing children that are not in the list.

Append(Vec<<E as EntityTrait>::ActiveModelEx>)

Persist these related models alongside any existing children; never deletes.

Implementations

impl<E> ActiveHasMany<E>

where E: EntityTrait,

pub fn take(&mut self) -> ActiveHasMany<E>

Take ownership of the models, leaving NotSet in place

pub fn as_slice(&self) -> &[<E as EntityTrait>::ActiveModelEx]

Borrow models as slice

pub fn as_mut_vec(&mut self) -> &mut Vec<<E as EntityTrait>::ActiveModelEx>

Get a mutable vec. If self is NotSet, convert to append.

pub fn into_vec(self) -> Vec<<E as EntityTrait>::ActiveModelEx>

Consume self as vector

pub fn empty_holder(&self) -> ActiveHasMany<E>

Returns an empty container of self

pub fn push<AM>(&mut self, model: AM) -> &mut ActiveHasMany<E>

where AM: Into<<E as EntityTrait>::ActiveModelEx>,

Push an item to self

pub fn append<AM>(&mut self, model: AM) -> &mut ActiveHasMany<E>

where AM: Into<<E as EntityTrait>::ActiveModelEx>,

Push an item to self, but convert Replace to Append

pub fn replace_all<I>(&mut self, models: I) -> &mut ActiveHasMany<E>

where I: IntoIterator<Item = <E as EntityTrait>::ActiveModelEx>,

Replace all items in this set

pub fn convert_to_append(&mut self) -> &mut ActiveHasMany<E>

Convert self to Append, if set

pub fn not_set(&mut self)

Reset self to NotSet

pub fn is_replace(&self) -> bool

If self is Replace

pub fn is_append(&self) -> bool

If self is Append

pub fn is_changed(&self) -> bool

Return true if self is Replace or any containing model is changed

pub fn find(&self, model: &<E as EntityTrait>::Model) -> bool

Find within the models by primary key, return true if found

pub fn try_into_model(self) -> Result<HasMany<E>, DbErr>

where <E as EntityTrait>::ActiveModelEx: TryIntoModel<<E as EntityTrait>::ModelEx>,

Convert this back to a ModelEx container

Trait Implementations

impl<E> Clone for ActiveHasMany<E>

where E: EntityTrait, <E as EntityTrait>::ActiveModelEx: Clone,

fn clone(&self) -> ActiveHasMany<E>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<E> Debug for ActiveHasMany<E>

where E: EntityTrait, <E as EntityTrait>::ActiveModelEx: Debug,

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

Formats the value using the given formatter.

impl<E> Default for ActiveHasMany<E>

where E: EntityTrait,

fn default() -> ActiveHasMany<E>

Returns the “default value” for a type.

impl<E> Eq for ActiveHasMany<E>

where E: EntityTrait, <E as EntityTrait>::ActiveModelEx: Eq,

impl<E> From<ActiveHasMany<E>> for Option<Vec<<E as EntityTrait>::ActiveModelEx>>

where E: EntityTrait,

fn from( value: ActiveHasMany<E>, ) -> Option<Vec<<E as EntityTrait>::ActiveModelEx>>

Converts to this type from the input type.

impl<E> From<Vec<<E as EntityTrait>::ActiveModelEx>> for ActiveHasMany<E>

where E: EntityTrait,

Converts from a set of models into Append, which performs non-destructive action

fn from(value: Vec<<E as EntityTrait>::ActiveModelEx>) -> ActiveHasMany<E>

Converts to this type from the input type.

impl<E> Index<usize> for ActiveHasMany<E>

where E: EntityTrait,

type Output = <E as EntityTrait>::ActiveModelEx

The returned type after indexing.

fn index(&self, index: usize) -> &<ActiveHasMany<E> as Index<usize>>::Output

Performs the indexing (container[index]) operation.

impl<E> IndexMut<usize> for ActiveHasMany<E>

where E: EntityTrait,

fn index_mut( &mut self, index: usize, ) -> &mut <ActiveHasMany<E> as Index<usize>>::Output

Performs the mutable indexing (container[index]) operation.

impl<E> IntoIterator for ActiveHasMany<E>

where E: EntityTrait,

type Item = <E as EntityTrait>::ActiveModelEx

The type of the elements being iterated over.

type IntoIter = IntoIter<<E as EntityTrait>::ActiveModelEx>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <ActiveHasMany<E> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<E> PartialEq for ActiveHasMany<E>

where E: EntityTrait, <E as EntityTrait>::ActiveModelEx: PartialEq,

fn eq(&self, __other: &ActiveHasMany<E>) -> bool

Equality operator ==.

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

Inequality operator !=.