objc2_core_foundation/generated/
CFPlugIn.rs1use core::cell::UnsafeCell;
4use core::ffi::*;
5use core::marker::{PhantomData, PhantomPinned};
6use core::ptr::NonNull;
7
8use crate::*;
9
10extern "C" {
11 #[cfg(feature = "CFBase")]
13 pub static kCFPlugInDynamicRegistrationKey: Option<&'static CFString>;
14}
15
16extern "C" {
17 #[cfg(feature = "CFBase")]
19 pub static kCFPlugInDynamicRegisterFunctionKey: Option<&'static CFString>;
20}
21
22extern "C" {
23 #[cfg(feature = "CFBase")]
25 pub static kCFPlugInUnloadFunctionKey: Option<&'static CFString>;
26}
27
28extern "C" {
29 #[cfg(feature = "CFBase")]
31 pub static kCFPlugInFactoriesKey: Option<&'static CFString>;
32}
33
34extern "C" {
35 #[cfg(feature = "CFBase")]
37 pub static kCFPlugInTypesKey: Option<&'static CFString>;
38}
39
40#[cfg(feature = "CFBundle")]
42pub type CFPlugInDynamicRegisterFunction = Option<unsafe extern "C-unwind" fn(*mut CFPlugIn)>;
43
44#[cfg(feature = "CFBundle")]
46pub type CFPlugInUnloadFunction = Option<unsafe extern "C-unwind" fn(*mut CFPlugIn)>;
47
48#[cfg(all(feature = "CFBase", feature = "CFUUID"))]
50pub type CFPlugInFactoryFunction =
51 Option<unsafe extern "C-unwind" fn(*const CFAllocator, *const CFUUID) -> *mut c_void>;
52
53#[cfg(all(feature = "CFBase", feature = "CFBundle"))]
54unsafe impl ConcreteType for CFPlugIn {
55 #[doc(alias = "CFPlugInGetTypeID")]
56 #[inline]
57 fn type_id() -> CFTypeID {
58 extern "C-unwind" {
59 fn CFPlugInGetTypeID() -> CFTypeID;
60 }
61 unsafe { CFPlugInGetTypeID() }
62 }
63}
64
65#[cfg(all(feature = "CFBase", feature = "CFBundle", feature = "CFURL"))]
66#[inline]
67pub unsafe extern "C-unwind" fn CFPlugInCreate(
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#[cfg(feature = "CFBundle")]
82#[inline]
83pub unsafe extern "C-unwind" fn CFPlugInGetBundle(
84 plug_in: &CFPlugIn,
85) -> Option<CFRetained<CFBundle>> {
86 extern "C-unwind" {
87 fn CFPlugInGetBundle(plug_in: &CFPlugIn) -> Option<NonNull<CFBundle>>;
88 }
89 let ret = unsafe { CFPlugInGetBundle(plug_in) };
90 ret.map(|ret| unsafe { CFRetained::retain(ret) })
91}
92
93#[cfg(feature = "CFBundle")]
94#[inline]
95pub unsafe extern "C-unwind" fn CFPlugInSetLoadOnDemand(plug_in: &CFPlugIn, flag: bool) {
96 extern "C-unwind" {
97 fn CFPlugInSetLoadOnDemand(plug_in: &CFPlugIn, flag: Boolean);
98 }
99 unsafe { CFPlugInSetLoadOnDemand(plug_in, flag as _) }
100}
101
102#[cfg(feature = "CFBundle")]
103#[inline]
104pub unsafe extern "C-unwind" fn CFPlugInIsLoadOnDemand(plug_in: &CFPlugIn) -> bool {
105 extern "C-unwind" {
106 fn CFPlugInIsLoadOnDemand(plug_in: &CFPlugIn) -> Boolean;
107 }
108 let ret = unsafe { CFPlugInIsLoadOnDemand(plug_in) };
109 ret != 0
110}
111
112#[cfg(all(feature = "CFArray", feature = "CFUUID"))]
113#[inline]
114pub unsafe extern "C-unwind" fn CFPlugInFindFactoriesForPlugInType(
115 type_uuid: Option<&CFUUID>,
116) -> Option<CFRetained<CFArray>> {
117 extern "C-unwind" {
118 fn CFPlugInFindFactoriesForPlugInType(
119 type_uuid: Option<&CFUUID>,
120 ) -> Option<NonNull<CFArray>>;
121 }
122 let ret = unsafe { CFPlugInFindFactoriesForPlugInType(type_uuid) };
123 ret.map(|ret| unsafe { CFRetained::from_raw(ret) })
124}
125
126#[cfg(all(feature = "CFArray", feature = "CFBundle", feature = "CFUUID"))]
127#[inline]
128pub unsafe extern "C-unwind" fn CFPlugInFindFactoriesForPlugInTypeInPlugIn(
129 type_uuid: Option<&CFUUID>,
130 plug_in: Option<&CFPlugIn>,
131) -> Option<CFRetained<CFArray>> {
132 extern "C-unwind" {
133 fn CFPlugInFindFactoriesForPlugInTypeInPlugIn(
134 type_uuid: Option<&CFUUID>,
135 plug_in: Option<&CFPlugIn>,
136 ) -> Option<NonNull<CFArray>>;
137 }
138 let ret = unsafe { CFPlugInFindFactoriesForPlugInTypeInPlugIn(type_uuid, plug_in) };
139 ret.map(|ret| unsafe { CFRetained::from_raw(ret) })
140}
141
142extern "C-unwind" {
143 #[cfg(all(feature = "CFBase", feature = "CFUUID"))]
144 pub fn CFPlugInInstanceCreate(
145 allocator: Option<&CFAllocator>,
146 factory_uuid: Option<&CFUUID>,
147 type_uuid: Option<&CFUUID>,
148 ) -> *mut c_void;
149}
150
151#[cfg(all(feature = "CFBase", feature = "CFUUID"))]
152#[inline]
153pub unsafe extern "C-unwind" fn CFPlugInRegisterFactoryFunction(
154 factory_uuid: Option<&CFUUID>,
155 func: CFPlugInFactoryFunction,
156) -> bool {
157 extern "C-unwind" {
158 fn CFPlugInRegisterFactoryFunction(
159 factory_uuid: Option<&CFUUID>,
160 func: CFPlugInFactoryFunction,
161 ) -> Boolean;
162 }
163 let ret = unsafe { CFPlugInRegisterFactoryFunction(factory_uuid, func) };
164 ret != 0
165}
166
167#[cfg(all(feature = "CFBase", feature = "CFBundle", feature = "CFUUID"))]
168#[inline]
169pub unsafe extern "C-unwind" fn CFPlugInRegisterFactoryFunctionByName(
170 factory_uuid: Option<&CFUUID>,
171 plug_in: Option<&CFPlugIn>,
172 function_name: Option<&CFString>,
173) -> bool {
174 extern "C-unwind" {
175 fn CFPlugInRegisterFactoryFunctionByName(
176 factory_uuid: Option<&CFUUID>,
177 plug_in: Option<&CFPlugIn>,
178 function_name: Option<&CFString>,
179 ) -> Boolean;
180 }
181 let ret =
182 unsafe { CFPlugInRegisterFactoryFunctionByName(factory_uuid, plug_in, function_name) };
183 ret != 0
184}
185
186#[cfg(feature = "CFUUID")]
187#[inline]
188pub unsafe extern "C-unwind" fn CFPlugInUnregisterFactory(factory_uuid: Option<&CFUUID>) -> bool {
189 extern "C-unwind" {
190 fn CFPlugInUnregisterFactory(factory_uuid: Option<&CFUUID>) -> Boolean;
191 }
192 let ret = unsafe { CFPlugInUnregisterFactory(factory_uuid) };
193 ret != 0
194}
195
196#[cfg(feature = "CFUUID")]
197#[inline]
198pub unsafe extern "C-unwind" fn CFPlugInRegisterPlugInType(
199 factory_uuid: Option<&CFUUID>,
200 type_uuid: Option<&CFUUID>,
201) -> bool {
202 extern "C-unwind" {
203 fn CFPlugInRegisterPlugInType(
204 factory_uuid: Option<&CFUUID>,
205 type_uuid: Option<&CFUUID>,
206 ) -> Boolean;
207 }
208 let ret = unsafe { CFPlugInRegisterPlugInType(factory_uuid, type_uuid) };
209 ret != 0
210}
211
212#[cfg(feature = "CFUUID")]
213#[inline]
214pub unsafe extern "C-unwind" fn CFPlugInUnregisterPlugInType(
215 factory_uuid: Option<&CFUUID>,
216 type_uuid: Option<&CFUUID>,
217) -> bool {
218 extern "C-unwind" {
219 fn CFPlugInUnregisterPlugInType(
220 factory_uuid: Option<&CFUUID>,
221 type_uuid: Option<&CFUUID>,
222 ) -> Boolean;
223 }
224 let ret = unsafe { CFPlugInUnregisterPlugInType(factory_uuid, type_uuid) };
225 ret != 0
226}
227
228extern "C-unwind" {
229 #[cfg(feature = "CFUUID")]
230 pub fn CFPlugInAddInstanceForFactory(factory_id: Option<&CFUUID>);
231}
232
233extern "C-unwind" {
234 #[cfg(feature = "CFUUID")]
235 pub fn CFPlugInRemoveInstanceForFactory(factory_id: Option<&CFUUID>);
236}
237
238#[repr(C)]
240pub struct CFPlugInInstance {
241 inner: [u8; 0],
242 _p: UnsafeCell<PhantomData<(*const UnsafeCell<()>, PhantomPinned)>>,
243}
244
245cf_type!(
246 #[encoding_name = "__CFPlugInInstance"]
247 unsafe impl CFPlugInInstance {}
248);
249
250#[cfg(feature = "CFBase")]
252pub type CFPlugInInstanceGetInterfaceFunction = Option<
253 unsafe extern "C-unwind" fn(
254 *mut CFPlugInInstance,
255 *const CFString,
256 *mut *mut c_void,
257 ) -> Boolean,
258>;
259
260pub type CFPlugInInstanceDeallocateInstanceDataFunction =
262 Option<unsafe extern "C-unwind" fn(*mut c_void)>;
263
264#[cfg(feature = "CFBase")]
265#[inline]
266pub unsafe extern "C-unwind" fn CFPlugInInstanceGetInterfaceFunctionTable(
267 instance: &CFPlugInInstance,
268 interface_name: Option<&CFString>,
269 ftbl: *mut *mut c_void,
270) -> bool {
271 extern "C-unwind" {
272 fn CFPlugInInstanceGetInterfaceFunctionTable(
273 instance: &CFPlugInInstance,
274 interface_name: Option<&CFString>,
275 ftbl: *mut *mut c_void,
276 ) -> Boolean;
277 }
278 let ret = unsafe { CFPlugInInstanceGetInterfaceFunctionTable(instance, interface_name, ftbl) };
279 ret != 0
280}
281
282#[cfg(feature = "CFBase")]
283#[inline]
284pub unsafe extern "C-unwind" fn CFPlugInInstanceGetFactoryName(
285 instance: &CFPlugInInstance,
286) -> Option<CFRetained<CFString>> {
287 extern "C-unwind" {
288 fn CFPlugInInstanceGetFactoryName(instance: &CFPlugInInstance)
289 -> Option<NonNull<CFString>>;
290 }
291 let ret = unsafe { CFPlugInInstanceGetFactoryName(instance) };
292 ret.map(|ret| unsafe { CFRetained::from_raw(ret) })
293}
294
295extern "C-unwind" {
296 pub fn CFPlugInInstanceGetInstanceData(instance: &CFPlugInInstance) -> *mut c_void;
297}
298
299#[cfg(feature = "CFBase")]
300unsafe impl ConcreteType for CFPlugInInstance {
301 #[doc(alias = "CFPlugInInstanceGetTypeID")]
302 #[inline]
303 fn type_id() -> CFTypeID {
304 extern "C-unwind" {
305 fn CFPlugInInstanceGetTypeID() -> CFTypeID;
306 }
307 unsafe { CFPlugInInstanceGetTypeID() }
308 }
309}
310
311#[cfg(feature = "CFBase")]
312#[inline]
313pub unsafe extern "C-unwind" fn CFPlugInInstanceCreateWithInstanceDataSize(
314 allocator: Option<&CFAllocator>,
315 instance_data_size: CFIndex,
316 deallocate_instance_function: CFPlugInInstanceDeallocateInstanceDataFunction,
317 factory_name: Option<&CFString>,
318 get_interface_function: CFPlugInInstanceGetInterfaceFunction,
319) -> Option<CFRetained<CFPlugInInstance>> {
320 extern "C-unwind" {
321 fn CFPlugInInstanceCreateWithInstanceDataSize(
322 allocator: Option<&CFAllocator>,
323 instance_data_size: CFIndex,
324 deallocate_instance_function: CFPlugInInstanceDeallocateInstanceDataFunction,
325 factory_name: Option<&CFString>,
326 get_interface_function: CFPlugInInstanceGetInterfaceFunction,
327 ) -> Option<NonNull<CFPlugInInstance>>;
328 }
329 let ret = unsafe {
330 CFPlugInInstanceCreateWithInstanceDataSize(
331 allocator,
332 instance_data_size,
333 deallocate_instance_function,
334 factory_name,
335 get_interface_function,
336 )
337 };
338 ret.map(|ret| unsafe { CFRetained::from_raw(ret) })
339}