Struct bonsaidb_core::admin::PermissionGroup  
source · pub struct PermissionGroup {
    pub name: String,
    pub statements: Vec<Statement>,
}Expand description
A named group of permissions statements.
Fields§
§name: StringThe name of the group. Must be unique.
statements: Vec<Statement>The permission statements.
Implementations§
source§impl PermissionGroup
 
impl PermissionGroup
sourcepub fn named<S: Into<String>>(name: S) -> Self
 
pub fn named<S: Into<String>>(name: S) -> Self
Returns a new group with no statements and the name provided.
sourcepub fn with_group_ids<I: IntoIterator<Item = Statement>>(
    self,
    statements: I
) -> Self
 
pub fn with_group_ids<I: IntoIterator<Item = Statement>>( self, statements: I ) -> Self
Builder-style method. Returns self after replacing the current statements with statements.
Trait Implementations§
source§impl Clone for PermissionGroup
 
impl Clone for PermissionGroup
source§fn clone(&self) -> PermissionGroup
 
fn clone(&self) -> PermissionGroup
Returns a copy of the value. Read more
1.0.0 · source§fn clone_from(&mut self, source: &Self)
 
fn clone_from(&mut self, source: &Self)
Performs copy-assignment from 
source. Read moresource§impl Collection for PermissionGroup
 
impl Collection for PermissionGroup
§type PrimaryKey = u64
 
type PrimaryKey = u64
The unique id type. Each document stored in a collection will be
uniquely identified by this type. Read more
source§fn collection_name() -> CollectionName
 
fn collection_name() -> CollectionName
The unique name of this collection. Each collection must be uniquely
named within the 
Schema it is registered
within.source§impl Debug for PermissionGroup
 
impl Debug for PermissionGroup
source§impl DefaultSerialization for PermissionGroup
 
impl DefaultSerialization for PermissionGroup
source§fn natural_id(&self) -> Option<Self::PrimaryKey>
 
fn natural_id(&self) -> Option<Self::PrimaryKey>
Returns the natural identifier of 
contents. This is called when
pushing values into a collection, before attempting to automatically
assign a unique id.source§impl<'de> Deserialize<'de> for PermissionGroup
 
impl<'de> Deserialize<'de> for PermissionGroup
source§fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where
    __D: Deserializer<'de>,
 
fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where
    __D: Deserializer<'de>,
Deserialize this value from the given Serde deserializer. Read more
source§impl NamedCollection for PermissionGroup
 
impl NamedCollection for PermissionGroup
§type ByNameView = ByName
 
type ByNameView = ByName
The name view defined for the collection.
source§fn load<'name, N: Nameable<'name, Self::PrimaryKey> + Send + Sync, C: Connection>(
    id: N,
    connection: &C
) -> Result<Option<CollectionDocument<Self>>, Error>where
    Self: SerializedCollection + Sized + 'static,
 
fn load<'name, N: Nameable<'name, Self::PrimaryKey> + Send + Sync, C: Connection>(
    id: N,
    connection: &C
) -> Result<Option<CollectionDocument<Self>>, Error>where
    Self: SerializedCollection + Sized + 'static,
source§fn load_async<'name, 'life0, 'async_trait, N, C>(
    id: N,
    connection: &'life0 C
) -> Pin<Box<dyn Future<Output = Result<Option<CollectionDocument<Self>>, Error>> + Send + 'async_trait>>where
    Self: SerializedCollection + Sized + 'static + Send + 'async_trait,
    N: 'async_trait + Nameable<'name, Self::PrimaryKey> + Send + Sync,
    C: 'async_trait + AsyncConnection,
    'name: 'async_trait,
    'life0: 'async_trait,
 
fn load_async<'name, 'life0, 'async_trait, N, C>(
    id: N,
    connection: &'life0 C
) -> Pin<Box<dyn Future<Output = Result<Option<CollectionDocument<Self>>, Error>> + Send + 'async_trait>>where
    Self: SerializedCollection + Sized + 'static + Send + 'async_trait,
    N: 'async_trait + Nameable<'name, Self::PrimaryKey> + Send + Sync,
    C: 'async_trait + AsyncConnection,
    'name: 'async_trait,
    'life0: 'async_trait,
