hitbox-backend 0.2.1

Backend trait for asynchronous caching framework in Rust.
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
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136

//! CompositionPolicy builder for configuring all three policies together.

use super::{
    CompositionReadPolicy, CompositionWritePolicy, OptimisticParallelWritePolicy, RefillPolicy,
    SequentialReadPolicy,
};

/// Bundle of read, write, and refill policies for CompositionBackend.
///
/// This struct provides a builder pattern for configuring all three policy types
/// together, making it easy to create and reuse policy configurations.
///
/// # Example
///
/// ```ignore
/// use hitbox_backend::composition::{CompositionPolicy, CompositionBackend};
/// use hitbox_backend::composition::policy::{RaceReadPolicy, SequentialWritePolicy, RefillPolicy};
///
/// let policy = CompositionPolicy::new()
///     .read(RaceReadPolicy::new())
///     .write(SequentialWritePolicy::new())
///     .refill(RefillPolicy::Always);
///
/// let backend = CompositionBackend::new(l1, l2)
///     .with_policy(policy);
/// ```
#[derive(Debug, Clone)]
pub struct CompositionPolicy<R = SequentialReadPolicy, W = OptimisticParallelWritePolicy>
where
    R: CompositionReadPolicy,
    W: CompositionWritePolicy,
{
    /// Read policy
    pub(crate) read: R,
    /// Write policy
    pub(crate) write: W,
    /// Refill policy
    pub(crate) refill: RefillPolicy,
}

impl CompositionPolicy<SequentialReadPolicy, OptimisticParallelWritePolicy> {
    /// Create a new policy bundle with default policies.
    ///
    /// Default policies:
    /// - Read: `SequentialReadPolicy` (try L1 first, then L2)
    /// - Write: `OptimisticParallelWritePolicy` (write to both, succeed if ≥1 succeeds)
    /// - Refill: `RefillPolicy::Never` (do not populate L1 after L2 hit)
    pub fn new() -> Self {
        Self {
            read: SequentialReadPolicy::new(),
            write: OptimisticParallelWritePolicy::new(),
            refill: RefillPolicy::default(),
        }
    }
}

impl Default for CompositionPolicy<SequentialReadPolicy, OptimisticParallelWritePolicy> {
    fn default() -> Self {
        Self::new()
    }
}

impl<R, W> CompositionPolicy<R, W>
where
    R: CompositionReadPolicy,
    W: CompositionWritePolicy,
{
    /// Set the read policy (builder pattern).
    ///
    /// # Example
    /// ```ignore
    /// use hitbox_backend::composition::CompositionPolicy;
    /// use hitbox_backend::composition::policy::RaceReadPolicy;
    ///
    /// let policy = CompositionPolicy::new()
    ///     .read(RaceReadPolicy::new());
    /// ```
    pub fn read<NewR: CompositionReadPolicy>(self, read: NewR) -> CompositionPolicy<NewR, W> {
        CompositionPolicy {
            read,
            write: self.write,
            refill: self.refill,
        }
    }

    /// Set the write policy (builder pattern).
    ///
    /// # Example
    /// ```ignore
    /// use hitbox_backend::composition::CompositionPolicy;
    /// use hitbox_backend::composition::policy::SequentialWritePolicy;
    ///
    /// let policy = CompositionPolicy::new()
    ///     .write(SequentialWritePolicy::new());
    /// ```
    pub fn write<NewW: CompositionWritePolicy>(self, write: NewW) -> CompositionPolicy<R, NewW> {
        CompositionPolicy {
            read: self.read,
            write,
            refill: self.refill,
        }
    }

    /// Set the refill policy (builder pattern).
    ///
    /// # Example
    /// ```ignore
    /// use hitbox_backend::composition::CompositionPolicy;
    /// use hitbox_backend::composition::policy::RefillPolicy;
    ///
    /// let policy = CompositionPolicy::new()
    ///     .refill(RefillPolicy::Always);
    /// ```
    pub fn refill(self, refill: RefillPolicy) -> CompositionPolicy<R, W> {
        CompositionPolicy {
            read: self.read,
            write: self.write,
            refill,
        }
    }

    /// Get a reference to the read policy.
    pub fn read_policy(&self) -> &R {
        &self.read
    }

    /// Get a reference to the write policy.
    pub fn write_policy(&self) -> &W {
        &self.write
    }

    /// Get a reference to the refill policy.
    pub fn refill_policy(&self) -> &RefillPolicy {
        &self.refill
    }
}