Struct CollectionDocument

pub struct CollectionDocument<C>
where
    C: SerializedCollection,
{
    pub header: CollectionHeader<C::PrimaryKey>,
    pub contents: C::Contents,
}

A document with serializable contents.

Fields

header: CollectionHeader<C::PrimaryKey>

The header of the document, which contains the id and Revision.

contents: C::Contents

The document’s contents.

Implementations

impl<C> CollectionDocument<C>

where C: SerializedCollection,

pub fn update<Cn: Connection>(&mut self, connection: &Cn) -> Result<(), Error>

Updates the document stored in the database with the contents of this collection document.

if let Some(mut document) = MyCollection::get(&42, &db)? {
    // ... do something `document`
    document.update(&db)?;
    println!(
        "The document has been updated: {:?}",
        document.header.revision
    );
}

pub fn update_in_transaction( &self, transaction: &mut Transaction, ) -> Result<(), Error>

Pushes an update Operation to the transaction for this document.

The changes will happen once the transaction is applied.

pub async fn update_async<Cn: AsyncConnection>( &mut self, connection: &Cn, ) -> Result<(), Error>

Stores the new value of contents in the document.

if let Some(mut document) = MyCollection::get_async(&42, &db).await? {
    // modify the document
    document.update_async(&db).await?;
    println!("Updated revision: {:?}", document.header.revision);
}

pub fn modify<Cn: Connection, Modifier: FnMut(&mut Self) + Send + Sync>( &mut self, connection: &Cn, modifier: Modifier, ) -> Result<(), Error>

where C::Contents: Clone,

Modifies self, automatically retrying the modification if the document has been updated on the server.

Data loss warning

If you’ve modified self before calling this function and a conflict occurs, all changes to self will be lost when the current document is fetched before retrying the process again. When you use this function, you should limit the edits to the value to within the modifier callback.

pub async fn modify_async<Cn: AsyncConnection, Modifier: FnMut(&mut Self) + Send + Sync>( &mut self, connection: &Cn, modifier: Modifier, ) -> Result<(), Error>

where C::Contents: Clone,

Modifies self, automatically retrying the modification if the document has been updated on the server.

Data loss warning

If you’ve modified self before calling this function and a conflict occurs, all changes to self will be lost when the current document is fetched before retrying the process again. When you use this function, you should limit the edits to the value to within the modifier callback.

pub fn delete<Cn: Connection>(&self, connection: &Cn) -> Result<(), Error>

Removes the document from the collection.

if let Some(document) = MyCollection::get(&42, &db)? {
    document.delete(&db)?;
}

pub async fn delete_async<Cn: AsyncConnection>( &self, connection: &Cn, ) -> Result<(), Error>

Removes the document from the collection.

if let Some(document) = MyCollection::get_async(&42, &db).await? {
    document.delete_async(&db).await?;
}

pub fn delete_in_transaction( &self, transaction: &mut Transaction, ) -> Result<(), Error>

Pushes a delete Operation to the transaction for this document.

The document will be deleted once the transaction is applied.

pub fn refresh<Cn: Connection>(&mut self, connection: &Cn) -> Result<(), Error>

Refreshes this instance from connection. If the document is no longer present, Error::DocumentNotFound will be returned.

pub async fn refresh_async<Cn: AsyncConnection>( &mut self, connection: &Cn, ) -> Result<(), Error>

Refreshes this instance from connection. If the document is no longer present, Error::DocumentNotFound will be returned.

pub fn to_document(&self) -> Result<OwnedDocument, Error>

Converts this value to a serialized Document.

Trait Implementations

impl<C> Clone for CollectionDocument<C>

where C: SerializedCollection + Clone, C::PrimaryKey: Clone, C::Contents: Clone,

fn clone(&self) -> CollectionDocument<C>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<C> Debug for CollectionDocument<C>

where C: SerializedCollection + Debug, C::PrimaryKey: Debug, C::Contents: Debug,

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

Formats the value using the given formatter.

impl<'de, C> Deserialize<'de> for CollectionDocument<C>

where C: SerializedCollection, C::PrimaryKey: Deserialize<'de>, C::Contents: Deserialize<'de>,

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<C> HasHeader for CollectionDocument<C>

where C: SerializedCollection,

fn header(&self) -> Result<Header, Error>

Returns the header for this instance.

impl<'a, C> Nameable<'a, <C as Collection>::PrimaryKey> for &'a CollectionDocument<C>

where C: SerializedCollection,

fn name(self) -> Result<NamedReference<'a, C::PrimaryKey>, Error>

Returns this name as a NamedReference.

impl<C> PartialEq for CollectionDocument<C>

where C: SerializedCollection + PartialEq, C::PrimaryKey: PartialEq, C::Contents: PartialEq,

fn eq(&self, other: &CollectionDocument<C>) -> 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<C> Serialize for CollectionDocument<C>

where C: SerializedCollection, C::Contents: Serialize, C::PrimaryKey: Serialize,

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<'a, C> TryFrom<&'a BorrowedDocument<'a>> for CollectionDocument<C>

where C: SerializedCollection,

type Error = Error

The type returned in the event of a conversion error.

fn try_from(value: &'a BorrowedDocument<'a>) -> Result<Self, Self::Error>

Performs the conversion.

impl<'a, 'b, C> TryFrom<&'b CollectionDocument<C>> for BorrowedDocument<'a>

where C: SerializedCollection,

type Error = Error

The type returned in the event of a conversion error.

fn try_from(value: &'b CollectionDocument<C>) -> Result<Self, Self::Error>

Performs the conversion.

impl<'a, 'c, C> TryFrom<&'c CollectionDocument<C>> for NamedReference<'a, C::PrimaryKey>

where C: SerializedCollection,

type Error = Error

The type returned in the event of a conversion error.

fn try_from(doc: &'c CollectionDocument<C>) -> Result<Self, Error>

Performs the conversion.

impl<'a, C> TryFrom<&'a OwnedDocument> for CollectionDocument<C>

where C: SerializedCollection,

type Error = Error

The type returned in the event of a conversion error.

fn try_from(value: &'a OwnedDocument) -> Result<Self, Self::Error>

Performs the conversion.

impl<C> Eq for CollectionDocument<C>

where C: SerializedCollection + Eq, C::PrimaryKey: Eq, C::Contents: Eq,

impl<C> StructuralPartialEq for CollectionDocument<C>

where C: SerializedCollection,