rocketmq_rust/
arc_mut.rs

1/*
2 * Licensed to the Apache Software Foundation (ASF) under one or more
3 * contributor license agreements.  See the NOTICE file distributed with
4 * this work for additional information regarding copyright ownership.
5 * The ASF licenses this file to You under the Apache License, Version 2.0
6 * (the "License"); you may not use this file except in compliance with
7 * the License.  You may obtain a copy of the License at
8 *
9 *     http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 */
17
18#![allow(dead_code)]
19
20use core::fmt;
21use std::cell::SyncUnsafeCell;
22use std::fmt::Debug;
23use std::fmt::Formatter;
24use std::hash::Hash;
25use std::hash::Hasher;
26use std::ops::Deref;
27use std::ops::DerefMut;
28use std::sync::Arc;
29use std::sync::Weak;
30
31use serde::Deserialize;
32use serde::Deserializer;
33use serde::Serialize;
34use serde::Serializer;
35
36/// A weak version of `ArcMut` that doesn't prevent the inner value from being dropped.
37///
38/// # Safety
39/// This type uses `SyncUnsafeCell` which is not thread-safe by default.
40/// You must ensure that no data races occur when using this type across threads.
41pub struct WeakArcMut<T: ?Sized> {
42    inner: Weak<SyncUnsafeCell<T>>,
43}
44
45// Implementation of PartialEq for WeakArcMut<T>
46impl<T: PartialEq + ?Sized> PartialEq for WeakArcMut<T> {
47    fn eq(&self, other: &Self) -> bool {
48        if let (Some(a), Some(b)) = (self.inner.upgrade(), other.inner.upgrade()) {
49            unsafe { *a.get() == *b.get() }
50        } else {
51            false
52        }
53    }
54}
55
56// Implementation of Eq for WeakArcMut<T>
57impl<T: Eq + ?Sized> Eq for WeakArcMut<T> {}
58
59// Implementation of Hash for WeakArcMut<T>
60
61impl<T: Hash + ?Sized> Hash for WeakArcMut<T> {
62    fn hash<H: Hasher>(&self, state: &mut H) {
63        if let Some(arc) = self.inner.upgrade() {
64            unsafe { (*arc.get()).hash(state) }
65        }
66    }
67}
68
69impl<T: ?Sized> Clone for WeakArcMut<T> {
70    fn clone(&self) -> Self {
71        Self {
72            inner: self.inner.clone(),
73        }
74    }
75}
76
77impl<T: ?Sized> WeakArcMut<T> {
78    #[inline]
79    pub fn upgrade(&self) -> Option<ArcMut<T>> {
80        self.inner.upgrade().map(|inner| ArcMut { inner })
81    }
82}
83
84/// A mutable reference-counted pointer with interior mutability.
85///
86/// # Safety
87/// This type uses `SyncUnsafeCell` which is not thread-safe by default.
88/// You must ensure that no data races occur when using this type across threads.
89#[derive(Default)]
90pub struct ArcMut<T: ?Sized> {
91    inner: Arc<SyncUnsafeCell<T>>,
92}
93
94// Implementation of PartialEq for ArcMut<T>
95impl<T: PartialEq + ?Sized> PartialEq for ArcMut<T> {
96    fn eq(&self, other: &Self) -> bool {
97        unsafe { *self.inner.get() == *other.inner.get() }
98    }
99}
100
101impl<T: Eq + ?Sized> Eq for ArcMut<T> {}
102
103impl<T: Hash> Hash for ArcMut<T> {
104    #[inline]
105    fn hash<H: Hasher>(&self, state: &mut H) {
106        // Compute the hash of the inner value
107        unsafe { (*self.inner.get()).hash(state) }
108    }
109}
110
111impl<T> ArcMut<T> {
112    #[inline]
113    pub fn new(value: T) -> Self {
114        Self {
115            inner: Arc::new(SyncUnsafeCell::new(value)),
116        }
117    }
118
119    /// Returns a mutable reference to the inner value
120    ///
121    /// # Safety
122    /// This is safe as long as no other mutable references exist
123    /// and the caller ensures proper synchronization.
124    #[inline]
125    #[allow(clippy::mut_from_ref)]
126    pub fn mut_from_ref(&self) -> &mut T {
127        unsafe { &mut *self.inner.get() }
128    }
129
130    #[inline]
131    pub fn downgrade(this: &Self) -> WeakArcMut<T> {
132        WeakArcMut {
133            inner: Arc::downgrade(&this.inner),
134        }
135    }
136
137    #[inline]
138    pub fn get_inner(&self) -> &Arc<SyncUnsafeCell<T>> {
139        &self.inner
140    }
141
142    pub fn try_unwrap(self) -> Result<T, Self> {
143        match Arc::try_unwrap(self.inner) {
144            Ok(cell) => Ok(cell.into_inner()),
145            Err(inner) => Err(Self { inner }),
146        }
147    }
148
149    pub fn strong_count(&self) -> usize {
150        Arc::strong_count(&self.inner)
151    }
152
153    pub fn weak_count(&self) -> usize {
154        Arc::weak_count(&self.inner)
155    }
156}
157
158impl<T: ?Sized> Clone for ArcMut<T> {
159    #[inline]
160    fn clone(&self) -> Self {
161        ArcMut {
162            inner: Arc::clone(&self.inner),
163        }
164    }
165}
166
167impl<T: ?Sized> AsRef<T> for ArcMut<T> {
168    #[inline]
169    fn as_ref(&self) -> &T {
170        unsafe { &*self.inner.get() }
171    }
172}
173
174impl<T: ?Sized> AsMut<T> for ArcMut<T> {
175    #[inline]
176    fn as_mut(&mut self) -> &mut T {
177        unsafe { &mut *self.inner.get() }
178    }
179}
180
181impl<T: ?Sized> Deref for ArcMut<T> {
182    type Target = T;
183
184    #[inline]
185    fn deref(&self) -> &Self::Target {
186        self.as_ref()
187    }
188}
189
190impl<T: ?Sized> DerefMut for ArcMut<T> {
191    #[inline]
192    fn deref_mut(&mut self) -> &mut Self::Target {
193        self.as_mut()
194    }
195}
196
197pub struct SyncUnsafeCellWrapper<T: ?Sized> {
198    inner: SyncUnsafeCell<T>,
199}
200
201impl<T> SyncUnsafeCellWrapper<T> {
202    #[inline]
203    pub fn new(value: T) -> Self {
204        Self {
205            inner: SyncUnsafeCell::new(value),
206        }
207    }
208}
209
210impl<T> SyncUnsafeCellWrapper<T> {
211    #[inline]
212    #[allow(clippy::mut_from_ref)]
213    pub fn mut_from_ref(&self) -> &mut T {
214        unsafe { &mut *self.inner.get() }
215    }
216}
217
218impl<T> AsRef<T> for SyncUnsafeCellWrapper<T> {
219    #[inline]
220    fn as_ref(&self) -> &T {
221        unsafe { &*self.inner.get() }
222    }
223}
224
225impl<T> AsMut<T> for SyncUnsafeCellWrapper<T> {
226    #[inline]
227    fn as_mut(&mut self) -> &mut T {
228        &mut *self.inner.get_mut()
229    }
230}
231
232impl<T> Deref for SyncUnsafeCellWrapper<T> {
233    type Target = T;
234
235    #[inline]
236    fn deref(&self) -> &Self::Target {
237        self.as_ref()
238    }
239}
240
241impl<T> DerefMut for SyncUnsafeCellWrapper<T> {
242    #[inline]
243    fn deref_mut(&mut self) -> &mut Self::Target {
244        self.as_mut()
245    }
246}
247
248impl<T: ?Sized + Debug> std::fmt::Debug for ArcMut<T> {
249    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
250        fmt::Debug::fmt(&**self, f)
251    }
252}
253
254impl<T> Serialize for ArcMut<T>
255where
256    T: Serialize,
257{
258    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
259    where
260        S: Serializer,
261    {
262        let inner_ref = unsafe { &*self.inner.get() };
263        inner_ref.serialize(serializer)
264    }
265}
266
267impl<'de, T> Deserialize<'de> for ArcMut<T>
268where
269    T: Deserialize<'de>,
270{
271    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
272    where
273        D: Deserializer<'de>,
274    {
275        let inner = T::deserialize(deserializer)?;
276        Ok(ArcMut::new(inner))
277    }
278}
279
280#[cfg(test)]
281mod arc_cell_wrapper_tests {
282    use std::sync::Arc;
283
284    use super::*;
285
286    #[test]
287    fn new_creates_arc_cell_wrapper_with_provided_value() {
288        let wrapper = ArcMut::new(10);
289        assert_eq!(*wrapper.as_ref(), 10);
290    }
291
292    #[test]
293    fn clone_creates_a_new_instance_with_same_value() {
294        let wrapper = ArcMut::new(20);
295        let cloned_wrapper = wrapper.clone();
296        assert_eq!(*cloned_wrapper.as_ref(), 20);
297    }
298
299    #[test]
300    fn as_ref_returns_immutable_reference_to_value() {
301        let wrapper = ArcMut::new(30);
302        assert_eq!(*wrapper.as_ref(), 30);
303    }
304
305    #[test]
306    fn as_mut_returns_mutable_reference_to_value() {
307        let mut wrapper = ArcMut::new(40);
308        *wrapper.as_mut() = 50;
309        assert_eq!(*wrapper.as_ref(), 50);
310    }
311
312    #[test]
313    fn deref_returns_reference_to_inner_value() {
314        let wrapper = ArcMut::new(60);
315        assert_eq!(*wrapper, 60);
316    }
317
318    #[test]
319    fn deref_mut_allows_modification_of_inner_value() {
320        let mut wrapper = ArcMut::new(70);
321        *wrapper = 80;
322        assert_eq!(*wrapper, 80);
323    }
324
325    #[test]
326    fn multiple_clones_share_the_same_underlying_data() {
327        let wrapper = ArcMut::new(Arc::new(90));
328        let cloned_wrapper1 = wrapper.clone();
329        let cloned_wrapper2 = wrapper.clone();
330
331        assert_eq!(Arc::strong_count(wrapper.as_ref()), 1);
332        assert_eq!(Arc::strong_count(cloned_wrapper1.as_ref()), 1);
333        assert_eq!(Arc::strong_count(cloned_wrapper2.as_ref()), 1);
334    }
335}
rocketmq_rust/arc_mut.rs

rocketmq_rust/
arc_mut.rs