source§fn entry<'connection, 'name, N: Into<NamedReference<'name, Self::PrimaryKey>> + Send + Sync, C: Connection>(
    id: N,
    connection: &'connection C
) -> Entry<'connection, 'name, C, Self, (), ()>where
    Self: SerializedCollection + Sized,
 
fn entry<'connection, 'name, N: Into<NamedReference<'name, Self::PrimaryKey>> + Send + Sync, C: Connection>(
    id: N,
    connection: &'connection C
) -> Entry<'connection, 'name, C, Self, (), ()>where
    Self: SerializedCollection + Sized,
source§fn entry_async<'connection, 'name, N: Into<NamedReference<'name, Self::PrimaryKey>> + Send + Sync, C: AsyncConnection>(
    id: N,
    connection: &'connection C
) -> AsyncEntry<'connection, 'name, C, Self, (), ()> ⓘwhere
    Self: SerializedCollection + Sized,
 
fn entry_async<'connection, 'name, N: Into<NamedReference<'name, Self::PrimaryKey>> + Send + Sync, C: AsyncConnection>(
    id: N,
    connection: &'connection C
) -> AsyncEntry<'connection, 'name, C, Self, (), ()> ⓘwhere
    Self: SerializedCollection + Sized,
source§fn load_document<'name, N: Nameable<'name, Self::PrimaryKey> + Send + Sync, C: Connection>(
    name: N,
    connection: &C
) -> Result<Option<OwnedDocument>, Error>where
    Self: SerializedCollection + Sized,
 
fn load_document<'name, N: Nameable<'name, Self::PrimaryKey> + Send + Sync, C: Connection>(
    name: N,
    connection: &C
) -> Result<Option<OwnedDocument>, Error>where
    Self: SerializedCollection + Sized,
Loads a document from this collection by name, if applicable. Return
Ok(None) if unsupported.source§fn load_document_async<'name, 'life0, 'async_trait, N, C>(
    name: N,
    connection: &'life0 C
) -> Pin<Box<dyn Future<Output = Result<Option<OwnedDocument>, Error>> + Send + 'async_trait>>where
    Self: SerializedCollection + Sized + Send + 'async_trait,
    N: 'async_trait + Nameable<'name, Self::PrimaryKey> + Send + Sync,
    C: 'async_trait + AsyncConnection,
    'name: 'async_trait,
    'life0: 'async_trait,
 
fn load_document_async<'name, 'life0, 'async_trait, N, C>(
    name: N,
    connection: &'life0 C
) -> Pin<Box<dyn Future<Output = Result<Option<OwnedDocument>, Error>> + Send + 'async_trait>>where
    Self: SerializedCollection + Sized + Send + 'async_trait,
    N: 'async_trait + Nameable<'name, Self::PrimaryKey> + Send + Sync,
    C: 'async_trait + AsyncConnection,
    'name: 'async_trait,
    'life0: 'async_trait,
Loads a document from this collection by name, if applicable. Return
Ok(None) if unsupported.source§fn delete_by_name<C: Connection>(
    name: &str,
    connection: &C
) -> Result<bool, Error>where
    Self: SerializedCollection + Sized,
 
fn delete_by_name<C: Connection>(
    name: &str,
    connection: &C
) -> Result<bool, Error>where
    Self: SerializedCollection + Sized,
Deletes a document by its name. Returns true if a document was deleted.
source§fn delete_by_name_async<'life0, 'life1, 'async_trait, C>(
    name: &'life0 str,
    connection: &'life1 C
) -> Pin<Box<dyn Future<Output = Result<bool, Error>> + Send + 'async_trait>>where
    Self: SerializedCollection + Sized + Send + 'async_trait,
    C: 'async_trait + AsyncConnection,
    'life0: 'async_trait,
    'life1: 'async_trait,
 
fn delete_by_name_async<'life0, 'life1, 'async_trait, C>(
    name: &'life0 str,
    connection: &'life1 C
) -> Pin<Box<dyn Future<Output = Result<bool, Error>> + Send + 'async_trait>>where
    Self: SerializedCollection + Sized + Send + 'async_trait,
    C: 'async_trait + AsyncConnection,
    'life0: 'async_trait,
    'life1: 'async_trait,
Deletes a document by its name. Returns true if a document was deleted.
Auto Trait Implementations§
impl RefUnwindSafe for PermissionGroup
impl Send for PermissionGroup
impl Sync for PermissionGroup
impl Unpin for PermissionGroup
impl UnwindSafe for PermissionGroup
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
    T: ?Sized,
 
