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) -> 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, 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) -> 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#[doc(alias = "CFPlugInInstanceRef")]
273#[repr(C)]
274pub struct CFPlugInInstance {
275 inner: [u8; 0],
276 _p: UnsafeCell<PhantomData<(*const UnsafeCell<()>, PhantomPinned)>>,
277}
278
279cf_type!(
280 unsafe impl CFPlugInInstance {}
281);
282#[cfg(feature = "objc2")]
283cf_objc2_type!(
284 unsafe impl RefEncode<"__CFPlugInInstance"> for CFPlugInInstance {}
285);
286
287pub type CFPlugInInstanceGetInterfaceFunction = Option<
289 unsafe extern "C-unwind" fn(
290 *mut CFPlugInInstance,
291 *const CFString,
292 *mut *mut c_void,
293 ) -> Boolean,
294>;
295
296pub type CFPlugInInstanceDeallocateInstanceDataFunction =
298 Option<unsafe extern "C-unwind" fn(*mut c_void)>;
299
300impl CFPlugInInstance {
301 #[doc(alias = "CFPlugInInstanceGetInterfaceFunctionTable")]
306 #[inline]
307 pub unsafe fn interface_function_table(
308 &self,
309 interface_name: Option<&CFString>,
310 ftbl: *mut *mut c_void,
311 ) -> bool {
312 extern "C-unwind" {
313 fn CFPlugInInstanceGetInterfaceFunctionTable(
314 instance: &CFPlugInInstance,
315 interface_name: Option<&CFString>,
316 ftbl: *mut *mut c_void,
317 ) -> Boolean;
318 }
319 let ret = unsafe { CFPlugInInstanceGetInterfaceFunctionTable(self, interface_name, ftbl) };
320 ret != 0
321 }
322
323 #[doc(alias = "CFPlugInInstanceGetFactoryName")]
324 #[inline]
325 pub fn factory_name(&self) -> Option<CFRetained<CFString>> {
326 extern "C-unwind" {
327 fn CFPlugInInstanceGetFactoryName(
328 instance: &CFPlugInInstance,
329 ) -> Option<NonNull<CFString>>;
330 }
331 let ret = unsafe { CFPlugInInstanceGetFactoryName(self) };
332 ret.map(|ret| unsafe { CFRetained::from_raw(ret) })
333 }
334
335 #[doc(alias = "CFPlugInInstanceGetInstanceData")]
336 #[inline]
337 pub fn instance_data(&self) -> *mut c_void {
338 extern "C-unwind" {
339 fn CFPlugInInstanceGetInstanceData(instance: &CFPlugInInstance) -> *mut c_void;
340 }
341 unsafe { CFPlugInInstanceGetInstanceData(self) }
342 }
343}
344
345unsafe impl ConcreteType for CFPlugInInstance {
346 #[doc(alias = "CFPlugInInstanceGetTypeID")]
347 #[inline]
348 fn type_id() -> CFTypeID {
349 extern "C-unwind" {
350 fn CFPlugInInstanceGetTypeID() -> CFTypeID;
351 }
352 unsafe { CFPlugInInstanceGetTypeID() }
353 }
354}
355
356impl CFPlugInInstance {
357 #[doc(alias = "CFPlugInInstanceCreateWithInstanceDataSize")]
364 #[inline]
365 pub unsafe fn with_instance_data_size(
366 allocator: Option<&CFAllocator>,
367 instance_data_size: CFIndex,
368 deallocate_instance_function: CFPlugInInstanceDeallocateInstanceDataFunction,
369 factory_name: Option<&CFString>,
370 get_interface_function: CFPlugInInstanceGetInterfaceFunction,
371 ) -> Option<CFRetained<CFPlugInInstance>> {
372 extern "C-unwind" {
373 fn CFPlugInInstanceCreateWithInstanceDataSize(
374 allocator: Option<&CFAllocator>,
375 instance_data_size: CFIndex,
376 deallocate_instance_function: CFPlugInInstanceDeallocateInstanceDataFunction,
377 factory_name: Option<&CFString>,
378 get_interface_function: CFPlugInInstanceGetInterfaceFunction,
379 ) -> Option<NonNull<CFPlugInInstance>>;
380 }
381 let ret = unsafe {
382 CFPlugInInstanceCreateWithInstanceDataSize(
383 allocator,
384 instance_data_size,
385 deallocate_instance_function,
386 factory_name,
387 get_interface_function,
388 )
389 };
390 ret.map(|ret| unsafe { CFRetained::from_raw(ret) })
391 }
392}
393
394#[cfg(all(feature = "CFBundle", feature = "CFURL"))]
395#[deprecated = "renamed to `CFPlugIn::new`"]
396#[inline]
397pub extern "C-unwind" fn CFPlugInCreate(
398 allocator: Option<&CFAllocator>,
399 plug_in_url: Option<&CFURL>,
400) -> Option<CFRetained<CFPlugIn>> {
401 extern "C-unwind" {
402 fn CFPlugInCreate(
403 allocator: Option<&CFAllocator>,
404 plug_in_url: Option<&CFURL>,
405 ) -> Option<NonNull<CFPlugIn>>;
406 }
407 let ret = unsafe { CFPlugInCreate(allocator, plug_in_url) };
408 ret.map(|ret| unsafe { CFRetained::from_raw(ret) })
409}
410
411#[cfg(feature = "CFBundle")]
412#[deprecated = "renamed to `CFPlugIn::bundle`"]
413#[inline]
414pub extern "C-unwind" fn CFPlugInGetBundle(plug_in: &CFPlugIn) -> Option<CFRetained<CFBundle>> {
415 extern "C-unwind" {
416 fn CFPlugInGetBundle(plug_in: &CFPlugIn) -> Option<NonNull<CFBundle>>;
417 }
418 let ret = unsafe { CFPlugInGetBundle(plug_in) };
419 ret.map(|ret| unsafe { CFRetained::retain(ret) })
420}
421
422#[cfg(feature = "CFBundle")]
423#[deprecated = "renamed to `CFPlugIn::set_load_on_demand`"]
424#[inline]
425pub extern "C-unwind" fn CFPlugInSetLoadOnDemand(plug_in: &CFPlugIn, flag: bool) {
426 extern "C-unwind" {
427 fn CFPlugInSetLoadOnDemand(plug_in: &CFPlugIn, flag: Boolean);
428 }
429 unsafe { CFPlugInSetLoadOnDemand(plug_in, flag as _) }
430}
431
432#[cfg(feature = "CFBundle")]
433#[deprecated = "renamed to `CFPlugIn::is_load_on_demand`"]
434#[inline]
435pub extern "C-unwind" fn CFPlugInIsLoadOnDemand(plug_in: &CFPlugIn) -> bool {
436 extern "C-unwind" {
437 fn CFPlugInIsLoadOnDemand(plug_in: &CFPlugIn) -> Boolean;
438 }
439 let ret = unsafe { CFPlugInIsLoadOnDemand(plug_in) };
440 ret != 0
441}
442
443#[cfg(all(feature = "CFArray", feature = "CFUUID"))]
444#[deprecated = "renamed to `CFPlugIn::find_factories_for_plug_in_type`"]
445#[inline]
446pub extern "C-unwind" fn CFPlugInFindFactoriesForPlugInType(
447 type_uuid: Option<&CFUUID>,
448) -> Option<CFRetained<CFArray>> {
449 extern "C-unwind" {
450 fn CFPlugInFindFactoriesForPlugInType(
451 type_uuid: Option<&CFUUID>,
452 ) -> Option<NonNull<CFArray>>;
453 }
454 let ret = unsafe { CFPlugInFindFactoriesForPlugInType(type_uuid) };
455 ret.map(|ret| unsafe { CFRetained::from_raw(ret) })
456}
457
458#[cfg(all(feature = "CFArray", feature = "CFBundle", feature = "CFUUID"))]
459#[deprecated = "renamed to `CFPlugIn::find_factories_for_plug_in_type_in_plug_in`"]
460#[inline]
461pub extern "C-unwind" fn CFPlugInFindFactoriesForPlugInTypeInPlugIn(
462 type_uuid: Option<&CFUUID>,
463 plug_in: Option<&CFPlugIn>,
464) -> Option<CFRetained<CFArray>> {
465 extern "C-unwind" {
466 fn CFPlugInFindFactoriesForPlugInTypeInPlugIn(
467 type_uuid: Option<&CFUUID>,
468 plug_in: Option<&CFPlugIn>,
469 ) -> Option<NonNull<CFArray>>;
470 }
471 let ret = unsafe { CFPlugInFindFactoriesForPlugInTypeInPlugIn(type_uuid, plug_in) };
472 ret.map(|ret| unsafe { CFRetained::from_raw(ret) })
473}
474
475#[cfg(feature = "CFUUID")]
476#[deprecated = "renamed to `CFPlugInInstance::create`"]
477#[inline]
478pub extern "C-unwind" fn CFPlugInInstanceCreate(
479 allocator: Option<&CFAllocator>,
480 factory_uuid: Option<&CFUUID>,
481 type_uuid: Option<&CFUUID>,
482) -> *mut c_void {
483 extern "C-unwind" {
484 fn CFPlugInInstanceCreate(
485 allocator: Option<&CFAllocator>,
486 factory_uuid: Option<&CFUUID>,
487 type_uuid: Option<&CFUUID>,
488 ) -> *mut c_void;
489 }
490 unsafe { CFPlugInInstanceCreate(allocator, factory_uuid, type_uuid) }
491}
492
493#[cfg(feature = "CFUUID")]
494#[deprecated = "renamed to `CFPlugIn::register_factory_function`"]
495#[inline]
496pub extern "C-unwind" fn CFPlugInRegisterFactoryFunction(
497 factory_uuid: Option<&CFUUID>,
498 func: CFPlugInFactoryFunction,
499) -> bool {
500 extern "C-unwind" {
501 fn CFPlugInRegisterFactoryFunction(
502 factory_uuid: Option<&CFUUID>,
503 func: CFPlugInFactoryFunction,
504 ) -> Boolean;
505 }
506 let ret = unsafe { CFPlugInRegisterFactoryFunction(factory_uuid, func) };
507 ret != 0
508}
509
510#[cfg(all(feature = "CFBundle", feature = "CFUUID"))]
511#[deprecated = "renamed to `CFPlugIn::register_factory_function_by_name`"]
512#[inline]
513pub extern "C-unwind" fn CFPlugInRegisterFactoryFunctionByName(
514 factory_uuid: Option<&CFUUID>,
515 plug_in: Option<&CFPlugIn>,
516 function_name: Option<&CFString>,
517) -> bool {
518 extern "C-unwind" {
519 fn CFPlugInRegisterFactoryFunctionByName(
520 factory_uuid: Option<&CFUUID>,
521 plug_in: Option<&CFPlugIn>,
522 function_name: Option<&CFString>,
523 ) -> Boolean;
524 }
525 let ret =
526 unsafe { CFPlugInRegisterFactoryFunctionByName(factory_uuid, plug_in, function_name) };
527 ret != 0
528}
529
530#[cfg(feature = "CFUUID")]
531#[deprecated = "renamed to `CFPlugIn::unregister_factory`"]
532#[inline]
533pub extern "C-unwind" fn CFPlugInUnregisterFactory(factory_uuid: Option<&CFUUID>) -> bool {
534 extern "C-unwind" {
535 fn CFPlugInUnregisterFactory(factory_uuid: Option<&CFUUID>) -> Boolean;
536 }
537 let ret = unsafe { CFPlugInUnregisterFactory(factory_uuid) };
538 ret != 0
539}
540
541#[cfg(feature = "CFUUID")]
542#[deprecated = "renamed to `CFPlugIn::register_plug_in_type`"]
543#[inline]
544pub extern "C-unwind" fn CFPlugInRegisterPlugInType(
545 factory_uuid: Option<&CFUUID>,
546 type_uuid: Option<&CFUUID>,
547) -> bool {
548 extern "C-unwind" {
549 fn CFPlugInRegisterPlugInType(
550 factory_uuid: Option<&CFUUID>,
551 type_uuid: Option<&CFUUID>,
552 ) -> Boolean;
553 }
554 let ret = unsafe { CFPlugInRegisterPlugInType(factory_uuid, type_uuid) };
555 ret != 0
556}
557
558#[cfg(feature = "CFUUID")]
559#[deprecated = "renamed to `CFPlugIn::unregister_plug_in_type`"]
560#[inline]
561pub extern "C-unwind" fn CFPlugInUnregisterPlugInType(
562 factory_uuid: Option<&CFUUID>,
563 type_uuid: Option<&CFUUID>,
564) -> bool {
565 extern "C-unwind" {
566 fn CFPlugInUnregisterPlugInType(
567 factory_uuid: Option<&CFUUID>,
568 type_uuid: Option<&CFUUID>,
569 ) -> Boolean;
570 }
571 let ret = unsafe { CFPlugInUnregisterPlugInType(factory_uuid, type_uuid) };
572 ret != 0
573}
574
575#[cfg(feature = "CFUUID")]
576#[deprecated = "renamed to `CFPlugIn::add_instance_for_factory`"]
577#[inline]
578pub extern "C-unwind" fn CFPlugInAddInstanceForFactory(factory_id: Option<&CFUUID>) {
579 extern "C-unwind" {
580 fn CFPlugInAddInstanceForFactory(factory_id: Option<&CFUUID>);
581 }
582 unsafe { CFPlugInAddInstanceForFactory(factory_id) }
583}
584
585#[cfg(feature = "CFUUID")]
586#[deprecated = "renamed to `CFPlugIn::remove_instance_for_factory`"]
587#[inline]
588pub extern "C-unwind" fn CFPlugInRemoveInstanceForFactory(factory_id: Option<&CFUUID>) {
589 extern "C-unwind" {
590 fn CFPlugInRemoveInstanceForFactory(factory_id: Option<&CFUUID>);
591 }
592 unsafe { CFPlugInRemoveInstanceForFactory(factory_id) }
593}
594
595#[deprecated = "renamed to `CFPlugInInstance::interface_function_table`"]
596#[inline]
597pub unsafe extern "C-unwind" fn CFPlugInInstanceGetInterfaceFunctionTable(
598 instance: &CFPlugInInstance,
599 interface_name: Option<&CFString>,
600 ftbl: *mut *mut c_void,
601) -> bool {
602 extern "C-unwind" {
603 fn CFPlugInInstanceGetInterfaceFunctionTable(
604 instance: &CFPlugInInstance,
605 interface_name: Option<&CFString>,
606 ftbl: *mut *mut c_void,
607 ) -> Boolean;
608 }
609 let ret = unsafe { CFPlugInInstanceGetInterfaceFunctionTable(instance, interface_name, ftbl) };
610 ret != 0
611}
612
613#[deprecated = "renamed to `CFPlugInInstance::factory_name`"]
614#[inline]
615pub extern "C-unwind" fn CFPlugInInstanceGetFactoryName(
616 instance: &CFPlugInInstance,
617) -> Option<CFRetained<CFString>> {
618 extern "C-unwind" {
619 fn CFPlugInInstanceGetFactoryName(instance: &CFPlugInInstance)
620 -> Option<NonNull<CFString>>;
621 }
622 let ret = unsafe { CFPlugInInstanceGetFactoryName(instance) };
623 ret.map(|ret| unsafe { CFRetained::from_raw(ret) })
624}
625
626#[deprecated = "renamed to `CFPlugInInstance::instance_data`"]
627#[inline]
628pub extern "C-unwind" fn CFPlugInInstanceGetInstanceData(
629 instance: &CFPlugInInstance,
630) -> *mut c_void {
631 extern "C-unwind" {
632 fn CFPlugInInstanceGetInstanceData(instance: &CFPlugInInstance) -> *mut c_void;
633 }
634 unsafe { CFPlugInInstanceGetInstanceData(instance) }
635}
636
637#[deprecated = "renamed to `CFPlugInInstance::with_instance_data_size`"]
638#[inline]
639pub unsafe extern "C-unwind" fn CFPlugInInstanceCreateWithInstanceDataSize(
640 allocator: Option<&CFAllocator>,
641 instance_data_size: CFIndex,
642 deallocate_instance_function: CFPlugInInstanceDeallocateInstanceDataFunction,
643 factory_name: Option<&CFString>,
644 get_interface_function: CFPlugInInstanceGetInterfaceFunction,
645) -> Option<CFRetained<CFPlugInInstance>> {
646 extern "C-unwind" {
647 fn CFPlugInInstanceCreateWithInstanceDataSize(
648 allocator: Option<&CFAllocator>,
649 instance_data_size: CFIndex,
650 deallocate_instance_function: CFPlugInInstanceDeallocateInstanceDataFunction,
651 factory_name: Option<&CFString>,
652 get_interface_function: CFPlugInInstanceGetInterfaceFunction,
653 ) -> Option<NonNull<CFPlugInInstance>>;
654 }
655 let ret = unsafe {
656 CFPlugInInstanceCreateWithInstanceDataSize(
657 allocator,
658 instance_data_size,
659 deallocate_instance_function,
660 factory_name,
661 get_interface_function,
662 )
663 };
664 ret.map(|ret| unsafe { CFRetained::from_raw(ret) })
665}