Enum HasManyModel 

pub enum HasManyModel<E>
where
    E: EntityTrait,
{
    NotSet,
    Replace(Vec<<E as EntityTrait>::ActiveModelEx>),
    Append(Vec<<E as EntityTrait>::ActiveModelEx>),
}

Container for 1-N or M-N related Models

Variants

NotSet

Unspecified value, do nothing

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

Replace all items with this value set; delete leftovers

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

Add new items to this has many relation; do not delete

Implementations

impl<E> HasManyModel<E>

where E: EntityTrait,

pub fn take(&mut self) -> HasManyModel<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) -> HasManyModel<E>

Returns an empty container of self

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

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

Push an item to self

pub fn append<AM>(&mut self, model: AM) -> &mut HasManyModel<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 HasManyModel<E>

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

Replace all items in this set

pub fn convert_to_append(&mut self) -> &mut HasManyModel<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 HasManyModel<E>

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

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<E> Debug for HasManyModel<E>

where E: Debug + 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 HasManyModel<E>

where E: EntityTrait,

fn default() -> HasManyModel<E>

Returns the “default value” for a type.

impl<E> From<Vec<<E as EntityTrait>::ActiveModelEx>> for HasManyModel<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>) -> HasManyModel<E>

Converts to this type from the input type.

impl<E> Index<usize> for HasManyModel<E>

where E: EntityTrait,

type Output = <E as EntityTrait>::ActiveModelEx

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<E> IndexMut<usize> for HasManyModel<E>

where E: EntityTrait,

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

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

impl<E> IntoIterator for HasManyModel<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) -> <HasManyModel<E> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<E> PartialEq for HasManyModel<E>

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

fn eq(&self, other: &HasManyModel<E>) -> 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<E> Eq for HasManyModel<E>

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