impl<T> BorrowMut<T> for Twhere
    T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
 
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
§impl<T> Instrument for T
 
impl<T> Instrument for T
§fn instrument(self, span: Span) -> Instrumented<Self>
 
fn instrument(self, span: Span) -> Instrumented<Self>
§fn in_current_span(self) -> Instrumented<Self>
 
fn in_current_span(self) -> Instrumented<Self>
source§impl<T> Schema for Twhere
    T: Collection + 'static,
 
impl<T> Schema for Twhere
    T: Collection + 'static,
source§fn schema_name() -> SchemaName
 
fn schema_name() -> SchemaName
Returns the unique 
SchemaName for this schema.source§impl<T> SerializedCollection for T
 
impl<T> SerializedCollection for T
source§fn format() -> <T as SerializedCollection>::Format
 
fn format() -> <T as SerializedCollection>::Format
Returns the configured instance of 
Self::Format.source§fn natural_id(
    contents: &<T as SerializedCollection>::Contents
) -> Option<<T as Collection>::PrimaryKey>
 
fn natural_id( contents: &<T as SerializedCollection>::Contents ) -> Option<<T as Collection>::PrimaryKey>
Returns the natural identifier of 
contents. This is called when
pushing values into a collection, before attempting to automatically
assign a unique id.source§fn deserialize(data: &[u8]) -> Result<Self::Contents, Error>
 
fn deserialize(data: &[u8]) -> Result<Self::Contents, Error>
Deserialize 
data as Self::Contents using this collection’s format.source§fn document_contents<D: Document<Self>>(
    doc: &D
) -> Result<Self::Contents, Error>where
    Self: Sized,
 
fn document_contents<D: Document<Self>>(
    doc: &D
) -> Result<Self::Contents, Error>where
    Self: Sized,
Returns the deserialized contents of 
doc.source§fn set_document_contents<D: Document<Self>>(
    doc: &mut D,
    contents: Self::Contents
) -> Result<(), Error>where
    Self: Sized,
 
fn set_document_contents<D: Document<Self>>(
    doc: &mut D,
    contents: Self::Contents
) -> Result<(), Error>where
    Self: Sized,
Sets the contents of 
doc to contents.source§fn serialize(item: &Self::Contents) -> Result<Vec<u8>, Error>
 
fn serialize(item: &Self::Contents) -> Result<Vec<u8>, Error>
Serialize 
item using this collection’s format.source§fn get<C, PrimaryKey>(
    id: &PrimaryKey,
    connection: &C
) -> Result<Option<CollectionDocument<Self>>, Error>
 
fn get<C, PrimaryKey>( id: &PrimaryKey, connection: &C ) -> Result<Option<CollectionDocument<Self>>, Error>
source§fn get_async<'life0, 'life1, 'async_trait, C, PrimaryKey>(
    id: &'life0 PrimaryKey,
    connection: &'life1 C
) -> Pin<Box<dyn Future<Output = Result<Option<CollectionDocument<Self>>, Error>> + Send + 'async_trait>>where
    C: AsyncConnection + 'async_trait,
    PrimaryKey: KeyEncoding<Self::PrimaryKey> + 'async_trait,
    Self: Sized + Send + 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
 
fn get_async<'life0, 'life1, 'async_trait, C, PrimaryKey>(
    id: &'life0 PrimaryKey,
    connection: &'life1 C
) -> Pin<Box<dyn Future<Output = Result<Option<CollectionDocument<Self>>, Error>> + Send + 'async_trait>>where
    C: AsyncConnection + 'async_trait,
    PrimaryKey: KeyEncoding<Self::PrimaryKey> + 'async_trait,
    Self: Sized + Send + 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
source§fn get_multiple<'id, C, DocumentIds, PrimaryKey, I>(
    ids: DocumentIds,
    connection: &C
) -> Result<Vec<CollectionDocument<Self>>, Error>where
    C: Connection,
    DocumentIds: IntoIterator<Item = &'id PrimaryKey, IntoIter = I> + Send + Sync,
    I: Iterator<Item = &'id PrimaryKey> + Send + Sync,
    PrimaryKey: KeyEncoding<Self::PrimaryKey> + 'id,
    Self: Sized,
 
