1use std::cmp;
8use std::fmt;
9use std::hash::{Hash, Hasher};
10use std::marker::PhantomData;
11use std::ptr;
12use translate::*;
13
14#[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 unimplemented!()
147 }
148
149 fn to_glib_full_from_slice(_: &[$name]) -> *const *mut $ffi_name {
150 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 unimplemented!()
253 }
254
255 unsafe fn from_glib_full_num_as_vec(_: *const *mut $ffi_name, _: usize) -> Vec<Self> {
256 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 unimplemented!()
270 }
271
272 unsafe fn from_glib_full_as_vec(_: *const *mut $ffi_name) -> Vec<Self> {
273 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
285pub 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}