rt-own 0.2.2

runtime ownership: owner, viewer and holder
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
137
138
139

use std::fmt::Debug;
use std::fmt::Formatter;
use std::hash::Hash;
use std::hash::Hasher;
use std::ops::Deref;

use crate::Holder;
use crate::Owner;
use crate::OwnerRef;
use crate::State;
use crate::Viewer;
use crate::ptr::Ptr;
use crate::ref_::Ref;

pub struct ViewerRef<Source: ?Sized, Target: ?Sized> {
    ref_: Ref<Source, Target>,
}

impl<Source: ?Sized, Target: ?Sized> ViewerRef<Source, Target> {
    pub fn state(viewer: &Self) -> State {
        viewer.ref_.source().cell().state()
    }

    pub fn map<Target2, Map>(viewer: Self, map: Map) -> ViewerRef<Source, Target2>
    where
        Target2: ?Sized + 'static,
        Map: for<'a> FnOnce(&'a Target) -> &'a Target2, {
        // SAFETY: when self is alive there is no owner and data hasn't been dropped
        let target = unsafe { viewer.ref_.map_target(map) };
        let source = viewer.ref_.source().clone_to_viewer().unwrap();
        ViewerRef { ref_: Ref::new(source, target) }
    }

    pub fn try_map<Target2, Err, Map>(
        viewer: Self, map: Map,
    ) -> Result<ViewerRef<Source, Target2>, Err>
    where
        Target2: ?Sized + 'static,
        Map: for<'a> FnOnce(&'a Target) -> Result<&'a Target2, Err>, {
        // SAFETY: when self is alive there is no owner and data hasn't been dropped
        let target = unsafe { viewer.ref_.try_map_target(map) }?;
        let source = viewer.ref_.source().clone_to_viewer().unwrap();
        Ok(ViewerRef { ref_: Ref::new(source, target) })
    }

    pub(crate) fn source(viewer: &Self) -> &Ptr<Source> {
        viewer.ref_.source()
    }
}

impl<Source: ?Sized, Target: ?Sized> Clone for ViewerRef<Source, Target> {
    fn clone(&self) -> Self {
        let source = self.ref_.source().clone_to_viewer().unwrap();
        let target = self.ref_.target();
        Self { ref_: Ref::new(source, target) }
    }
}

impl<Source: ?Sized, Target: ?Sized> Drop for ViewerRef<Source, Target> {
    fn drop(&mut self) {
        self.ref_.source().drop_from_viewer();
    }
}

impl<Source: ?Sized, Target: ?Sized> Deref for ViewerRef<Source, Target> {
    type Target = Target;
    fn deref(&self) -> &Self::Target {
        // SAFETY: when self is alive there is no owner and data hasn't been dropped
        unsafe { self.ref_.deref() }
    }
}

impl<Source: ?Sized> TryFrom<&Holder<Source>> for ViewerRef<Source, Source> {
    type Error = State;
    fn try_from(holder: &Holder<Source>) -> Result<Self, Self::Error> {
        let source = Holder::ptr(holder).clone_to_viewer()?;
        Ok(Self { ref_: Ref::from_source(source) })
    }
}

impl<Source: ?Sized> TryFrom<Holder<Source>> for ViewerRef<Source, Source> {
    type Error = State;
    fn try_from(holder: Holder<Source>) -> Result<Self, Self::Error> {
        let source = Holder::ptr(&holder).clone_to_viewer()?;
        Ok(Self { ref_: Ref::from_source(source) })
    }
}

impl<Source: ?Sized> From<&Viewer<Source>> for ViewerRef<Source, Source> {
    fn from(value: &Viewer<Source>) -> Self {
        let source = Viewer::ptr(value).clone_to_viewer().unwrap();
        Self { ref_: Ref::from_source(source) }
    }
}

impl<Source: ?Sized> From<Viewer<Source>> for ViewerRef<Source, Source> {
    fn from(value: Viewer<Source>) -> Self {
        let source = Viewer::ptr(&value).clone_to_viewer().unwrap();
        Self { ref_: Ref::from_source(source) }
    }
}

impl<Source: ?Sized> From<Owner<Source>> for ViewerRef<Source, Source> {
    fn from(value: Owner<Source>) -> Self {
        let holder = Holder::from(value);
        let source = Holder::ptr(&holder).clone_to_viewer().unwrap();
        Self { ref_: Ref::from_source(source) }
    }
}

impl<Source: ?Sized, Target: ?Sized> From<OwnerRef<Source, Target>> for ViewerRef<Source, Target> {
    fn from(value: OwnerRef<Source, Target>) -> Self {
        let target = OwnerRef::target(&value);
        let holder = Holder::from(value);
        let source = Holder::ptr(&holder).clone_to_viewer().unwrap();
        ViewerRef { ref_: Ref::new(source, target) }
    }
}

impl<Source: ?Sized, Target: ?Sized> Debug for ViewerRef<Source, Target> {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        f.write_str("Viewer")?;
        self.ref_.fmt(f)
    }
}

impl<Source: ?Sized, Target: ?Sized> PartialEq for ViewerRef<Source, Target> {
    fn eq(&self, other: &Self) -> bool {
        self.ref_ == other.ref_
    }
}

impl<Source: ?Sized, Target: ?Sized> Eq for ViewerRef<Source, Target> {}

impl<Source: ?Sized, Target: ?Sized> Hash for ViewerRef<Source, Target> {
    fn hash<H: Hasher>(&self, state: &mut H) {
        self.ref_.hash(state);
    }
}