fn get_multiple<'id, C, DocumentIds, PrimaryKey, I>(
    ids: DocumentIds,
    connection: &C
) -> Result<Vec<CollectionDocument<Self>>, Error>where
    C: Connection,
    DocumentIds: IntoIterator<Item = &'id PrimaryKey, IntoIter = I> + Send + Sync,
    I: Iterator<Item = &'id PrimaryKey> + Send + Sync,
    PrimaryKey: KeyEncoding<Self::PrimaryKey> + 'id,
    Self: Sized,
Retrieves all documents matching 
ids. Documents that are not found
are not returned, but no error will be generated. Read moresource§fn get_multiple_async<'id, 'life0, 'async_trait, C, DocumentIds, PrimaryKey, I>(
    ids: DocumentIds,
    connection: &'life0 C
) -> Pin<Box<dyn Future<Output = Result<Vec<CollectionDocument<Self>>, Error>> + Send + 'async_trait>>where
    C: AsyncConnection + 'async_trait,
    DocumentIds: IntoIterator<Item = &'id PrimaryKey, IntoIter = I> + Send + Sync + 'async_trait,
    I: Iterator<Item = &'id PrimaryKey> + Send + Sync + 'async_trait,
    PrimaryKey: KeyEncoding<Self::PrimaryKey> + 'id + 'async_trait,
    Self: Sized + Send + 'async_trait,
    'id: 'async_trait,
    'life0: 'async_trait,
 
fn get_multiple_async<'id, 'life0, 'async_trait, C, DocumentIds, PrimaryKey, I>(
    ids: DocumentIds,
    connection: &'life0 C
) -> Pin<Box<dyn Future<Output = Result<Vec<CollectionDocument<Self>>, Error>> + Send + 'async_trait>>where
    C: AsyncConnection + 'async_trait,
    DocumentIds: IntoIterator<Item = &'id PrimaryKey, IntoIter = I> + Send + Sync + 'async_trait,
    I: Iterator<Item = &'id PrimaryKey> + Send + Sync + 'async_trait,
    PrimaryKey: KeyEncoding<Self::PrimaryKey> + 'id + 'async_trait,
    Self: Sized + Send + 'async_trait,
    'id: 'async_trait,
    'life0: 'async_trait,
Retrieves all documents matching 
ids. Documents that are not found
are not returned, but no error will be generated. Read moresource§fn list<'id, R, PrimaryKey, C>(
    ids: R,
    connection: &'id C
) -> List<'id, C, Self, PrimaryKey>where
    R: Into<RangeRef<'id, Self::PrimaryKey, PrimaryKey>>,
    C: Connection,
    PrimaryKey: KeyEncoding<Self::PrimaryKey> + PartialEq + 'id,
    Self::PrimaryKey: Borrow<PrimaryKey> + PartialEq<PrimaryKey>,
    Self: Sized,
 
fn list<'id, R, PrimaryKey, C>(
    ids: R,
    connection: &'id C
) -> List<'id, C, Self, PrimaryKey>where
    R: Into<RangeRef<'id, Self::PrimaryKey, PrimaryKey>>,
    C: Connection,
    PrimaryKey: KeyEncoding<Self::PrimaryKey> + PartialEq + 'id,
    Self::PrimaryKey: Borrow<PrimaryKey> + PartialEq<PrimaryKey>,
    Self: Sized,
Retrieves all documents matching the range of 
ids. Read moresource§fn list_async<'id, R, PrimaryKey, C>(
    ids: R,
    connection: &'id C
) -> AsyncList<'id, C, Self, PrimaryKey> ⓘwhere
    R: Into<RangeRef<'id, Self::PrimaryKey, PrimaryKey>>,
    C: AsyncConnection,
    PrimaryKey: KeyEncoding<Self::PrimaryKey> + PartialEq + 'id + ?Sized,
    Self::PrimaryKey: Borrow<PrimaryKey> + PartialEq<PrimaryKey>,
    Self: Sized,
 
fn list_async<'id, R, PrimaryKey, C>(
    ids: R,
    connection: &'id C
) -> AsyncList<'id, C, Self, PrimaryKey> ⓘwhere
    R: Into<RangeRef<'id, Self::PrimaryKey, PrimaryKey>>,
    C: AsyncConnection,
    PrimaryKey: KeyEncoding<Self::PrimaryKey> + PartialEq + 'id + ?Sized,
    Self::PrimaryKey: Borrow<PrimaryKey> + PartialEq<PrimaryKey>,
    Self: Sized,
