cogl/
fence_closure.rs

1use glib::translate::*;
2use std::mem;
3use std::ptr;
4
5#[repr(C)]
6#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
7pub struct FenceClosure(ffi::CoglFenceClosure);
8
9impl GlibPtrDefault for FenceClosure {
10    type GlibType = ffi::CoglFenceClosure;
11}
12
13#[doc(hidden)]
14impl Uninitialized for FenceClosure {
15    #[inline]
16    unsafe fn uninitialized() -> Self {
17        mem::zeroed()
18    }
19}
20
21impl<'a> ToGlibPtr<'a, ffi::CoglFenceClosure> for FenceClosure {
22    type Storage = ();
23
24    #[inline]
25    fn to_glib_none(&self) -> Stash<'a, ffi::CoglFenceClosure, FenceClosure> {
26        Stash(self.0, ())
27    }
28}
29
30impl<'a> ToGlibPtrMut<'a, *mut ffi::CoglFenceClosure> for FenceClosure {
31    type Storage = ();
32
33    #[inline]
34    fn to_glib_none_mut(&'a mut self) -> StashMut<'a, *mut ffi::CoglFenceClosure, FenceClosure> {
35        StashMut(&mut self.0, ())
36    }
37}
38
39impl<'a> ToGlibContainerFromSlice<'a, *mut ffi::CoglFenceClosure> for &'a FenceClosure {
40    type Storage = (
41        Vec<Stash<'a, ffi::CoglFenceClosure, &'a FenceClosure>>,
42        Option<Vec<ffi::CoglFenceClosure>>,
43    );
44
45    fn to_glib_none_from_slice(
46        t: &'a [&'a FenceClosure],
47    ) -> (*mut ffi::CoglFenceClosure, Self::Storage) {
48        let v: Vec<_> = t.iter().map(|s| s.to_glib_none()).collect();
49        let mut v_ptr: Vec<_> = v.iter().map(|s| s.0).collect();
50        v_ptr.push(ptr::null_mut());
51
52        (
53            v_ptr.as_ptr() as *mut ffi::CoglFenceClosure,
54            (v, Some(v_ptr)),
55        )
56    }
57
58    fn to_glib_container_from_slice(
59        t: &'a [&'a FenceClosure],
60    ) -> (*mut ffi::CoglFenceClosure, Self::Storage) {
61        let v: Vec<_> = t.iter().map(|s| s.to_glib_none()).collect();
62
63        let v_ptr = unsafe {
64            let v_ptr = glib_sys::g_malloc0(mem::size_of::<ffi::CoglFenceClosure>() * (t.len() + 1))
65                as *mut ffi::CoglFenceClosure;
66
67            for (i, s) in v.iter().enumerate() {
68                ptr::write(v_ptr.add(i), s.0);
69            }
70
71            v_ptr
72        };
73
74        (v_ptr, (v, None))
75    }
76
77    fn to_glib_full_from_slice(_: &[&'a FenceClosure]) -> *mut ffi::CoglFenceClosure {
78        unimplemented!()
79    }
80}
81
82impl<'a> ToGlibContainerFromSlice<'a, *const ffi::CoglFenceClosure> for &'a FenceClosure {
83    type Storage = (
84        Vec<Stash<'a, ffi::CoglFenceClosure, &'a FenceClosure>>,
85        Option<Vec<ffi::CoglFenceClosure>>,
86    );
87
88    fn to_glib_none_from_slice(
89        t: &'a [&'a FenceClosure],
90    ) -> (*const ffi::CoglFenceClosure, Self::Storage) {
91        let v: Vec<_> = t.iter().map(|s| s.to_glib_none()).collect();
92        let mut v_ptr: Vec<_> = v.iter().map(|s| s.0).collect();
93        v_ptr.push(ptr::null_mut());
94
95        (
96            v_ptr.as_ptr() as *const ffi::CoglFenceClosure,
97            (v, Some(v_ptr)),
98        )
99    }
100
101    fn to_glib_container_from_slice(
102        t: &'a [&'a FenceClosure],
103    ) -> (*const ffi::CoglFenceClosure, Self::Storage) {
104        let v: Vec<_> = t.iter().map(|s| s.to_glib_none()).collect();
105
106        let v_ptr = unsafe {
107            let v_ptr = glib_sys::g_malloc0(mem::size_of::<ffi::CoglFenceClosure>() * (t.len() + 1))
108                as *mut ffi::CoglFenceClosure;
109
110            for (i, s) in v.iter().enumerate() {
111                ptr::write(v_ptr.add(i), s.0);
112            }
113
114            v_ptr as *const ffi::CoglFenceClosure
115        };
116
117        (v_ptr, (v, None))
118    }
119
120    fn to_glib_full_from_slice(_: &[&'a FenceClosure]) -> *const ffi::CoglFenceClosure {
121        unimplemented!()
122    }
123}
124
125impl FromGlibPtrNone<ffi::CoglFenceClosure> for FenceClosure {
126    #[inline]
127    unsafe fn from_glib_none(ptr: ffi::CoglFenceClosure) -> FenceClosure {
128        FenceClosure(ptr)
129    }
130}
131
132#[doc(hidden)]
133impl FromGlibPtrNone<*const ffi::CoglFenceClosure> for FenceClosure {
134    unsafe fn from_glib_none(ptr: *const ffi::CoglFenceClosure) -> Self {
135        *(ptr as *const FenceClosure)
136    }
137}
138
139#[doc(hidden)]
140impl FromGlibPtrNone<*mut ffi::CoglFenceClosure> for FenceClosure {
141    unsafe fn from_glib_none(ptr: *mut ffi::CoglFenceClosure) -> Self {
142        *(ptr as *mut FenceClosure)
143    }
144}
145
146impl FromGlibPtrBorrow<ffi::CoglFenceClosure> for FenceClosure {
147    #[inline]
148    unsafe fn from_glib_borrow(
149        ptr: ffi::CoglFenceClosure,
150    ) -> glib::translate::Borrowed<FenceClosure> {
151        glib::translate::Borrowed::new(FenceClosure(ptr))
152    }
153}
154
155#[doc(hidden)]
156impl FromGlibPtrBorrow<*mut ffi::CoglFenceClosure> for FenceClosure {
157    unsafe fn from_glib_borrow(ptr: *mut ffi::CoglFenceClosure) -> glib::translate::Borrowed<Self> {
158        glib::translate::Borrowed::new(*(ptr as *mut FenceClosure))
159    }
160}
161
162#[doc(hidden)]
163impl FromGlibPtrBorrow<*const ffi::CoglFenceClosure> for FenceClosure {
164    unsafe fn from_glib_borrow(
165        ptr: *const ffi::CoglFenceClosure,
166    ) -> glib::translate::Borrowed<Self> {
167        glib::translate::Borrowed::new(*(ptr as *const FenceClosure))
168    }
169}
170
171impl FromGlibPtrFull<ffi::CoglFenceClosure> for FenceClosure {
172    #[inline]
173    unsafe fn from_glib_full(_: ffi::CoglFenceClosure) -> FenceClosure {
174        unimplemented!()
175    }
176}
177
178impl FromGlibContainerAsVec<ffi::CoglFenceClosure, *mut ffi::CoglFenceClosure> for FenceClosure {
179    unsafe fn from_glib_none_num_as_vec(ptr: *mut ffi::CoglFenceClosure, num: usize) -> Vec<Self> {
180        if num == 0 || ptr.is_null() {
181            return Vec::new();
182        }
183
184        let mut res = Vec::with_capacity(num);
185        for i in 0..num {
186            res.push(from_glib_none(ptr::read(ptr.add(i))));
187        }
188        res
189    }
190
191    unsafe fn from_glib_container_num_as_vec(
192        ptr: *mut ffi::CoglFenceClosure,
193        num: usize,
194    ) -> Vec<Self> {
195        let res = FromGlibContainerAsVec::from_glib_none_num_as_vec(ptr, num);
196        glib_sys::g_free(ptr as *mut _);
197        res
198    }
199
200    unsafe fn from_glib_full_num_as_vec(ptr: *mut ffi::CoglFenceClosure, num: usize) -> Vec<Self> {
201        if num == 0 || ptr.is_null() {
202            return Vec::new();
203        }
204
205        let mut res = Vec::with_capacity(num);
206        for i in 0..num {
207            res.push(from_glib_full(ptr::read(ptr.add(i))));
208        }
209        glib_sys::g_free(ptr as *mut _);
210        res
211    }
212}
213
214impl FromGlibPtrArrayContainerAsVec<ffi::CoglFenceClosure, *mut ffi::CoglFenceClosure>
215    for FenceClosure
216{
217    unsafe fn from_glib_none_as_vec(ptr: *mut ffi::CoglFenceClosure) -> Vec<Self> {
218        FromGlibContainerAsVec::from_glib_none_num_as_vec(ptr, c_ptr_array_len(ptr))
219    }
220
221    unsafe fn from_glib_container_as_vec(ptr: *mut ffi::CoglFenceClosure) -> Vec<Self> {
222        FromGlibContainerAsVec::from_glib_container_num_as_vec(ptr, c_ptr_array_len(ptr))
223    }
224
225    unsafe fn from_glib_full_as_vec(ptr: *mut ffi::CoglFenceClosure) -> Vec<Self> {
226        FromGlibContainerAsVec::from_glib_full_num_as_vec(ptr, c_ptr_array_len(ptr))
227    }
228}
cogl/fence_closure.rs

cogl/
fence_closure.rs
