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
use tokio::time::Duration; pub(crate) enum InnerCommitPolicy { Default, Noop, Immediate(Box<dyn FnOnce() + Send>), Within(Duration), } #[derive(Clone, Copy)] pub enum DefaultCommitPolicy { /// The data must be persisted successfully before the execution returns. Immediate, /// The data should try to be persisted with at most a `Duration` delay. Within(Duration), } pub(super) enum CommitPolicy { /// The data should persist with the default persistence policy of the service. Default, /// The mutation was a no-op, and no additional persistence should be enqueued. Noop, /// The data must be persisted successfully before the execution returns. Immediate, /// The data should try to be persisted with at most a `Duration` delay. Within(Duration), } /// Specifies how the `execute_mut` should be committed to the upstream. /// /// This allows you to control the durability of your data mutation. /// /// [`execute_mut`]: ServiceHandle::execute_mut pub struct Commit<Data>(CommitPolicy, Data); impl<Data> Commit<Data> { /// Persist the item immediately. The execution future will not resolve until your write has been been /// acknowledged by the upstream layer. pub fn immediately(data: Data) -> Self { Self(CommitPolicy::Immediate, data) } /// Persist the data, using the default persistence policy for the service. pub fn default(data: Data) -> Self { Self(CommitPolicy::Default, data) } /// Ensure that the data is persisted within a given duration. pub fn within(data: Data, duration: Duration) -> Self { Self(CommitPolicy::Within(duration), data) } /// The mutation resulted in a no-op. Do not try to persist the data in any way. /// /// This function is unsafe, as it's up to you to make sure to only call this *if and only if* /// the data truly did not change. Since you're getting a `&mut` to the data, this contract /// cannot be statically enforced. So, it's up to you to use correctly. pub unsafe fn noop(data: Data) -> Self { Self(CommitPolicy::Noop, data) } pub(super) fn into_inner(self) -> (CommitPolicy, Data) { (self.0, self.1) } }