1use alloc::boxed::Box;
2use core::marker::PhantomData;
3use core::ptr::NonNull;
4
5#[repr(transparent)]
6pub struct Own<T>
7where
8 T: ?Sized,
9{
10 pub ptr: NonNull<T>,
11}
12
13unsafe impl<T> Send for Own<T> where T: ?Sized {}
14
15unsafe impl<T> Sync for Own<T> where T: ?Sized {}
16
17impl<T> Copy for Own<T> where T: ?Sized {}
18
19impl<T> Clone for Own<T>
20where
21 T: ?Sized,
22{
23 fn clone(&self) -> Self {
24 *self
25 }
26}
27
28impl<T> Own<T>
29where
30 T: ?Sized,
31{
32 pub fn new(ptr: Box<T>) -> Self {
33 Own {
34 ptr: unsafe { NonNull::new_unchecked(Box::into_raw(ptr)) },
35 }
36 }
37
38 pub fn cast<U: CastTo>(self) -> Own<U::Target> {
39 Own {
40 ptr: self.ptr.cast(),
41 }
42 }
43
44 pub unsafe fn boxed(self) -> Box<T> {
45 unsafe { Box::from_raw(self.ptr.as_ptr()) }
46 }
47
48 pub fn by_ref(&self) -> Ref<T> {
49 Ref {
50 ptr: self.ptr,
51 lifetime: PhantomData,
52 }
53 }
54
55 pub fn by_mut(&mut self) -> Mut<T> {
56 Mut {
57 ptr: self.ptr,
58 lifetime: PhantomData,
59 }
60 }
61}
62
63#[repr(transparent)]
64pub struct Ref<'a, T>
65where
66 T: ?Sized,
67{
68 pub ptr: NonNull<T>,
69 lifetime: PhantomData<&'a T>,
70}
71
72impl<'a, T> Copy for Ref<'a, T> where T: ?Sized {}
73
74impl<'a, T> Clone for Ref<'a, T>
75where
76 T: ?Sized,
77{
78 fn clone(&self) -> Self {
79 *self
80 }
81}
82
83impl<'a, T> Ref<'a, T>
84where
85 T: ?Sized,
86{
87 pub fn new(ptr: &'a T) -> Self {
88 Ref {
89 ptr: NonNull::from(ptr),
90 lifetime: PhantomData,
91 }
92 }
93
94 #[cfg(not(anyhow_no_ptr_addr_of))]
95 pub fn from_raw(ptr: NonNull<T>) -> Self {
96 Ref {
97 ptr,
98 lifetime: PhantomData,
99 }
100 }
101
102 pub fn cast<U: CastTo>(self) -> Ref<'a, U::Target> {
103 Ref {
104 ptr: self.ptr.cast(),
105 lifetime: PhantomData,
106 }
107 }
108
109 #[cfg(not(anyhow_no_ptr_addr_of))]
110 pub fn by_mut(self) -> Mut<'a, T> {
111 Mut {
112 ptr: self.ptr,
113 lifetime: PhantomData,
114 }
115 }
116
117 #[cfg(not(anyhow_no_ptr_addr_of))]
118 pub fn as_ptr(self) -> *const T {
119 self.ptr.as_ptr() as *const T
120 }
121
122 pub unsafe fn deref(self) -> &'a T {
123 unsafe { &*self.ptr.as_ptr() }
124 }
125}
126
127#[repr(transparent)]
128pub struct Mut<'a, T>
129where
130 T: ?Sized,
131{
132 pub ptr: NonNull<T>,
133 lifetime: PhantomData<&'a mut T>,
134}
135
136impl<'a, T> Copy for Mut<'a, T> where T: ?Sized {}
137
138impl<'a, T> Clone for Mut<'a, T>
139where
140 T: ?Sized,
141{
142 fn clone(&self) -> Self {
143 *self
144 }
145}
146
147impl<'a, T> Mut<'a, T>
148where
149 T: ?Sized,
150{
151 #[cfg(anyhow_no_ptr_addr_of)]
152 pub fn new(ptr: &'a mut T) -> Self {
153 Mut {
154 ptr: NonNull::from(ptr),
155 lifetime: PhantomData,
156 }
157 }
158
159 pub fn cast<U: CastTo>(self) -> Mut<'a, U::Target> {
160 Mut {
161 ptr: self.ptr.cast(),
162 lifetime: PhantomData,
163 }
164 }
165
166 #[cfg(not(anyhow_no_ptr_addr_of))]
167 pub fn by_ref(self) -> Ref<'a, T> {
168 Ref {
169 ptr: self.ptr,
170 lifetime: PhantomData,
171 }
172 }
173
174 pub fn extend<'b>(self) -> Mut<'b, T> {
175 Mut {
176 ptr: self.ptr,
177 lifetime: PhantomData,
178 }
179 }
180
181 pub unsafe fn deref_mut(self) -> &'a mut T {
182 unsafe { &mut *self.ptr.as_ptr() }
183 }
184}
185
186impl<'a, T> Mut<'a, T> {
187 pub unsafe fn read(self) -> T {
188 unsafe { self.ptr.as_ptr().read() }
189 }
190}
191
192// Force turbofish on all calls of `.cast::<U>()`.
193pub trait CastTo {
194 type Target;
195}
196
197impl<T> CastTo for T {
198 type Target = T;
199}
200