Retrieves all documents matching the range of 
ids. Read moresource§fn list_with_prefix<'a, PrimaryKey, C>(
    prefix: &'a PrimaryKey,
    connection: &'a C
) -> List<'a, C, Self, PrimaryKey>where
    C: Connection,
    Self: Sized,
    PrimaryKey: IntoPrefixRange<'a, Self::PrimaryKey> + KeyEncoding<Self::PrimaryKey> + PartialEq + ?Sized,
    Self::PrimaryKey: Borrow<PrimaryKey> + PartialEq<PrimaryKey>,
 
fn list_with_prefix<'a, PrimaryKey, C>(
    prefix: &'a PrimaryKey,
    connection: &'a C
) -> List<'a, C, Self, PrimaryKey>where
    C: Connection,
    Self: Sized,
    PrimaryKey: IntoPrefixRange<'a, Self::PrimaryKey> + KeyEncoding<Self::PrimaryKey> + PartialEq + ?Sized,
    Self::PrimaryKey: Borrow<PrimaryKey> + PartialEq<PrimaryKey>,
Retrieves all documents with ids that start with 
prefix. Read moresource§fn list_with_prefix_async<'a, PrimaryKey, C>(
    prefix: &'a PrimaryKey,
    connection: &'a C
) -> AsyncList<'a, C, Self, PrimaryKey> ⓘwhere
    C: AsyncConnection,
    Self: Sized,
    PrimaryKey: IntoPrefixRange<'a, Self::PrimaryKey> + KeyEncoding<Self::PrimaryKey> + PartialEq + ?Sized,
    Self::PrimaryKey: Borrow<PrimaryKey> + PartialEq<PrimaryKey>,
 
fn list_with_prefix_async<'a, PrimaryKey, C>(
    prefix: &'a PrimaryKey,
    connection: &'a C
) -> AsyncList<'a, C, Self, PrimaryKey> ⓘwhere
    C: AsyncConnection,
    Self: Sized,
    PrimaryKey: IntoPrefixRange<'a, Self::PrimaryKey> + KeyEncoding<Self::PrimaryKey> + PartialEq + ?Sized,
    Self::PrimaryKey: Borrow<PrimaryKey> + PartialEq<PrimaryKey>,
Retrieves all documents with ids that start with 
prefix. Read moresource§fn all<C: Connection>(connection: &C) -> List<'_, C, Self, Self::PrimaryKey>where
    Self: Sized,
 
fn all<C: Connection>(connection: &C) -> List<'_, C, Self, Self::PrimaryKey>where
    Self: Sized,
Retrieves all documents. Read more
source§fn all_async<C: AsyncConnection>(
    connection: &C
) -> AsyncList<'_, C, Self, Self::PrimaryKey> ⓘwhere
    Self: Sized,
 
fn all_async<C: AsyncConnection>(
    connection: &C
) -> AsyncList<'_, C, Self, Self::PrimaryKey> ⓘwhere
    Self: Sized,
Retrieves all documents. Read more
source§fn push<Cn: Connection>(
    contents: Self::Contents,
    connection: &Cn
) -> Result<CollectionDocument<Self>, InsertError<Self::Contents>>where
    Self: Sized + 'static,
 
fn push<Cn: Connection>(
    contents: Self::Contents,
    connection: &Cn
) -> Result<CollectionDocument<Self>, InsertError<Self::Contents>>where
    Self: Sized + 'static,
Pushes this value into the collection, returning the created document.
This function is useful when 
Self != Self::Contents. Read moresource§fn push_async<'life0, 'async_trait, Cn>(
    contents: Self::Contents,
    connection: &'life0 Cn
) -> Pin<Box<dyn Future<Output = Result<CollectionDocument<Self>, InsertError<Self::Contents>>> + Send + 'async_trait>>where
    Self: Sized + 'static + Send + 'async_trait,
    Self::Contents: 'async_trait,
    Cn: 'async_trait + AsyncConnection,
    'life0: 'async_trait,
 
