rt_own/
owner.rs

1use std::fmt::Debug;
2use std::fmt::Formatter;
3use std::hash::Hash;
4use std::hash::Hasher;
5use std::ops::Deref;
6use std::ops::DerefMut;
7
8use crate::Holder;
9use crate::OwnerRef;
10use crate::State;
11use crate::Viewer;
12use crate::ViewerRef;
13use crate::ptr::Ptr;
14
15pub struct Owner<D: ?Sized> {
16    ptr: Ptr<D>,
17}
18
19impl<D: ?Sized> Owner<D> {
20    pub fn new(data: D) -> Self
21    where D: Sized {
22        Self { ptr: Ptr::new_owner(data) }
23    }
24
25    pub fn state(owner: &Self) -> State {
26        owner.ptr.cell().state()
27    }
28
29    pub fn move_data(owner: Self) -> D
30    where D: Sized {
31        // SAFETY:
32        // we have exclusive ref
33        // we consume the Owner when taking
34        // we change the state to dropped
35        // so we won't access the data anymore
36        unsafe { owner.ptr.cell().move_data() }
37    }
38
39    pub fn drop_data(owner: Self) {
40        // SAFETY:
41        // we have exclusive ref
42        // we consume the Owner when deleting
43        // we change the state to dropped
44        // so we won't access the data anymore
45        unsafe { owner.ptr.cell().drop_data() }
46    }
47
48    pub(crate) fn ptr(owner: &Self) -> &Ptr<D> {
49        &owner.ptr
50    }
51}
52
53impl<D: ?Sized> Deref for Owner<D> {
54    type Target = D;
55    fn deref(&self) -> &Self::Target {
56        // SAFETY: we have exclusive ref and data hasn't been dropped
57        unsafe { self.ptr.cell().deref() }
58    }
59}
60
61impl<D: ?Sized> DerefMut for Owner<D> {
62    fn deref_mut(&mut self) -> &mut Self::Target {
63        // SAFETY: we have exclusive ref and data hasn't been dropped
64        unsafe { self.ptr.cell().deref_mut() }
65    }
66}
67
68impl<D: ?Sized> Drop for Owner<D> {
69    fn drop(&mut self) {
70        self.ptr.drop_from_owner();
71    }
72}
73
74impl<D: ?Sized> TryFrom<&Holder<D>> for Owner<D> {
75    type Error = State;
76    fn try_from(value: &Holder<D>) -> Result<Self, Self::Error> {
77        Ok(Self { ptr: Holder::ptr(value).clone_to_owner()? })
78    }
79}
80
81impl<D: ?Sized> TryFrom<Holder<D>> for Owner<D> {
82    type Error = State;
83    fn try_from(value: Holder<D>) -> Result<Self, Self::Error> {
84        Ok(Self { ptr: Holder::ptr(&value).clone_to_owner()? })
85    }
86}
87
88impl<D: ?Sized> TryFrom<Viewer<D>> for Owner<D> {
89    type Error = State;
90    fn try_from(value: Viewer<D>) -> Result<Self, Self::Error> {
91        let holder = Holder::from(value);
92        Ok(Self { ptr: Holder::ptr(&holder).clone_to_owner()? })
93    }
94}
95
96impl<Source: ?Sized, Target: ?Sized> TryFrom<ViewerRef<Source, Target>> for Owner<Source> {
97    type Error = State;
98    fn try_from(value: ViewerRef<Source, Target>) -> Result<Self, Self::Error> {
99        let holder = Holder::from(value);
100        Ok(Self { ptr: Holder::ptr(&holder).clone_to_owner()? })
101    }
102}
103
104impl<Source: ?Sized, Target: ?Sized> From<OwnerRef<Source, Target>> for Owner<Source> {
105    fn from(value: OwnerRef<Source, Target>) -> Self {
106        let holder = Holder::from(value);
107        Self { ptr: Holder::ptr(&holder).clone_to_owner().unwrap() }
108    }
109}
110
111impl<D: ?Sized> Debug for Owner<D> {
112    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
113        f.debug_tuple("Owner").field(&self.ptr).finish()
114    }
115}
116
117impl<D: Default> Default for Owner<D> {
118    fn default() -> Self {
119        Self::new(D::default())
120    }
121}
122
123impl<D: ?Sized> PartialEq for Owner<D> {
124    fn eq(&self, other: &Self) -> bool {
125        self.ptr == other.ptr
126    }
127}
128
129impl<D: ?Sized> Eq for Owner<D> {}
130
131impl<D: ?Sized> Hash for Owner<D> {
132    fn hash<H: Hasher>(&self, state: &mut H) {
133        self.ptr.hash(state);
134    }
135}
rt_own/owner.rs

rt_own/
owner.rs
