objc2_core_graphics/generated/
CGDataProvider.rs1use core::cell::UnsafeCell;
4use core::ffi::*;
5use core::marker::{PhantomData, PhantomPinned};
6use core::ptr::NonNull;
7#[cfg(feature = "objc2")]
8use objc2::__framework_prelude::*;
9use objc2_core_foundation::*;
10
11use crate::*;
12
13#[doc(alias = "CGDataProviderRef")]
15#[repr(C)]
16pub struct CGDataProvider {
17 inner: [u8; 0],
18 _p: UnsafeCell<PhantomData<(*const UnsafeCell<()>, PhantomPinned)>>,
19}
20
21cf_type!(
22 unsafe impl CGDataProvider {}
23);
24#[cfg(feature = "objc2")]
25cf_objc2_type!(
26 unsafe impl RefEncode<"CGDataProvider"> for CGDataProvider {}
27);
28
29pub type CGDataProviderGetBytesCallback =
31 Option<unsafe extern "C-unwind" fn(*mut c_void, NonNull<c_void>, usize) -> usize>;
32
33#[cfg(feature = "libc")]
35pub type CGDataProviderSkipForwardCallback =
36 Option<unsafe extern "C-unwind" fn(*mut c_void, libc::off_t) -> libc::off_t>;
37
38pub type CGDataProviderRewindCallback = Option<unsafe extern "C-unwind" fn(*mut c_void)>;
40
41pub type CGDataProviderReleaseInfoCallback = Option<unsafe extern "C-unwind" fn(*mut c_void)>;
43
44#[cfg(feature = "libc")]
46#[repr(C)]
47#[allow(unpredictable_function_pointer_comparisons)]
48#[derive(Clone, Copy, Debug, PartialEq)]
49pub struct CGDataProviderSequentialCallbacks {
50 pub version: c_uint,
51 pub getBytes: CGDataProviderGetBytesCallback,
52 pub skipForward: CGDataProviderSkipForwardCallback,
53 pub rewind: CGDataProviderRewindCallback,
54 pub releaseInfo: CGDataProviderReleaseInfoCallback,
55}
56
57#[cfg(all(feature = "libc", feature = "objc2"))]
58unsafe impl Encode for CGDataProviderSequentialCallbacks {
59 const ENCODING: Encoding = Encoding::Struct(
60 "CGDataProviderSequentialCallbacks",
61 &[
62 <c_uint>::ENCODING,
63 <CGDataProviderGetBytesCallback>::ENCODING,
64 <CGDataProviderSkipForwardCallback>::ENCODING,
65 <CGDataProviderRewindCallback>::ENCODING,
66 <CGDataProviderReleaseInfoCallback>::ENCODING,
67 ],
68 );
69}
70
71#[cfg(all(feature = "libc", feature = "objc2"))]
72unsafe impl RefEncode for CGDataProviderSequentialCallbacks {
73 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
74}
75
76pub type CGDataProviderGetBytePointerCallback =
78 Option<unsafe extern "C-unwind" fn(*mut c_void) -> *const c_void>;
79
80pub type CGDataProviderReleaseBytePointerCallback =
82 Option<unsafe extern "C-unwind" fn(*mut c_void, NonNull<c_void>)>;
83
84#[cfg(feature = "libc")]
86pub type CGDataProviderGetBytesAtPositionCallback =
87 Option<unsafe extern "C-unwind" fn(*mut c_void, NonNull<c_void>, libc::off_t, usize) -> usize>;
88
89#[cfg(feature = "libc")]
91#[repr(C)]
92#[allow(unpredictable_function_pointer_comparisons)]
93#[derive(Clone, Copy, Debug, PartialEq)]
94pub struct CGDataProviderDirectCallbacks {
95 pub version: c_uint,
96 pub getBytePointer: CGDataProviderGetBytePointerCallback,
97 pub releaseBytePointer: CGDataProviderReleaseBytePointerCallback,
98 pub getBytesAtPosition: CGDataProviderGetBytesAtPositionCallback,
99 pub releaseInfo: CGDataProviderReleaseInfoCallback,
100}
101
102#[cfg(all(feature = "libc", feature = "objc2"))]
103unsafe impl Encode for CGDataProviderDirectCallbacks {
104 const ENCODING: Encoding = Encoding::Struct(
105 "CGDataProviderDirectCallbacks",
106 &[
107 <c_uint>::ENCODING,
108 <CGDataProviderGetBytePointerCallback>::ENCODING,
109 <CGDataProviderReleaseBytePointerCallback>::ENCODING,
110 <CGDataProviderGetBytesAtPositionCallback>::ENCODING,
111 <CGDataProviderReleaseInfoCallback>::ENCODING,
112 ],
113 );
114}
115
116#[cfg(all(feature = "libc", feature = "objc2"))]
117unsafe impl RefEncode for CGDataProviderDirectCallbacks {
118 const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
119}
120
121unsafe impl ConcreteType for CGDataProvider {
122 #[doc(alias = "CGDataProviderGetTypeID")]
123 #[inline]
124 fn type_id() -> CFTypeID {
125 extern "C-unwind" {
126 fn CGDataProviderGetTypeID() -> CFTypeID;
127 }
128 unsafe { CGDataProviderGetTypeID() }
129 }
130}
131
132impl CGDataProvider {
133 #[doc(alias = "CGDataProviderCreateSequential")]
138 #[cfg(feature = "libc")]
139 #[inline]
140 pub unsafe fn new_sequential(
141 info: *mut c_void,
142 callbacks: *const CGDataProviderSequentialCallbacks,
143 ) -> Option<CFRetained<CGDataProvider>> {
144 extern "C-unwind" {
145 fn CGDataProviderCreateSequential(
146 info: *mut c_void,
147 callbacks: *const CGDataProviderSequentialCallbacks,
148 ) -> Option<NonNull<CGDataProvider>>;
149 }
150 let ret = unsafe { CGDataProviderCreateSequential(info, callbacks) };
151 ret.map(|ret| unsafe { CFRetained::from_raw(ret) })
152 }
153
154 #[doc(alias = "CGDataProviderCreateDirect")]
159 #[cfg(feature = "libc")]
160 #[inline]
161 pub unsafe fn new_direct(
162 info: *mut c_void,
163 size: libc::off_t,
164 callbacks: *const CGDataProviderDirectCallbacks,
165 ) -> Option<CFRetained<CGDataProvider>> {
166 extern "C-unwind" {
167 fn CGDataProviderCreateDirect(
168 info: *mut c_void,
169 size: libc::off_t,
170 callbacks: *const CGDataProviderDirectCallbacks,
171 ) -> Option<NonNull<CGDataProvider>>;
172 }
173 let ret = unsafe { CGDataProviderCreateDirect(info, size, callbacks) };
174 ret.map(|ret| unsafe { CFRetained::from_raw(ret) })
175 }
176}
177
178pub type CGDataProviderReleaseDataCallback =
180 Option<unsafe extern "C-unwind" fn(*mut c_void, NonNull<c_void>, usize)>;
181
182impl CGDataProvider {
183 #[doc(alias = "CGDataProviderCreateWithData")]
189 #[inline]
190 pub unsafe fn with_data(
191 info: *mut c_void,
192 data: *const c_void,
193 size: usize,
194 release_data: CGDataProviderReleaseDataCallback,
195 ) -> Option<CFRetained<CGDataProvider>> {
196 extern "C-unwind" {
197 fn CGDataProviderCreateWithData(
198 info: *mut c_void,
199 data: *const c_void,
200 size: usize,
201 release_data: CGDataProviderReleaseDataCallback,
202 ) -> Option<NonNull<CGDataProvider>>;
203 }
204 let ret = unsafe { CGDataProviderCreateWithData(info, data, size, release_data) };
205 ret.map(|ret| unsafe { CFRetained::from_raw(ret) })
206 }
207
208 #[doc(alias = "CGDataProviderCreateWithCFData")]
209 #[inline]
210 pub fn with_cf_data(data: Option<&CFData>) -> Option<CFRetained<CGDataProvider>> {
211 extern "C-unwind" {
212 fn CGDataProviderCreateWithCFData(
213 data: Option<&CFData>,
214 ) -> Option<NonNull<CGDataProvider>>;
215 }
216 let ret = unsafe { CGDataProviderCreateWithCFData(data) };
217 ret.map(|ret| unsafe { CFRetained::from_raw(ret) })
218 }
219
220 #[doc(alias = "CGDataProviderCreateWithURL")]
221 #[inline]
222 pub fn with_url(url: Option<&CFURL>) -> Option<CFRetained<CGDataProvider>> {
223 extern "C-unwind" {
224 fn CGDataProviderCreateWithURL(url: Option<&CFURL>) -> Option<NonNull<CGDataProvider>>;
225 }
226 let ret = unsafe { CGDataProviderCreateWithURL(url) };
227 ret.map(|ret| unsafe { CFRetained::from_raw(ret) })
228 }
229
230 #[doc(alias = "CGDataProviderCreateWithFilename")]
234 #[inline]
235 pub unsafe fn with_filename(filename: *const c_char) -> Option<CFRetained<CGDataProvider>> {
236 extern "C-unwind" {
237 fn CGDataProviderCreateWithFilename(
238 filename: *const c_char,
239 ) -> Option<NonNull<CGDataProvider>>;
240 }
241 let ret = unsafe { CGDataProviderCreateWithFilename(filename) };
242 ret.map(|ret| unsafe { CFRetained::from_raw(ret) })
243 }
244
245 #[doc(alias = "CGDataProviderCopyData")]
246 #[inline]
247 pub fn data(provider: Option<&CGDataProvider>) -> Option<CFRetained<CFData>> {
248 extern "C-unwind" {
249 fn CGDataProviderCopyData(provider: Option<&CGDataProvider>)
250 -> Option<NonNull<CFData>>;
251 }
252 let ret = unsafe { CGDataProviderCopyData(provider) };
253 ret.map(|ret| unsafe { CFRetained::from_raw(ret) })
254 }
255
256 #[doc(alias = "CGDataProviderGetInfo")]
257 #[inline]
258 pub fn info(provider: Option<&CGDataProvider>) -> *mut c_void {
259 extern "C-unwind" {
260 fn CGDataProviderGetInfo(provider: Option<&CGDataProvider>) -> *mut c_void;
261 }
262 unsafe { CGDataProviderGetInfo(provider) }
263 }
264}
265
266#[cfg(feature = "libc")]
267#[deprecated = "renamed to `CGDataProvider::new_sequential`"]
268#[inline]
269pub unsafe extern "C-unwind" fn CGDataProviderCreateSequential(
270 info: *mut c_void,
271 callbacks: *const CGDataProviderSequentialCallbacks,
272) -> Option<CFRetained<CGDataProvider>> {
273 extern "C-unwind" {
274 fn CGDataProviderCreateSequential(
275 info: *mut c_void,
276 callbacks: *const CGDataProviderSequentialCallbacks,
277 ) -> Option<NonNull<CGDataProvider>>;
278 }
279 let ret = unsafe { CGDataProviderCreateSequential(info, callbacks) };
280 ret.map(|ret| unsafe { CFRetained::from_raw(ret) })
281}
282
283#[cfg(feature = "libc")]
284#[deprecated = "renamed to `CGDataProvider::new_direct`"]
285#[inline]
286pub unsafe extern "C-unwind" fn CGDataProviderCreateDirect(
287 info: *mut c_void,
288 size: libc::off_t,
289 callbacks: *const CGDataProviderDirectCallbacks,
290) -> Option<CFRetained<CGDataProvider>> {
291 extern "C-unwind" {
292 fn CGDataProviderCreateDirect(
293 info: *mut c_void,
294 size: libc::off_t,
295 callbacks: *const CGDataProviderDirectCallbacks,
296 ) -> Option<NonNull<CGDataProvider>>;
297 }
298 let ret = unsafe { CGDataProviderCreateDirect(info, size, callbacks) };
299 ret.map(|ret| unsafe { CFRetained::from_raw(ret) })
300}
301
302#[deprecated = "renamed to `CGDataProvider::with_data`"]
303#[inline]
304pub unsafe extern "C-unwind" fn CGDataProviderCreateWithData(
305 info: *mut c_void,
306 data: *const c_void,
307 size: usize,
308 release_data: CGDataProviderReleaseDataCallback,
309) -> Option<CFRetained<CGDataProvider>> {
310 extern "C-unwind" {
311 fn CGDataProviderCreateWithData(
312 info: *mut c_void,
313 data: *const c_void,
314 size: usize,
315 release_data: CGDataProviderReleaseDataCallback,
316 ) -> Option<NonNull<CGDataProvider>>;
317 }
318 let ret = unsafe { CGDataProviderCreateWithData(info, data, size, release_data) };
319 ret.map(|ret| unsafe { CFRetained::from_raw(ret) })
320}
321
322#[deprecated = "renamed to `CGDataProvider::with_cf_data`"]
323#[inline]
324pub extern "C-unwind" fn CGDataProviderCreateWithCFData(
325 data: Option<&CFData>,
326) -> Option<CFRetained<CGDataProvider>> {
327 extern "C-unwind" {
328 fn CGDataProviderCreateWithCFData(data: Option<&CFData>)
329 -> Option<NonNull<CGDataProvider>>;
330 }
331 let ret = unsafe { CGDataProviderCreateWithCFData(data) };
332 ret.map(|ret| unsafe { CFRetained::from_raw(ret) })
333}
334
335#[deprecated = "renamed to `CGDataProvider::with_url`"]
336#[inline]
337pub extern "C-unwind" fn CGDataProviderCreateWithURL(
338 url: Option<&CFURL>,
339) -> Option<CFRetained<CGDataProvider>> {
340 extern "C-unwind" {
341 fn CGDataProviderCreateWithURL(url: Option<&CFURL>) -> Option<NonNull<CGDataProvider>>;
342 }
343 let ret = unsafe { CGDataProviderCreateWithURL(url) };
344 ret.map(|ret| unsafe { CFRetained::from_raw(ret) })
345}
346
347#[deprecated = "renamed to `CGDataProvider::with_filename`"]
348#[inline]
349pub unsafe extern "C-unwind" fn CGDataProviderCreateWithFilename(
350 filename: *const c_char,
351) -> Option<CFRetained<CGDataProvider>> {
352 extern "C-unwind" {
353 fn CGDataProviderCreateWithFilename(
354 filename: *const c_char,
355 ) -> Option<NonNull<CGDataProvider>>;
356 }
357 let ret = unsafe { CGDataProviderCreateWithFilename(filename) };
358 ret.map(|ret| unsafe { CFRetained::from_raw(ret) })
359}
360
361#[deprecated = "renamed to `CGDataProvider::data`"]
362#[inline]
363pub extern "C-unwind" fn CGDataProviderCopyData(
364 provider: Option<&CGDataProvider>,
365) -> Option<CFRetained<CFData>> {
366 extern "C-unwind" {
367 fn CGDataProviderCopyData(provider: Option<&CGDataProvider>) -> Option<NonNull<CFData>>;
368 }
369 let ret = unsafe { CGDataProviderCopyData(provider) };
370 ret.map(|ret| unsafe { CFRetained::from_raw(ret) })
371}
372
373#[deprecated = "renamed to `CGDataProvider::info`"]
374#[inline]
375pub extern "C-unwind" fn CGDataProviderGetInfo(provider: Option<&CGDataProvider>) -> *mut c_void {
376 extern "C-unwind" {
377 fn CGDataProviderGetInfo(provider: Option<&CGDataProvider>) -> *mut c_void;
378 }
379 unsafe { CGDataProviderGetInfo(provider) }
380}