glib/
shared.rs

1// Copyright 2015-2016, The Gtk-rs Project Developers.
2// See the COPYRIGHT file at the top-level directory of this distribution.
3// Licensed under the MIT license, see the LICENSE file or <http://opensource.org/licenses/MIT>
4
5//! `IMPL` Shared (reference counted) wrapper implementation.
6
7use std::cmp;
8use std::fmt;
9use std::hash::{Hash, Hasher};
10use std::marker::PhantomData;
11use std::ptr;
12use translate::*;
13
14/// Wrapper implementations for shared types. See `glib_wrapper!`.
15#[macro_export]
16macro_rules! glib_shared_wrapper {
17    ([$($attr:meta)*] $name:ident, $ffi_name:path, @ref $ref_arg:ident $ref_expr:expr,
18     @unref $unref_arg:ident $unref_expr:expr,
19     @get_type $get_type_expr:expr) => {
20        glib_shared_wrapper!([$($attr)*] $name, $ffi_name, @ref $ref_arg $ref_expr,
21            @unref $unref_arg $unref_expr);
22
23        impl $crate::types::StaticType for $name {
24            fn static_type() -> $crate::types::Type {
25                #[allow(unused_unsafe)]
26                unsafe { $crate::translate::from_glib($get_type_expr) }
27            }
28        }
29
30        #[doc(hidden)]
31        impl<'a> $crate::value::FromValueOptional<'a> for $name {
32            unsafe fn from_value_optional(value: &$crate::Value) -> Option<Self> {
33                $crate::translate::from_glib_full($crate::gobject_sys::g_value_dup_boxed($crate::translate::ToGlibPtr::to_glib_none(value).0) as *mut $ffi_name)
34            }
35        }
36
37        #[doc(hidden)]
38        impl $crate::value::SetValue for $name {
39            unsafe fn set_value(value: &mut $crate::Value, this: &Self) {
40                $crate::gobject_sys::g_value_set_boxed($crate::translate::ToGlibPtrMut::to_glib_none_mut(value).0, $crate::translate::ToGlibPtr::<*mut $ffi_name>::to_glib_none(this).0 as $crate::glib_sys::gpointer)
41            }
42        }
43
44        #[doc(hidden)]
45        impl $crate::value::SetValueOptional for $name {
46            unsafe fn set_value_optional(value: &mut $crate::Value, this: Option<&Self>) {
47                $crate::gobject_sys::g_value_set_boxed($crate::translate::ToGlibPtrMut::to_glib_none_mut(value).0, $crate::translate::ToGlibPtr::<*mut $ffi_name>::to_glib_none(&this).0 as $crate::glib_sys::gpointer)
48            }
49        }
50    };
51
52    ([$($attr:meta)*] $name:ident, $ffi_name:path, @ref $ref_arg:ident $ref_expr:expr,
53     @unref $unref_arg:ident $unref_expr:expr) => {
54        $(#[$attr])*
55        #[derive(Clone)]
56        pub struct $name($crate::shared::Shared<$ffi_name, MemoryManager>);
57
58        #[doc(hidden)]
59        pub struct MemoryManager;
60
61        impl $crate::shared::SharedMemoryManager<$ffi_name> for MemoryManager {
62            #[inline]
63            unsafe fn ref_($ref_arg: *mut $ffi_name) {
64                $ref_expr;
65            }
66
67            #[inline]
68            unsafe fn unref($unref_arg: *mut $ffi_name) {
69                $unref_expr
70            }
71        }
72
73        #[doc(hidden)]
74        impl $crate::translate::GlibPtrDefault for $name {
75            type GlibType = *mut $ffi_name;
76        }
77
78        #[doc(hidden)]
79        impl<'a> $crate::translate::ToGlibPtr<'a, *mut $ffi_name> for $name {
80            type Storage = &'a $crate::shared::Shared<$ffi_name, MemoryManager>;
81
82            #[inline]
83            fn to_glib_none(&'a self) -> $crate::translate::Stash<'a, *mut $ffi_name, Self> {
84                let stash = $crate::translate::ToGlibPtr::to_glib_none(&self.0);
85                $crate::translate::Stash(stash.0, stash.1)
86            }
87
88            #[inline]
89            fn to_glib_full(&self) -> *mut $ffi_name {
90                $crate::translate::ToGlibPtr::to_glib_full(&self.0)
91            }
92        }
93
94        #[doc(hidden)]
95        impl<'a> $crate::translate::ToGlibContainerFromSlice<'a, *mut *mut $ffi_name> for $name {
96            type Storage = (Vec<$crate::translate::Stash<'a, *mut $ffi_name, $name>>, Option<Vec<*mut $ffi_name>>);
97
98            fn to_glib_none_from_slice(t: &'a [$name]) -> (*mut *mut $ffi_name, Self::Storage) {
99                let v: Vec<_> = t.iter().map(|s| $crate::translate::ToGlibPtr::to_glib_none(s)).collect();
100                let mut v_ptr: Vec<_> = v.iter().map(|s| s.0).collect();
101                v_ptr.push(::std::ptr::null_mut() as *mut $ffi_name);
102
103                (v_ptr.as_ptr() as *mut *mut $ffi_name, (v, Some(v_ptr)))
104            }
105
106            fn to_glib_container_from_slice(t: &'a [$name]) -> (*mut *mut $ffi_name, Self::Storage) {
107                let v: Vec<_> = t.iter().map(|s| $crate::translate::ToGlibPtr::to_glib_none(s)).collect();
108
109                let v_ptr = unsafe {
110                    let v_ptr = $crate::glib_sys::g_malloc0(::std::mem::size_of::<*mut $ffi_name>() * (t.len() + 1)) as *mut *mut $ffi_name;
111
112                    for (i, s) in v.iter().enumerate() {
113                        ::std::ptr::write(v_ptr.add(i), s.0);
114                    }
115
116                    v_ptr
117                };
118
119                (v_ptr, (v, None))
120            }
121
122            fn to_glib_full_from_slice(t: &[$name]) -> *mut *mut $ffi_name {
123                unsafe {
124                    let v_ptr = $crate::glib_sys::g_malloc0(::std::mem::size_of::<*mut $ffi_name>() * (t.len() + 1)) as *mut *mut $ffi_name;
125
126                    for (i, s) in t.iter().enumerate() {
127                        ::std::ptr::write(v_ptr.add(i), $crate::translate::ToGlibPtr::to_glib_full(s));
128                    }
129
130                    v_ptr
131                }
132            }
133        }
134
135        #[doc(hidden)]
136        impl<'a> $crate::translate::ToGlibContainerFromSlice<'a, *const *mut $ffi_name> for $name {
137            type Storage = (Vec<$crate::translate::Stash<'a, *mut $ffi_name, $name>>, Option<Vec<*mut $ffi_name>>);
138
139            fn to_glib_none_from_slice(t: &'a [$name]) -> (*const *mut $ffi_name, Self::Storage) {
140                let (ptr, stash) = $crate::translate::ToGlibContainerFromSlice::<'a, *mut *mut $ffi_name>::to_glib_none_from_slice(t);
141                (ptr as *const *mut $ffi_name, stash)
142            }
143
144            fn to_glib_container_from_slice(_: &'a [$name]) -> (*const *mut $ffi_name, Self::Storage) {
145                // Can't have consumer free a *const pointer
146                unimplemented!()
147            }
148
149            fn to_glib_full_from_slice(_: &[$name]) -> *const *mut $ffi_name {
150                // Can't have consumer free a *const pointer
151                unimplemented!()
152            }
153        }
154
155        #[doc(hidden)]
156        impl $crate::translate::FromGlibPtrNone<*mut $ffi_name> for $name {
157            #[inline]
158            unsafe fn from_glib_none(ptr: *mut $ffi_name) -> Self {
159                $name($crate::translate::from_glib_none(ptr))
160            }
161        }
162
163        #[doc(hidden)]
164        impl $crate::translate::FromGlibPtrNone<*const $ffi_name> for $name {
165            #[inline]
166            unsafe fn from_glib_none(ptr: *const $ffi_name) -> Self {
167                $name($crate::translate::from_glib_none(ptr))
168            }
169        }
170
171        #[doc(hidden)]
172        impl $crate::translate::FromGlibPtrFull<*mut $ffi_name> for $name {
173            #[inline]
174            unsafe fn from_glib_full(ptr: *mut $ffi_name) -> Self {
175                $name($crate::translate::from_glib_full(ptr))
176            }
177        }
178
179        #[doc(hidden)]
180        impl $crate::translate::FromGlibPtrBorrow<*mut $ffi_name> for $name {
181            #[inline]
182            unsafe fn from_glib_borrow(ptr: *mut $ffi_name) -> Self {
183                $name($crate::translate::from_glib_borrow(ptr))
184            }
185        }
186
187        #[doc(hidden)]
188        impl $crate::translate::FromGlibPtrBorrow<*const $ffi_name> for $name {
189            #[inline]
190            unsafe fn from_glib_borrow(ptr: *const $ffi_name) -> Self {
191                $crate::translate::from_glib_borrow(ptr as *mut $ffi_name)
192            }
193        }
194
195        #[doc(hidden)]
196        impl $crate::translate::FromGlibContainerAsVec<*mut $ffi_name, *mut *mut $ffi_name> for $name {
197            unsafe fn from_glib_none_num_as_vec(ptr: *mut *mut $ffi_name, num: usize) -> Vec<Self> {
198                if num == 0 || ptr.is_null() {
199                    return Vec::new();
200                }
201
202                let mut res = Vec::with_capacity(num);
203                for i in 0..num {
204                    res.push($crate::translate::from_glib_none(::std::ptr::read(ptr.add(i))));
205                }
206                res
207            }
208
209            unsafe fn from_glib_container_num_as_vec(ptr: *mut *mut $ffi_name, num: usize) -> Vec<Self> {
210                let res = $crate::translate::FromGlibContainerAsVec::from_glib_none_num_as_vec(ptr, num);
211                $crate::glib_sys::g_free(ptr as *mut _);
212                res
213            }
214
215            unsafe fn from_glib_full_num_as_vec(ptr: *mut *mut $ffi_name, num: usize) -> Vec<Self> {
216                if num == 0 || ptr.is_null() {
217                    return Vec::new();
218                }
219
220                let mut res = Vec::with_capacity(num);
221                for i in 0..num {
222                    res.push($crate::translate::from_glib_full(::std::ptr::read(ptr.add(i))));
223                }
224                $crate::glib_sys::g_free(ptr as *mut _);
225                res
226            }
227        }
228
229        #[doc(hidden)]
230        impl $crate::translate::FromGlibPtrArrayContainerAsVec<*mut $ffi_name, *mut *mut $ffi_name> for $name {
231            unsafe fn from_glib_none_as_vec(ptr: *mut *mut $ffi_name) -> Vec<Self> {
232                $crate::translate::FromGlibContainerAsVec::from_glib_none_num_as_vec(ptr, $crate::translate::c_ptr_array_len(ptr))
233            }
234
235            unsafe fn from_glib_container_as_vec(ptr: *mut *mut $ffi_name) -> Vec<Self> {
236                $crate::translate::FromGlibContainerAsVec::from_glib_container_num_as_vec(ptr, $crate::translate::c_ptr_array_len(ptr))
237            }
238
239            unsafe fn from_glib_full_as_vec(ptr: *mut *mut $ffi_name) -> Vec<Self> {
240                $crate::translate::FromGlibContainerAsVec::from_glib_full_num_as_vec(ptr, $crate::translate::c_ptr_array_len(ptr))
241            }
242        }
243
244        #[doc(hidden)]
245        impl $crate::translate::FromGlibContainerAsVec<*mut $ffi_name, *const *mut $ffi_name> for $name {
246            unsafe fn from_glib_none_num_as_vec(ptr: *const *mut $ffi_name, num: usize) -> Vec<Self> {
247                $crate::translate::FromGlibContainerAsVec::from_glib_none_num_as_vec(ptr as *mut *mut _, num)
248            }
249
250            unsafe fn from_glib_container_num_as_vec(_: *const *mut $ffi_name, _: usize) -> Vec<Self> {
251                // Can't free a *const
252                unimplemented!()
253            }
254
255            unsafe fn from_glib_full_num_as_vec(_: *const *mut $ffi_name, _: usize) -> Vec<Self> {
256                // Can't free a *const
257                unimplemented!()
258            }
259        }
260
261        #[doc(hidden)]
262        impl $crate::translate::FromGlibPtrArrayContainerAsVec<*mut $ffi_name, *const *mut $ffi_name> for $name {
263            unsafe fn from_glib_none_as_vec(ptr: *const *mut $ffi_name) -> Vec<Self> {
264                $crate::translate::FromGlibPtrArrayContainerAsVec::from_glib_none_as_vec(ptr as *mut *mut _)
265            }
266
267            unsafe fn from_glib_container_as_vec(_: *const *mut $ffi_name) -> Vec<Self> {
268                // Can't free a *const
269                unimplemented!()
270            }
271
272            unsafe fn from_glib_full_as_vec(_: *const *mut $ffi_name) -> Vec<Self> {
273                // Can't free a *const
274                unimplemented!()
275            }
276        }
277    }
278}
279
280pub trait SharedMemoryManager<T> {
281    unsafe fn ref_(ptr: *mut T);
282    unsafe fn unref(ptr: *mut T);
283}
284
285/// Encapsulates memory management logic for shared types.
286pub struct Shared<T, MM: SharedMemoryManager<T>> {
287    inner: ptr::NonNull<T>,
288    borrowed: bool,
289    mm: PhantomData<*const MM>,
290}
291
292impl<T, MM: SharedMemoryManager<T>> Drop for Shared<T, MM> {
293    fn drop(&mut self) {
294        if !self.borrowed {
295            unsafe {
296                MM::unref(self.inner.as_ptr());
297            }
298        }
299    }
300}
301
302impl<T, MM: SharedMemoryManager<T>> Clone for Shared<T, MM> {
303    fn clone(&self) -> Self {
304        unsafe {
305            MM::ref_(self.inner.as_ptr());
306        }
307        Shared {
308            inner: self.inner,
309            borrowed: false,
310            mm: PhantomData,
311        }
312    }
313}
314
315impl<T, MM: SharedMemoryManager<T>> fmt::Debug for Shared<T, MM> {
316    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
317        f.debug_struct("Shared")
318            .field("inner", &self.inner)
319            .field("borrowed", &self.borrowed)
320            .finish()
321    }
322}
323
324impl<T, MM: SharedMemoryManager<T>> PartialOrd for Shared<T, MM> {
325    fn partial_cmp(&self, other: &Self) -> Option<cmp::Ordering> {
326        self.inner.partial_cmp(&other.inner)
327    }
328}
329
330impl<T, MM: SharedMemoryManager<T>> Ord for Shared<T, MM> {
331    fn cmp(&self, other: &Self) -> cmp::Ordering {
332        self.inner.cmp(&other.inner)
333    }
334}
335
336impl<T, MM: SharedMemoryManager<T>> PartialEq for Shared<T, MM> {
337    fn eq(&self, other: &Self) -> bool {
338        self.inner == other.inner
339    }
340}
341
342impl<T, MM: SharedMemoryManager<T>> Eq for Shared<T, MM> {}
343
344impl<T, MM: SharedMemoryManager<T>> Hash for Shared<T, MM> {
345    fn hash<H>(&self, state: &mut H)
346    where
347        H: Hasher,
348    {
349        self.inner.hash(state)
350    }
351}
352
353impl<'a, T: 'static, MM> ToGlibPtr<'a, *mut T> for Shared<T, MM>
354where
355    MM: SharedMemoryManager<T> + 'static,
356{
357    type Storage = &'a Self;
358
359    #[inline]
360    fn to_glib_none(&'a self) -> Stash<'a, *mut T, Self> {
361        Stash(self.inner.as_ptr(), self)
362    }
363
364    #[inline]
365    fn to_glib_full(&self) -> *mut T {
366        unsafe {
367            MM::ref_(self.inner.as_ptr());
368        }
369        self.inner.as_ptr()
370    }
371}
372
373impl<T: 'static, MM: SharedMemoryManager<T>> FromGlibPtrNone<*mut T> for Shared<T, MM> {
374    #[inline]
375    unsafe fn from_glib_none(ptr: *mut T) -> Self {
376        assert!(!ptr.is_null());
377        MM::ref_(ptr);
378        Shared {
379            inner: ptr::NonNull::new_unchecked(ptr),
380            borrowed: false,
381            mm: PhantomData,
382        }
383    }
384}
385
386impl<T: 'static, MM: SharedMemoryManager<T>> FromGlibPtrNone<*const T> for Shared<T, MM> {
387    #[inline]
388    unsafe fn from_glib_none(ptr: *const T) -> Self {
389        assert!(!ptr.is_null());
390        MM::ref_(ptr as *mut _);
391        Shared {
392            inner: ptr::NonNull::new_unchecked(ptr as *mut _),
393            borrowed: false,
394            mm: PhantomData,
395        }
396    }
397}
398
399impl<T: 'static, MM: SharedMemoryManager<T>> FromGlibPtrFull<*mut T> for Shared<T, MM> {
400    #[inline]
401    unsafe fn from_glib_full(ptr: *mut T) -> Self {
402        assert!(!ptr.is_null());
403        Shared {
404            inner: ptr::NonNull::new_unchecked(ptr),
405            borrowed: false,
406            mm: PhantomData,
407        }
408    }
409}
410
411impl<T: 'static, MM: SharedMemoryManager<T>> FromGlibPtrBorrow<*mut T> for Shared<T, MM> {
412    #[inline]
413    unsafe fn from_glib_borrow(ptr: *mut T) -> Self {
414        assert!(!ptr.is_null());
415        Shared {
416            inner: ptr::NonNull::new_unchecked(ptr),
417            borrowed: true,
418            mm: PhantomData,
419        }
420    }
421}