fn push_async<'life0, 'async_trait, Cn>(
    contents: Self::Contents,
    connection: &'life0 Cn
) -> Pin<Box<dyn Future<Output = Result<CollectionDocument<Self>, InsertError<Self::Contents>>> + Send + 'async_trait>>where
    Self: Sized + 'static + Send + 'async_trait,
    Self::Contents: 'async_trait,
    Cn: 'async_trait + AsyncConnection,
    'life0: 'async_trait,
Pushes this value into the collection, returning the created document.
This function is useful when 
Self != Self::Contents. Read moresource§fn push_all<Contents: IntoIterator<Item = Self::Contents>, Cn: Connection>(
    contents: Contents,
    connection: &Cn
) -> Result<Vec<CollectionDocument<Self>>, Error>
 
fn push_all<Contents: IntoIterator<Item = Self::Contents>, Cn: Connection>( contents: Contents, connection: &Cn ) -> Result<Vec<CollectionDocument<Self>>, Error>
Pushes all 
contents in a single transaction. If successful, all
collection documents will be returned. If an error occurs during this
operation, no documents will be pushed. Read moresource§fn push_all_async<'life0, 'async_trait, Contents, Cn>(
    contents: Contents,
    connection: &'life0 Cn
) -> Pin<Box<dyn Future<Output = Result<Vec<CollectionDocument<Self>>, Error>> + Send + 'async_trait>>where
    Self: Sized + 'static + Send + 'async_trait,
    Self::PrimaryKey: Default,
    Contents::IntoIter: Send,
    Contents: 'async_trait + IntoIterator<Item = Self::Contents> + Send,
    Cn: 'async_trait + AsyncConnection,
    'life0: 'async_trait,
 
fn push_all_async<'life0, 'async_trait, Contents, Cn>(
    contents: Contents,
    connection: &'life0 Cn
) -> Pin<Box<dyn Future<Output = Result<Vec<CollectionDocument<Self>>, Error>> + Send + 'async_trait>>where
    Self: Sized + 'static + Send + 'async_trait,
    Self::PrimaryKey: Default,
    Contents::IntoIter: Send,
    Contents: 'async_trait + IntoIterator<Item = Self::Contents> + Send,
    Cn: 'async_trait + AsyncConnection,
    'life0: 'async_trait,
Pushes all 
contents in a single transaction. If successful, all
collection documents will be returned. If an error occurs during this
operation, no documents will be pushed. Read moresource§fn push_into<Cn: Connection>(
    self,
    connection: &Cn
) -> Result<CollectionDocument<Self>, InsertError<Self>>where
    Self: SerializedCollection<Contents = Self> + Sized + 'static,
 
fn push_into<Cn: Connection>(
    self,
    connection: &Cn
) -> Result<CollectionDocument<Self>, InsertError<Self>>where
    Self: SerializedCollection<Contents = Self> + Sized + 'static,
Pushes this value into the collection, returning the created document. Read more
source§fn push_into_async<'life0, 'async_trait, Cn>(
    self,
    connection: &'life0 Cn
) -> Pin<Box<dyn Future<Output = Result<CollectionDocument<Self>, InsertError<Self>>> + Send + 'async_trait>>where
    Self: SerializedCollection<Contents = Self> + Sized + 'static + Send + 'async_trait,
    Cn: 'async_trait + AsyncConnection,
    'life0: 'async_trait,
 
fn push_into_async<'life0, 'async_trait, Cn>(
    self,
    connection: &'life0 Cn
) -> Pin<Box<dyn Future<Output = Result<CollectionDocument<Self>, InsertError<Self>>> + Send + 'async_trait>>where
    Self: SerializedCollection<Contents = Self> + Sized + 'static + Send + 'async_trait,
    Cn: 'async_trait + AsyncConnection,
    'life0: 'async_trait,
Pushes this value into the collection, returning the created document. Read more
source§fn push_in_transaction(
    &self,
    transaction: &mut Transaction
) -> Result<(), Error>where
    Self: SerializedCollection<Contents = Self> + Sized + 'static,
 
fn push_in_transaction(
    &self,
    transaction: &mut Transaction
) -> Result<(), Error>where
    Self: SerializedCollection<Contents = Self> + Sized + 'static,
source§fn insert<PrimaryKey, Cn>(
    id: &PrimaryKey,
    contents: Self::Contents,
    connection: &Cn
) -> Result<CollectionDocument<Self>, InsertError<Self::Contents>>
 
