rt_own/
owner_ref.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;
7use std::ptr::NonNull;
8
9use crate::Holder;
10use crate::Owner;
11use crate::State;
12use crate::Viewer;
13use crate::ptr::Ptr;
14use crate::ref_::Ref;
15
16pub struct OwnerRef<Source: ?Sized, Target: ?Sized> {
17    ref_: Ref<Source, Target>,
18}
19
20impl<Source: ?Sized, Target: ?Sized> OwnerRef<Source, Target> {
21    pub fn state(owner: &Self) -> State {
22        owner.ref_.source().cell().state()
23    }
24
25    pub fn map<Target2, Map>(mut owner: Self, map: Map) -> OwnerRef<Source, Target2>
26    where
27        Target2: ?Sized + 'static,
28        Map: for<'a> FnOnce(&'a mut Target) -> &'a mut Target2, {
29        // SAFETY: when self is alive there is no owner and data hasn't been dropped
30        let target = unsafe { owner.ref_.map_target_mut(map) };
31        let holder = Holder::from(owner);
32        let source = Holder::ptr(&holder).clone_to_owner().unwrap();
33        OwnerRef { ref_: Ref::new(source, target) }
34    }
35
36    pub fn try_map<Target2, Err, Map>(
37        mut owner: Self, map: Map,
38    ) -> Result<OwnerRef<Source, Target2>, Err>
39    where
40        Target2: ?Sized + 'static,
41        Map: for<'a> FnOnce(&'a mut Target) -> Result<&'a mut Target2, Err>, {
42        // SAFETY: when self is alive there is no owner and data hasn't been dropped
43        let target = unsafe { owner.ref_.try_map_target_mut(map) }?;
44        let holder = Holder::from(owner);
45        let source = Holder::ptr(&holder).clone_to_owner().unwrap();
46        Ok(OwnerRef { ref_: Ref::new(source, target) })
47    }
48
49    pub(crate) fn source(owner: &Self) -> &Ptr<Source> {
50        owner.ref_.source()
51    }
52
53    pub(crate) fn target(owner: &Self) -> NonNull<Target> {
54        owner.ref_.target()
55    }
56}
57
58impl<Source: ?Sized, Target: ?Sized> Drop for OwnerRef<Source, Target> {
59    fn drop(&mut self) {
60        self.ref_.source().drop_from_owner();
61    }
62}
63
64impl<Source: ?Sized, Target: ?Sized> Deref for OwnerRef<Source, Target> {
65    type Target = Target;
66    fn deref(&self) -> &Self::Target {
67        // SAFETY: we have exclusive ref and data hasn't been dropped
68        unsafe { self.ref_.deref() }
69    }
70}
71
72impl<Source: ?Sized, Target: ?Sized> DerefMut for OwnerRef<Source, Target> {
73    fn deref_mut(&mut self) -> &mut Self::Target {
74        // SAFETY: we have exclusive ref and data hasn't been dropped
75        unsafe { self.ref_.deref_mut() }
76    }
77}
78
79impl<Source: ?Sized> TryFrom<&Holder<Source>> for OwnerRef<Source, Source> {
80    type Error = State;
81    fn try_from(holder: &Holder<Source>) -> Result<Self, Self::Error> {
82        let source = Holder::ptr(holder).clone_to_owner()?;
83        Ok(Self { ref_: Ref::from_source(source) })
84    }
85}
86
87impl<Source: ?Sized> TryFrom<Holder<Source>> for OwnerRef<Source, Source> {
88    type Error = State;
89    fn try_from(holder: Holder<Source>) -> Result<Self, Self::Error> {
90        let source = Holder::ptr(&holder).clone_to_owner()?;
91        Ok(Self { ref_: Ref::from_source(source) })
92    }
93}
94
95impl<Source: ?Sized> TryFrom<Viewer<Source>> for OwnerRef<Source, Source> {
96    type Error = State;
97    fn try_from(value: Viewer<Source>) -> Result<Self, Self::Error> {
98        let holder = Holder::from(value);
99        let source = Holder::ptr(&holder).clone_to_owner()?;
100        Ok(Self { ref_: Ref::from_source(source) })
101    }
102}
103
104impl<Source: ?Sized> From<Owner<Source>> for OwnerRef<Source, Source> {
105    fn from(value: Owner<Source>) -> Self {
106        let holder = Holder::from(value);
107        let source = Holder::ptr(&holder).clone_to_owner().unwrap();
108        Self { ref_: Ref::from_source(source) }
109    }
110}
111
112impl<Source: ?Sized, Target: ?Sized> Debug for OwnerRef<Source, Target> {
113    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
114        f.write_str("Owner")?;
115        self.ref_.fmt(f)
116    }
117}
118
119impl<Source: ?Sized, Target: ?Sized> PartialEq for OwnerRef<Source, Target> {
120    fn eq(&self, other: &Self) -> bool {
121        self.ref_ == other.ref_
122    }
123}
124
125impl<Source: ?Sized, Target: ?Sized> Eq for OwnerRef<Source, Target> {}
126
127impl<Source: ?Sized, Target: ?Sized> Hash for OwnerRef<Source, Target> {
128    fn hash<H: Hasher>(&self, state: &mut H) {
129        self.ref_.hash(state);
130    }
131}
rt_own/owner_ref.rs

rt_own/
owner_ref.rs
