objc2_core_foundation/generated/
CFPlugIn.rs1use core::cell::UnsafeCell;
4use core::ffi::*;
5use core::marker::{PhantomData, PhantomPinned};
6use core::ptr::NonNull;
7#[cfg(feature = "objc2")]
8use objc2::__framework_prelude::*;
9
10use crate::*;
11
12extern "C" {
13 pub static kCFPlugInDynamicRegistrationKey: Option<&'static CFString>;
15}
16
17extern "C" {
18 pub static kCFPlugInDynamicRegisterFunctionKey: Option<&'static CFString>;
20}
21
22extern "C" {
23 pub static kCFPlugInUnloadFunctionKey: Option<&'static CFString>;
25}
26
27extern "C" {
28 pub static kCFPlugInFactoriesKey: Option<&'static CFString>;
30}
31
32extern "C" {
33 pub static kCFPlugInTypesKey: Option<&'static CFString>;
35}
36
37#[cfg(feature = "CFBundle")]
39pub type CFPlugInDynamicRegisterFunction = Option<unsafe extern "C-unwind" fn(*mut CFPlugIn)>;
40
41#[cfg(feature = "CFBundle")]
43pub type CFPlugInUnloadFunction = Option<unsafe extern "C-unwind" fn(*mut CFPlugIn)>;
44
45#[cfg(feature = "CFUUID")]
47pub type CFPlugInFactoryFunction =
48 Option<unsafe extern "C-unwind" fn(*const CFAllocator, *const CFUUID) -> *mut c_void>;
49
50#[cfg(feature = "CFBundle")]
51unsafe impl ConcreteType for CFPlugIn {
52 #[doc(alias = "CFPlugInGetTypeID")]
53 #[inline]
54 fn type_id() -> CFTypeID {
55 extern "C-unwind" {
56 fn CFPlugInGetTypeID() -> CFTypeID;
57 }
58 unsafe { CFPlugInGetTypeID() }
59 }
60}
61
62#[cfg(feature = "CFBundle")]
63impl CFPlugIn {
64 #[doc(alias = "CFPlugInCreate")]
65 #[cfg(all(feature = "CFBundle", feature = "CFURL"))]
66 #[inline]
67 pub fn new(
68 allocator: Option<&CFAllocator>,
69 plug_in_url: Option<&CFURL>,
70 ) -> Option<CFRetained<CFPlugIn>> {
71 extern "C-unwind" {
72 fn CFPlugInCreate(
73 allocator: Option<&CFAllocator>,
74 plug_in_url: Option<&CFURL>,
75 ) -> Option<NonNull<CFPlugIn>>;
76 }
77 let ret = unsafe { CFPlugInCreate(allocator, plug_in_url) };
78 ret.map(|ret| unsafe { CFRetained::from_raw(ret) })
79 }
80
81 #[doc(alias = "CFPlugInGetBundle")]
82 #[cfg(feature = "CFBundle")]
83 #[inline]
84 pub fn bundle(self: &CFPlugIn) -> Option<CFRetained<CFBundle>> {
85 extern "C-unwind" {
86 fn CFPlugInGetBundle(plug_in: &CFPlugIn) -> Option<NonNull<CFBundle>>;
87 }
88 let ret = unsafe { CFPlugInGetBundle(self) };
89 ret.map(|ret| unsafe { CFRetained::retain(ret) })
90 }
91
92 #[doc(alias = "CFPlugInSetLoadOnDemand")]
93 #[cfg(feature = "CFBundle")]
94 #[inline]
95 pub fn set_load_on_demand(self: &CFPlugIn, flag: bool) {
96 extern "C-unwind" {
97 fn CFPlugInSetLoadOnDemand(plug_in: &CFPlugIn, flag: Boolean);
98 }
99 unsafe { CFPlugInSetLoadOnDemand(self, flag as _) }
100 }
101
102 #[doc(alias = "CFPlugInIsLoadOnDemand")]
103 #[cfg(feature = "CFBundle")]
104 #[inline]
105 pub fn is_load_on_demand(self: &CFPlugIn) -> bool {
106 extern "C-unwind" {
107 fn CFPlugInIsLoadOnDemand(plug_in: &CFPlugIn) -> Boolean;
108 }
109 let ret = unsafe { CFPlugInIsLoadOnDemand(self) };
110 ret != 0
111 }
112
113 #[doc(alias = "CFPlugInFindFactoriesForPlugInType")]
114 #[cfg(all(feature = "CFArray", feature = "CFUUID"))]
115 #[inline]
116 pub fn find_factories_for_plug_in_type(
117 type_uuid: Option<&CFUUID>,
118 ) -> Option<CFRetained<CFArray>> {
119 extern "C-unwind" {
120 fn CFPlugInFindFactoriesForPlugInType(
121 type_uuid: Option<&CFUUID>,
122 ) -> Option<NonNull<CFArray>>;
123 }
124 let ret = unsafe { CFPlugInFindFactoriesForPlugInType(type_uuid) };
125 ret.map(|ret| unsafe { CFRetained::from_raw(ret) })
126 }
127
128 #[doc(alias = "CFPlugInFindFactoriesForPlugInTypeInPlugIn")]
129 #[cfg(all(feature = "CFArray", feature = "CFBundle", feature = "CFUUID"))]
130 #[inline]
131 pub fn find_factories_for_plug_in_type_in_plug_in(
132 type_uuid: Option<&CFUUID>,
133 plug_in: Option<&CFPlugIn>,
134 ) -> Option<CFRetained<CFArray>> {
135 extern "C-unwind" {
136 fn CFPlugInFindFactoriesForPlugInTypeInPlugIn(
137 type_uuid: Option<&CFUUID>,
138 plug_in: Option<&CFPlugIn>,
139 ) -> Option<NonNull<CFArray>>;
140 }
141 let ret = unsafe { CFPlugInFindFactoriesForPlugInTypeInPlugIn(type_uuid, plug_in) };
142 ret.map(|ret| unsafe { CFRetained::from_raw(ret) })
143 }
144}
145
146impl CFPlugInInstance {
147 #[doc(alias = "CFPlugInInstanceCreate")]
148 #[cfg(feature = "CFUUID")]
149 #[inline]
150 pub fn create(
151 allocator: Option<&CFAllocator>,
152 factory_uuid: Option<&CFUUID>,
153 type_uuid: Option<&CFUUID>,
154 ) -> *mut c_void {
155 extern "C-unwind" {
156 fn CFPlugInInstanceCreate(
157 allocator: Option<&CFAllocator>,
158 factory_uuid: Option<&CFUUID>,
159 type_uuid: Option<&CFUUID>,
160 ) -> *mut c_void;
161 }
162 unsafe { CFPlugInInstanceCreate(allocator, factory_uuid, type_uuid) }
163 }
164}
165
166#[cfg(feature = "CFBundle")]
167impl CFPlugIn {
168 #[doc(alias = "CFPlugInRegisterFactoryFunction")]
169 #[cfg(feature = "CFUUID")]
170 #[inline]
171 pub fn register_factory_function(
172 factory_uuid: Option<&CFUUID>,
173 func: CFPlugInFactoryFunction,
174 ) -> bool {
175 extern "C-unwind" {
176 fn CFPlugInRegisterFactoryFunction(
177 factory_uuid: Option<&CFUUID>,
178 func: CFPlugInFactoryFunction,
179 ) -> Boolean;
180 }
181 let ret = unsafe { CFPlugInRegisterFactoryFunction(factory_uuid, func) };
182 ret != 0
183 }
184
185 #[doc(alias = "CFPlugInRegisterFactoryFunctionByName")]
186 #[cfg(all(feature = "CFBundle", feature = "CFUUID"))]
187 #[inline]
188 pub fn register_factory_function_by_name(
189 factory_uuid: Option<&CFUUID>,
190 plug_in: Option<&CFPlugIn>,
191 function_name: Option<&CFString>,
192 ) -> bool {
193 extern "C-unwind" {
194 fn CFPlugInRegisterFactoryFunctionByName(
195 factory_uuid: Option<&CFUUID>,
196 plug_in: Option<&CFPlugIn>,
197 function_name: Option<&CFString>,
198 ) -> Boolean;
199 }
200 let ret =
201 unsafe { CFPlugInRegisterFactoryFunctionByName(factory_uuid, plug_in, function_name) };
202 ret != 0
203 }
204
205 #[doc(alias = "CFPlugInUnregisterFactory")]
206 #[cfg(feature = "CFUUID")]
207 #[inline]
208 pub fn unregister_factory(factory_uuid: Option<&CFUUID>) -> bool {
209 extern "C-unwind" {
210 fn CFPlugInUnregisterFactory(factory_uuid: Option<&CFUUID>) -> Boolean;
211 }
212 let ret = unsafe { CFPlugInUnregisterFactory(factory_uuid) };
213 ret != 0
214 }
215
216 #[doc(alias = "CFPlugInRegisterPlugInType")]
217 #[cfg(feature = "CFUUID")]
218 #[inline]
219 pub fn register_plug_in_type(
220 factory_uuid: Option<&CFUUID>,
221 type_uuid: Option<&CFUUID>,
222 ) -> bool {
223 extern "C-unwind" {
224 fn CFPlugInRegisterPlugInType(
225 factory_uuid: Option<&CFUUID>,
226 type_uuid: Option<&CFUUID>,
227 ) -> Boolean;
228 }
229 let ret = unsafe { CFPlugInRegisterPlugInType(factory_uuid, type_uuid) };
230 ret != 0
231 }
232
233 #[doc(alias = "CFPlugInUnregisterPlugInType")]
234 #[cfg(feature = "CFUUID")]
235 #[inline]
236 pub fn unregister_plug_in_type(
237 factory_uuid: Option<&CFUUID>,
238 type_uuid: Option<&CFUUID>,
239 ) -> bool {
240 extern "C-unwind" {
241 fn CFPlugInUnregisterPlugInType(
242 factory_uuid: Option<&CFUUID>,
243 type_uuid: Option<&CFUUID>,
244 ) -> Boolean;
245 }
246 let ret = unsafe { CFPlugInUnregisterPlugInType(factory_uuid, type_uuid) };
247 ret != 0
248 }
249
250 #[doc(alias = "CFPlugInAddInstanceForFactory")]
251 #[cfg(feature = "CFUUID")]
252 #[inline]
253 pub fn add_instance_for_factory(factory_id: Option<&CFUUID>) {
254 extern "C-unwind" {
255 fn CFPlugInAddInstanceForFactory(factory_id: Option<&CFUUID>);
256 }
257 unsafe { CFPlugInAddInstanceForFactory(factory_id) }
258 }
259
260 #[doc(alias = "CFPlugInRemoveInstanceForFactory")]
261 #[cfg(feature = "CFUUID")]
262 #[inline]
263 pub fn remove_instance_for_factory(factory_id: Option<&CFUUID>) {
264 extern "C-unwind" {
265 fn CFPlugInRemoveInstanceForFactory(factory_id: Option<&CFUUID>);
266 }
267 unsafe { CFPlugInRemoveInstanceForFactory(factory_id) }
268 }
269}
270
271#[repr(C)]
273pub struct CFPlugInInstance {
274 inner: [u8; 0],
275 _p: UnsafeCell<PhantomData<(*const UnsafeCell<()>, PhantomPinned)>>,
276}
277
278cf_type!(
279 unsafe impl CFPlugInInstance {}
280);
281#[cfg(feature = "objc2")]
282cf_objc2_type!(
283 unsafe impl RefEncode<"__CFPlugInInstance"> for CFPlugInInstance {}
284);
285
286pub type CFPlugInInstanceGetInterfaceFunction = Option<
288 unsafe extern "C-unwind" fn(
289 *mut CFPlugInInstance,
290 *const CFString,
291 *mut *mut c_void,
292 ) -> Boolean,
293>;
294
295pub type CFPlugInInstanceDeallocateInstanceDataFunction =
297 Option<unsafe extern "C-unwind" fn(*mut c_void)>;
298
299impl CFPlugInInstance {
300 #[doc(alias = "CFPlugInInstanceGetInterfaceFunctionTable")]
301 #[inline]
302 pub unsafe fn interface_function_table(
303 self: &CFPlugInInstance,
304 interface_name: Option<&CFString>,
305 ftbl: *mut *mut c_void,
306 ) -> bool {
307 extern "C-unwind" {
308 fn CFPlugInInstanceGetInterfaceFunctionTable(
309 instance: &CFPlugInInstance,
310 interface_name: Option<&CFString>,
311 ftbl: *mut *mut c_void,
312 ) -> Boolean;
313 }
314 let ret = unsafe { CFPlugInInstanceGetInterfaceFunctionTable(self, interface_name, ftbl) };
315 ret != 0
316 }
317
318 #[doc(alias = "CFPlugInInstanceGetFactoryName")]
319 #[inline]
320 pub fn factory_name(self: &CFPlugInInstance) -> Option<CFRetained<CFString>> {
321 extern "C-unwind" {
322 fn CFPlugInInstanceGetFactoryName(
323 instance: &CFPlugInInstance,
324 ) -> Option<NonNull<CFString>>;
325 }
326 let ret = unsafe { CFPlugInInstanceGetFactoryName(self) };
327 ret.map(|ret| unsafe { CFRetained::from_raw(ret) })
328 }
329
330 #[doc(alias = "CFPlugInInstanceGetInstanceData")]
331 #[inline]
332 pub fn instance_data(self: &CFPlugInInstance) -> *mut c_void {
333 extern "C-unwind" {
334 fn CFPlugInInstanceGetInstanceData(instance: &CFPlugInInstance) -> *mut c_void;
335 }
336 unsafe { CFPlugInInstanceGetInstanceData(self) }
337 }
338}
339
340unsafe impl ConcreteType for CFPlugInInstance {
341 #[doc(alias = "CFPlugInInstanceGetTypeID")]
342 #[inline]
343 fn type_id() -> CFTypeID {
344 extern "C-unwind" {
345 fn CFPlugInInstanceGetTypeID() -> CFTypeID;
346 }
347 unsafe { CFPlugInInstanceGetTypeID() }
348 }
349}
350
351impl CFPlugInInstance {
352 #[doc(alias = "CFPlugInInstanceCreateWithInstanceDataSize")]
353 #[inline]
354 pub unsafe fn with_instance_data_size(
355 allocator: Option<&CFAllocator>,
356 instance_data_size: CFIndex,
357 deallocate_instance_function: CFPlugInInstanceDeallocateInstanceDataFunction,
358 factory_name: Option<&CFString>,
359 get_interface_function: CFPlugInInstanceGetInterfaceFunction,
360 ) -> Option<CFRetained<CFPlugInInstance>> {
361 extern "C-unwind" {
362 fn CFPlugInInstanceCreateWithInstanceDataSize(
363 allocator: Option<&CFAllocator>,
364 instance_data_size: CFIndex,
365 deallocate_instance_function: CFPlugInInstanceDeallocateInstanceDataFunction,
366 factory_name: Option<&CFString>,
367 get_interface_function: CFPlugInInstanceGetInterfaceFunction,
368 ) -> Option<NonNull<CFPlugInInstance>>;
369 }
370 let ret = unsafe {
371 CFPlugInInstanceCreateWithInstanceDataSize(
372 allocator,
373 instance_data_size,
374 deallocate_instance_function,
375 factory_name,
376 get_interface_function,
377 )
378 };
379 ret.map(|ret| unsafe { CFRetained::from_raw(ret) })
380 }
381}
382
383#[cfg(all(feature = "CFBundle", feature = "CFURL"))]
384#[deprecated = "renamed to `CFPlugIn::new`"]
385#[inline]
386pub extern "C-unwind" fn CFPlugInCreate(
387 allocator: Option<&CFAllocator>,
388 plug_in_url: Option<&CFURL>,
389) -> Option<CFRetained<CFPlugIn>> {
390 extern "C-unwind" {
391 fn CFPlugInCreate(
392 allocator: Option<&CFAllocator>,
393 plug_in_url: Option<&CFURL>,
394 ) -> Option<NonNull<CFPlugIn>>;
395 }
396 let ret = unsafe { CFPlugInCreate(allocator, plug_in_url) };
397 ret.map(|ret| unsafe { CFRetained::from_raw(ret) })
398}
399
400#[cfg(feature = "CFBundle")]
401#[deprecated = "renamed to `CFPlugIn::bundle`"]
402#[inline]
403pub extern "C-unwind" fn CFPlugInGetBundle(plug_in: &CFPlugIn) -> Option<CFRetained<CFBundle>> {
404 extern "C-unwind" {
405 fn CFPlugInGetBundle(plug_in: &CFPlugIn) -> Option<NonNull<CFBundle>>;
406 }
407 let ret = unsafe { CFPlugInGetBundle(plug_in) };
408 ret.map(|ret| unsafe { CFRetained::retain(ret) })
409}
410
411#[cfg(feature = "CFBundle")]
412#[deprecated = "renamed to `CFPlugIn::set_load_on_demand`"]
413#[inline]
414pub extern "C-unwind" fn CFPlugInSetLoadOnDemand(plug_in: &CFPlugIn, flag: bool) {
415 extern "C-unwind" {
416 fn CFPlugInSetLoadOnDemand(plug_in: &CFPlugIn, flag: Boolean);
417 }
418 unsafe { CFPlugInSetLoadOnDemand(plug_in, flag as _) }
419}
420
421#[cfg(feature = "CFBundle")]
422#[deprecated = "renamed to `CFPlugIn::is_load_on_demand`"]
423#[inline]
424pub extern "C-unwind" fn CFPlugInIsLoadOnDemand(plug_in: &CFPlugIn) -> bool {
425 extern "C-unwind" {
426 fn CFPlugInIsLoadOnDemand(plug_in: &CFPlugIn) -> Boolean;
427 }
428 let ret = unsafe { CFPlugInIsLoadOnDemand(plug_in) };
429 ret != 0
430}
431
432#[cfg(all(feature = "CFArray", feature = "CFUUID"))]
433#[deprecated = "renamed to `CFPlugIn::find_factories_for_plug_in_type`"]
434#[inline]
435pub extern "C-unwind" fn CFPlugInFindFactoriesForPlugInType(
436 type_uuid: Option<&CFUUID>,
437) -> Option<CFRetained<CFArray>> {
438 extern "C-unwind" {
439 fn CFPlugInFindFactoriesForPlugInType(
440 type_uuid: Option<&CFUUID>,
441 ) -> Option<NonNull<CFArray>>;
442 }
443 let ret = unsafe { CFPlugInFindFactoriesForPlugInType(type_uuid) };
444 ret.map(|ret| unsafe { CFRetained::from_raw(ret) })
445}
446
447#[cfg(all(feature = "CFArray", feature = "CFBundle", feature = "CFUUID"))]
448#[deprecated = "renamed to `CFPlugIn::find_factories_for_plug_in_type_in_plug_in`"]
449#[inline]
450pub extern "C-unwind" fn CFPlugInFindFactoriesForPlugInTypeInPlugIn(
451 type_uuid: Option<&CFUUID>,
452 plug_in: Option<&CFPlugIn>,
453) -> Option<CFRetained<CFArray>> {
454 extern "C-unwind" {
455 fn CFPlugInFindFactoriesForPlugInTypeInPlugIn(
456 type_uuid: Option<&CFUUID>,
457 plug_in: Option<&CFPlugIn>,
458 ) -> Option<NonNull<CFArray>>;
459 }
460 let ret = unsafe { CFPlugInFindFactoriesForPlugInTypeInPlugIn(type_uuid, plug_in) };
461 ret.map(|ret| unsafe { CFRetained::from_raw(ret) })
462}
463
464#[cfg(feature = "CFUUID")]
465#[deprecated = "renamed to `CFPlugInInstance::create`"]
466#[inline]
467pub extern "C-unwind" fn CFPlugInInstanceCreate(
468 allocator: Option<&CFAllocator>,
469 factory_uuid: Option<&CFUUID>,
470 type_uuid: Option<&CFUUID>,
471) -> *mut c_void {
472 extern "C-unwind" {
473 fn CFPlugInInstanceCreate(
474 allocator: Option<&CFAllocator>,
475 factory_uuid: Option<&CFUUID>,
476 type_uuid: Option<&CFUUID>,
477 ) -> *mut c_void;
478 }
479 unsafe { CFPlugInInstanceCreate(allocator, factory_uuid, type_uuid) }
480}
481
482#[cfg(feature = "CFUUID")]
483#[deprecated = "renamed to `CFPlugIn::register_factory_function`"]
484#[inline]
485pub extern "C-unwind" fn CFPlugInRegisterFactoryFunction(
486 factory_uuid: Option<&CFUUID>,
487 func: CFPlugInFactoryFunction,
488) -> bool {
489 extern "C-unwind" {
490 fn CFPlugInRegisterFactoryFunction(
491 factory_uuid: Option<&CFUUID>,
492 func: CFPlugInFactoryFunction,
493 ) -> Boolean;
494 }
495 let ret = unsafe { CFPlugInRegisterFactoryFunction(factory_uuid, func) };
496 ret != 0
497}
498
499#[cfg(all(feature = "CFBundle", feature = "CFUUID"))]
500#[deprecated = "renamed to `CFPlugIn::register_factory_function_by_name`"]
501#[inline]
502pub extern "C-unwind" fn CFPlugInRegisterFactoryFunctionByName(
503 factory_uuid: Option<&CFUUID>,
504 plug_in: Option<&CFPlugIn>,
505 function_name: Option<&CFString>,
506) -> bool {
507 extern "C-unwind" {
508 fn CFPlugInRegisterFactoryFunctionByName(
509 factory_uuid: Option<&CFUUID>,
510 plug_in: Option<&CFPlugIn>,
511 function_name: Option<&CFString>,
512 ) -> Boolean;
513 }
514 let ret =
515 unsafe { CFPlugInRegisterFactoryFunctionByName(factory_uuid, plug_in, function_name) };
516 ret != 0
517}
518
519#[cfg(feature = "CFUUID")]
520#[deprecated = "renamed to `CFPlugIn::unregister_factory`"]
521#[inline]
522pub extern "C-unwind" fn CFPlugInUnregisterFactory(factory_uuid: Option<&CFUUID>) -> bool {
523 extern "C-unwind" {
524 fn CFPlugInUnregisterFactory(factory_uuid: Option<&CFUUID>) -> Boolean;
525 }
526 let ret = unsafe { CFPlugInUnregisterFactory(factory_uuid) };
527 ret != 0
528}
529
530#[cfg(feature = "CFUUID")]
531#[deprecated = "renamed to `CFPlugIn::register_plug_in_type`"]
532#[inline]
533pub extern "C-unwind" fn CFPlugInRegisterPlugInType(
534 factory_uuid: Option<&CFUUID>,
535 type_uuid: Option<&CFUUID>,
536) -> bool {
537 extern "C-unwind" {
538 fn CFPlugInRegisterPlugInType(
539 factory_uuid: Option<&CFUUID>,
540 type_uuid: Option<&CFUUID>,
541 ) -> Boolean;
542 }
543 let ret = unsafe { CFPlugInRegisterPlugInType(factory_uuid, type_uuid) };
544 ret != 0
545}
546
547#[cfg(feature = "CFUUID")]
548#[deprecated = "renamed to `CFPlugIn::unregister_plug_in_type`"]
549#[inline]
550pub extern "C-unwind" fn CFPlugInUnregisterPlugInType(
551 factory_uuid: Option<&CFUUID>,
552 type_uuid: Option<&CFUUID>,
553) -> bool {
554 extern "C-unwind" {
555 fn CFPlugInUnregisterPlugInType(
556 factory_uuid: Option<&CFUUID>,
557 type_uuid: Option<&CFUUID>,
558 ) -> Boolean;
559 }
560 let ret = unsafe { CFPlugInUnregisterPlugInType(factory_uuid, type_uuid) };
561 ret != 0
562}
563
564#[cfg(feature = "CFUUID")]
565#[deprecated = "renamed to `CFPlugIn::add_instance_for_factory`"]
566#[inline]
567pub extern "C-unwind" fn CFPlugInAddInstanceForFactory(factory_id: Option<&CFUUID>) {
568 extern "C-unwind" {
569 fn CFPlugInAddInstanceForFactory(factory_id: Option<&CFUUID>);
570 }
571 unsafe { CFPlugInAddInstanceForFactory(factory_id) }
572}
573
574#[cfg(feature = "CFUUID")]
575#[deprecated = "renamed to `CFPlugIn::remove_instance_for_factory`"]
576#[inline]
577pub extern "C-unwind" fn CFPlugInRemoveInstanceForFactory(factory_id: Option<&CFUUID>) {
578 extern "C-unwind" {
579 fn CFPlugInRemoveInstanceForFactory(factory_id: Option<&CFUUID>);
580 }
581 unsafe { CFPlugInRemoveInstanceForFactory(factory_id) }
582}
583
584#[deprecated = "renamed to `CFPlugInInstance::interface_function_table`"]
585#[inline]
586pub unsafe extern "C-unwind" fn CFPlugInInstanceGetInterfaceFunctionTable(
587 instance: &CFPlugInInstance,
588 interface_name: Option<&CFString>,
589 ftbl: *mut *mut c_void,
590) -> bool {
591 extern "C-unwind" {
592 fn CFPlugInInstanceGetInterfaceFunctionTable(
593 instance: &CFPlugInInstance,
594 interface_name: Option<&CFString>,
595 ftbl: *mut *mut c_void,
596 ) -> Boolean;
597 }
598 let ret = unsafe { CFPlugInInstanceGetInterfaceFunctionTable(instance, interface_name, ftbl) };
599 ret != 0
600}
601
602#[deprecated = "renamed to `CFPlugInInstance::factory_name`"]
603#[inline]
604pub extern "C-unwind" fn CFPlugInInstanceGetFactoryName(
605 instance: &CFPlugInInstance,
606) -> Option<CFRetained<CFString>> {
607 extern "C-unwind" {
608 fn CFPlugInInstanceGetFactoryName(instance: &CFPlugInInstance)
609 -> Option<NonNull<CFString>>;
610 }
611 let ret = unsafe { CFPlugInInstanceGetFactoryName(instance) };
612 ret.map(|ret| unsafe { CFRetained::from_raw(ret) })
613}
614
615#[deprecated = "renamed to `CFPlugInInstance::instance_data`"]
616#[inline]
617pub extern "C-unwind" fn CFPlugInInstanceGetInstanceData(
618 instance: &CFPlugInInstance,
619) -> *mut c_void {
620 extern "C-unwind" {
621 fn CFPlugInInstanceGetInstanceData(instance: &CFPlugInInstance) -> *mut c_void;
622 }
623 unsafe { CFPlugInInstanceGetInstanceData(instance) }
624}
625
626#[deprecated = "renamed to `CFPlugInInstance::with_instance_data_size`"]
627#[inline]
628pub unsafe extern "C-unwind" fn CFPlugInInstanceCreateWithInstanceDataSize(
629 allocator: Option<&CFAllocator>,
630 instance_data_size: CFIndex,
631 deallocate_instance_function: CFPlugInInstanceDeallocateInstanceDataFunction,
632 factory_name: Option<&CFString>,
633 get_interface_function: CFPlugInInstanceGetInterfaceFunction,
634) -> Option<CFRetained<CFPlugInInstance>> {
635 extern "C-unwind" {
636 fn CFPlugInInstanceCreateWithInstanceDataSize(
637 allocator: Option<&CFAllocator>,
638 instance_data_size: CFIndex,
639 deallocate_instance_function: CFPlugInInstanceDeallocateInstanceDataFunction,
640 factory_name: Option<&CFString>,
641 get_interface_function: CFPlugInInstanceGetInterfaceFunction,
642 ) -> Option<NonNull<CFPlugInInstance>>;
643 }
644 let ret = unsafe {
645 CFPlugInInstanceCreateWithInstanceDataSize(
646 allocator,
647 instance_data_size,
648 deallocate_instance_function,
649 factory_name,
650 get_interface_function,
651 )
652 };
653 ret.map(|ret| unsafe { CFRetained::from_raw(ret) })
654}