fn insert<PrimaryKey, Cn>( id: &PrimaryKey, contents: Self::Contents, connection: &Cn ) -> Result<CollectionDocument<Self>, InsertError<Self::Contents>>
Inserts this value into the collection with the specified id, returning
the created document. Read more
source§fn insert_async<'life0, 'life1, 'async_trait, PrimaryKey, Cn>(
    id: &'life0 PrimaryKey,
    contents: Self::Contents,
    connection: &'life1 Cn
) -> Pin<Box<dyn Future<Output = Result<CollectionDocument<Self>, InsertError<Self::Contents>>> + Send + 'async_trait>>where
    PrimaryKey: KeyEncoding<Self::PrimaryKey> + 'async_trait,
    Cn: AsyncConnection + 'async_trait,
    Self: Sized + 'static + Send + 'async_trait,
    Self::Contents: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
 
fn insert_async<'life0, 'life1, 'async_trait, PrimaryKey, Cn>(
    id: &'life0 PrimaryKey,
    contents: Self::Contents,
    connection: &'life1 Cn
) -> Pin<Box<dyn Future<Output = Result<CollectionDocument<Self>, InsertError<Self::Contents>>> + Send + 'async_trait>>where
    PrimaryKey: KeyEncoding<Self::PrimaryKey> + 'async_trait,
    Cn: AsyncConnection + 'async_trait,
    Self: Sized + 'static + Send + 'async_trait,
    Self::Contents: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
Inserts this value into the collection with the specified id, returning
the created document. Read more
source§fn insert_into<PrimaryKey, Cn>(
    self,
    id: &PrimaryKey,
    connection: &Cn
) -> Result<CollectionDocument<Self>, InsertError<Self>>where
    PrimaryKey: KeyEncoding<Self::PrimaryKey>,
    Cn: Connection,
    Self: SerializedCollection<Contents = Self> + Sized + 'static,
 
fn insert_into<PrimaryKey, Cn>(
    self,
    id: &PrimaryKey,
    connection: &Cn
) -> Result<CollectionDocument<Self>, InsertError<Self>>where
    PrimaryKey: KeyEncoding<Self::PrimaryKey>,
    Cn: Connection,
    Self: SerializedCollection<Contents = Self> + Sized + 'static,
Inserts this value into the collection with the given 
id, returning
the created document. Read moresource§fn insert_into_async<'life0, 'life1, 'async_trait, PrimaryKey, Cn>(
    self,
    id: &'life0 PrimaryKey,
    connection: &'life1 Cn
) -> Pin<Box<dyn Future<Output = Result<CollectionDocument<Self>, InsertError<Self>>> + Send + 'async_trait>>where
    PrimaryKey: KeyEncoding<Self::PrimaryKey> + 'async_trait,
    Cn: AsyncConnection + 'async_trait,
    Self: SerializedCollection<Contents = Self> + Sized + 'static + Send + 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
 
fn insert_into_async<'life0, 'life1, 'async_trait, PrimaryKey, Cn>(
    self,
    id: &'life0 PrimaryKey,
    connection: &'life1 Cn
) -> Pin<Box<dyn Future<Output = Result<CollectionDocument<Self>, InsertError<Self>>> + Send + 'async_trait>>where
    PrimaryKey: KeyEncoding<Self::PrimaryKey> + 'async_trait,
    Cn: AsyncConnection + 'async_trait,
    Self: SerializedCollection<Contents = Self> + Sized + 'static + Send + 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
Inserts this value into the collection with the given 
id, returning
the created document. Read moresource§fn insert_in_transaction(
    &self,
    key: &Self::PrimaryKey,
    transaction: &mut Transaction
) -> Result<(), Error>where
    Self: SerializedCollection<Contents = Self> + Sized + 'static,
 
fn insert_in_transaction(
    &self,
    key: &Self::PrimaryKey,
    transaction: &mut Transaction
) -> Result<(), Error>where
    Self: SerializedCollection<Contents = Self> + Sized + 'static,
source§fn overwrite<PrimaryKey, Cn>(
    id: &PrimaryKey,
    contents: Self::Contents,
    connection: &Cn
) -> Result<CollectionDocument<Self>, InsertError<Self::Contents>>
 
