rdt 0.2.4

Replicated Data Types - A synchronization framework
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

use super::DocumentMapHandle;
use crate::RdtResult;
use std::sync::atomic::{AtomicBool, Ordering};

/// A handle for managing a transaction on a document map
///
/// The transaction will automatically commit when the handle is dropped,
/// but can also be explicitly committed.
pub struct TransactionHandle {
    map_handle: DocumentMapHandle,
    committed: AtomicBool,
}

impl TransactionHandle {
    pub(crate) fn new(map_handle: DocumentMapHandle) -> Self {
        Self {
            map_handle,
            committed: AtomicBool::new(false),
        }
    }

    /// Commit the transaction, sending all collected changes as a batch
    pub fn commit(self) -> RdtResult<()> {
        if self.committed.swap(true, Ordering::AcqRel) {
            // Already committed
            return Ok(());
        }

        self.map_handle.commit_transaction_internal()
    }

    /// Check if the transaction is still active (not yet committed)
    pub fn is_active(&self) -> bool {
        !self.committed.load(Ordering::Acquire)
    }
}

impl Drop for TransactionHandle {
    fn drop(&mut self) {
        // Auto-commit if not already committed
        if !self.committed.swap(true, Ordering::AcqRel) {
            if let Err(e) = self.map_handle.commit_transaction_internal() {
                tracing::warn!("Failed to auto-commit transaction: {}", e);
            }
        }
    }
}