qubit-cas 0.8.0

Typed compare-and-swap executor with retry-aware conflict handling
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
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78

/*******************************************************************************
 *
 *    Copyright (c) 2025 - 2026 Haixing Hu.
 *
 *    SPDX-License-Identifier: Apache-2.0
 *
 *    Licensed under the Apache License, Version 2.0.
 *
 ******************************************************************************/
//! Decision values returned by fast compare-and-swap operations.

/// Decision returned by one [`crate::FastCas`] operation attempt.
///
/// The operation may be called multiple times when CAS conflicts happen, so it
/// should be deterministic and free of non-idempotent side effects.
#[derive(Debug, Clone, Copy, Eq, PartialEq)]
pub enum FastCasDecision<R, E> {
    /// Replace the current state with `next` and return `output` after the CAS
    /// write succeeds.
    Update {
        /// State code to install.
        next: usize,

        /// Business output returned after success.
        output: R,
    },

    /// Complete successfully without writing a new state.
    Finish {
        /// Business output returned immediately.
        output: R,
    },

    /// Stop immediately without writing a new state.
    Abort {
        /// Business error returned to the caller.
        error: E,
    },
}

impl<R, E> FastCasDecision<R, E> {
    /// Creates an update decision.
    ///
    /// # Parameters
    /// - `next`: State code to install.
    /// - `output`: Business output returned after the CAS succeeds.
    ///
    /// # Returns
    /// An update decision.
    #[inline]
    pub const fn update(next: usize, output: R) -> Self {
        Self::Update { next, output }
    }

    /// Creates a finish decision.
    ///
    /// # Parameters
    /// - `output`: Business output returned without writing.
    ///
    /// # Returns
    /// A finish decision.
    #[inline]
    pub const fn finish(output: R) -> Self {
        Self::Finish { output }
    }

    /// Creates an abort decision.
    ///
    /// # Parameters
    /// - `error`: Business error returned to the caller.
    ///
    /// # Returns
    /// An abort decision.
    #[inline]
    pub const fn abort(error: E) -> Self {
        Self::Abort { error }
    }
}