fn overwrite<PrimaryKey, Cn>( id: &PrimaryKey, contents: Self::Contents, connection: &Cn ) -> Result<CollectionDocument<Self>, InsertError<Self::Contents>>
Overwrites this value into the collection with the specified id, returning
the created or updated document. Read more
source§fn overwrite_async<'life0, 'life1, 'async_trait, PrimaryKey, Cn>(
    id: &'life0 PrimaryKey,
    contents: Self::Contents,
    connection: &'life1 Cn
) -> Pin<Box<dyn Future<Output = Result<CollectionDocument<Self>, InsertError<Self::Contents>>> + Send + 'async_trait>>where
    PrimaryKey: KeyEncoding<Self::PrimaryKey> + 'async_trait,
    Cn: AsyncConnection + 'async_trait,
    Self: Sized + 'static + Send + 'async_trait,
    Self::Contents: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
 
fn overwrite_async<'life0, 'life1, 'async_trait, PrimaryKey, Cn>(
    id: &'life0 PrimaryKey,
    contents: Self::Contents,
    connection: &'life1 Cn
) -> Pin<Box<dyn Future<Output = Result<CollectionDocument<Self>, InsertError<Self::Contents>>> + Send + 'async_trait>>where
    PrimaryKey: KeyEncoding<Self::PrimaryKey> + 'async_trait,
    Cn: AsyncConnection + 'async_trait,
    Self: Sized + 'static + Send + 'async_trait,
    Self::Contents: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
Overwrites this value into the collection with the specified id, returning
the created or updated document. Read more
source§fn overwrite_into<Cn: Connection, PrimaryKey>(
    self,
    id: &PrimaryKey,
    connection: &Cn
) -> Result<CollectionDocument<Self>, InsertError<Self>>where
    PrimaryKey: KeyEncoding<Self::PrimaryKey>,
    Self: SerializedCollection<Contents = Self> + Sized + 'static,
 
fn overwrite_into<Cn: Connection, PrimaryKey>(
    self,
    id: &PrimaryKey,
    connection: &Cn
) -> Result<CollectionDocument<Self>, InsertError<Self>>where
    PrimaryKey: KeyEncoding<Self::PrimaryKey>,
    Self: SerializedCollection<Contents = Self> + Sized + 'static,
Overwrites this value into the collection with the given 
id, returning
the created or updated document. Read moresource§fn overwrite_in_transaction<PrimaryKey>(
    &self,
    id: &PrimaryKey,
    transaction: &mut Transaction
) -> Result<(), Error>where
    PrimaryKey: KeyEncoding<Self::PrimaryKey>,
    Self: SerializedCollection<Contents = Self> + Sized + 'static,
 
fn overwrite_in_transaction<PrimaryKey>(
    &self,
    id: &PrimaryKey,
    transaction: &mut Transaction
) -> Result<(), Error>where
    PrimaryKey: KeyEncoding<Self::PrimaryKey>,
    Self: SerializedCollection<Contents = Self> + Sized + 'static,
source§fn overwrite_into_async<'life0, 'life1, 'async_trait, Cn, PrimaryKey>(
    self,
    id: &'life0 PrimaryKey,
    connection: &'life1 Cn
) -> Pin<Box<dyn Future<Output = Result<CollectionDocument<Self>, InsertError<Self>>> + Send + 'async_trait>>where
    PrimaryKey: KeyEncoding<Self::PrimaryKey> + 'async_trait,
    Self: SerializedCollection<Contents = Self> + Sized + 'static + Send + 'async_trait,
    Cn: 'async_trait + AsyncConnection,
    'life0: 'async_trait,
    'life1: 'async_trait,
 
fn overwrite_into_async<'life0, 'life1, 'async_trait, Cn, PrimaryKey>(
    self,
    id: &'life0 PrimaryKey,
    connection: &'life1 Cn
) -> Pin<Box<dyn Future<Output = Result<CollectionDocument<Self>, InsertError<Self>>> + Send + 'async_trait>>where
    PrimaryKey: KeyEncoding<Self::PrimaryKey> + 'async_trait,
    Self: SerializedCollection<Contents = Self> + Sized + 'static + Send + 'async_trait,
    Cn: 'async_trait + AsyncConnection,
    'life0: 'async_trait,
    'life1: 'async_trait,
Overwrites this value into the collection with the given 
id, returning
the created or updated document. Read more