objc2_core_services/generated/OSServices/
WSMethodInvocation.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
13extern "C" {
14 pub static kWSMethodInvocationResult: Option<&'static CFString>;
16}
17
18extern "C" {
19 pub static kWSFaultString: Option<&'static CFString>;
21}
22
23extern "C" {
24 pub static kWSFaultCode: Option<&'static CFString>;
26}
27
28extern "C" {
29 pub static kWSFaultExtra: Option<&'static CFString>;
31}
32
33extern "C" {
34 pub static kWSNetworkStreamFaultString: Option<&'static CFString>;
36}
37
38extern "C" {
39 pub static kWSStreamErrorMessage: Option<&'static CFString>;
41}
42
43extern "C" {
44 pub static kWSStreamErrorDomain: Option<&'static CFString>;
46}
47
48extern "C" {
49 pub static kWSStreamErrorError: Option<&'static CFString>;
51}
52
53extern "C" {
54 pub static kWSHTTPMessage: Option<&'static CFString>;
56}
57
58extern "C" {
59 pub static kWSHTTPResponseMessage: Option<&'static CFString>;
61}
62
63extern "C" {
64 pub static kWSHTTPExtraHeaders: Option<&'static CFString>;
66}
67
68extern "C" {
69 pub static kWSHTTPVersion: Option<&'static CFString>;
71}
72
73extern "C" {
74 pub static kWSHTTPProxy: Option<&'static CFString>;
76}
77
78extern "C" {
79 pub static kWSHTTPFollowsRedirects: Option<&'static CFString>;
81}
82
83extern "C" {
84 pub static kWSDebugOutgoingHeaders: Option<&'static CFString>;
86}
87
88extern "C" {
89 pub static kWSDebugOutgoingBody: Option<&'static CFString>;
91}
92
93extern "C" {
94 pub static kWSDebugIncomingHeaders: Option<&'static CFString>;
96}
97
98extern "C" {
99 pub static kWSDebugIncomingBody: Option<&'static CFString>;
101}
102
103extern "C" {
104 pub static kWSSOAPBodyEncodingStyle: Option<&'static CFString>;
106}
107
108extern "C" {
109 pub static kWSSOAPMethodNamespaceURI: Option<&'static CFString>;
111}
112
113extern "C" {
114 pub static kWSSOAPStyleDoc: Option<&'static CFString>;
116}
117
118extern "C" {
119 pub static kWSSOAPStyleRPC: Option<&'static CFString>;
121}
122
123extern "C" {
124 pub static kWSSOAPMessageHeaders: Option<&'static CFString>;
126}
127
128extern "C" {
129 pub static kWSRecordParameterOrder: Option<&'static CFString>;
131}
132
133extern "C" {
134 pub static kWSRecordNamespaceURI: Option<&'static CFString>;
136}
137
138extern "C" {
139 pub static kWSRecordType: Option<&'static CFString>;
141}
142
143extern "C" {
144 pub static kWSMethodInvocationResultParameterName: Option<&'static CFString>;
146}
147
148extern "C" {
149 pub static kWSMethodInvocationTimeoutValue: Option<&'static CFString>;
151}
152
153#[repr(C)]
155pub struct WSMethodInvocation {
156 inner: [u8; 0],
157 _p: UnsafeCell<PhantomData<(*const UnsafeCell<()>, PhantomPinned)>>,
158}
159
160cf_type!(
161 unsafe impl WSMethodInvocation {}
162);
163#[cfg(feature = "objc2")]
164cf_objc2_type!(
165 unsafe impl RefEncode<"OpaqueWSMethodInvocationRef"> for WSMethodInvocation {}
166);
167
168unsafe impl ConcreteType for WSMethodInvocation {
169 #[doc(alias = "WSMethodInvocationGetTypeID")]
170 #[inline]
171 fn type_id() -> CFTypeID {
172 extern "C-unwind" {
173 fn WSMethodInvocationGetTypeID() -> CFTypeID;
174 }
175 unsafe { WSMethodInvocationGetTypeID() }
176 }
177}
178
179impl WSMethodInvocation {
180 #[doc(alias = "WSMethodInvocationCreate")]
181 #[deprecated = "No longer supported"]
182 #[inline]
183 pub unsafe fn new(
184 url: Option<&CFURL>,
185 method_name: Option<&CFString>,
186 protocol: Option<&CFString>,
187 ) -> Option<CFRetained<WSMethodInvocation>> {
188 extern "C-unwind" {
189 fn WSMethodInvocationCreate(
190 url: Option<&CFURL>,
191 method_name: Option<&CFString>,
192 protocol: Option<&CFString>,
193 ) -> Option<NonNull<WSMethodInvocation>>;
194 }
195 let ret = unsafe { WSMethodInvocationCreate(url, method_name, protocol) };
196 ret.map(|ret| unsafe { CFRetained::from_raw(ret) })
197 }
198
199 #[doc(alias = "WSMethodInvocationCreateFromSerialization")]
200 #[deprecated = "No longer supported"]
201 #[inline]
202 pub unsafe fn from_serialization(
203 contract: Option<&CFData>,
204 ) -> Option<CFRetained<WSMethodInvocation>> {
205 extern "C-unwind" {
206 fn WSMethodInvocationCreateFromSerialization(
207 contract: Option<&CFData>,
208 ) -> Option<NonNull<WSMethodInvocation>>;
209 }
210 let ret = unsafe { WSMethodInvocationCreateFromSerialization(contract) };
211 ret.map(|ret| unsafe { CFRetained::from_raw(ret) })
212 }
213
214 #[doc(alias = "WSMethodInvocationCopySerialization")]
215 #[deprecated = "No longer supported"]
216 #[inline]
217 pub unsafe fn serialization(self: &WSMethodInvocation) -> Option<CFRetained<CFData>> {
218 extern "C-unwind" {
219 fn WSMethodInvocationCopySerialization(
220 invocation: &WSMethodInvocation,
221 ) -> Option<NonNull<CFData>>;
222 }
223 let ret = unsafe { WSMethodInvocationCopySerialization(self) };
224 ret.map(|ret| unsafe { CFRetained::from_raw(ret) })
225 }
226
227 #[doc(alias = "WSMethodInvocationSetParameters")]
228 #[deprecated = "No longer supported"]
229 #[inline]
230 pub unsafe fn set_parameters(
231 self: &WSMethodInvocation,
232 parameters: Option<&CFDictionary>,
233 parameter_order: Option<&CFArray>,
234 ) {
235 extern "C-unwind" {
236 fn WSMethodInvocationSetParameters(
237 invocation: &WSMethodInvocation,
238 parameters: Option<&CFDictionary>,
239 parameter_order: Option<&CFArray>,
240 );
241 }
242 unsafe { WSMethodInvocationSetParameters(self, parameters, parameter_order) }
243 }
244
245 #[doc(alias = "WSMethodInvocationCopyParameters")]
246 #[deprecated = "No longer supported"]
247 #[inline]
248 pub unsafe fn parameters(
249 self: &WSMethodInvocation,
250 parameter_order: *mut *const CFArray,
251 ) -> Option<CFRetained<CFDictionary>> {
252 extern "C-unwind" {
253 fn WSMethodInvocationCopyParameters(
254 invocation: &WSMethodInvocation,
255 parameter_order: *mut *const CFArray,
256 ) -> Option<NonNull<CFDictionary>>;
257 }
258 let ret = unsafe { WSMethodInvocationCopyParameters(self, parameter_order) };
259 ret.map(|ret| unsafe { CFRetained::from_raw(ret) })
260 }
261
262 #[doc(alias = "WSMethodInvocationSetProperty")]
263 #[deprecated = "No longer supported"]
264 #[inline]
265 pub unsafe fn set_property(
266 self: &WSMethodInvocation,
267 property_name: Option<&CFString>,
268 property_value: Option<&CFType>,
269 ) {
270 extern "C-unwind" {
271 fn WSMethodInvocationSetProperty(
272 invocation: &WSMethodInvocation,
273 property_name: Option<&CFString>,
274 property_value: Option<&CFType>,
275 );
276 }
277 unsafe { WSMethodInvocationSetProperty(self, property_name, property_value) }
278 }
279
280 #[doc(alias = "WSMethodInvocationCopyProperty")]
281 #[deprecated = "No longer supported"]
282 #[inline]
283 pub unsafe fn property(
284 self: &WSMethodInvocation,
285 property_name: Option<&CFString>,
286 ) -> Option<CFRetained<CFType>> {
287 extern "C-unwind" {
288 fn WSMethodInvocationCopyProperty(
289 invocation: &WSMethodInvocation,
290 property_name: Option<&CFString>,
291 ) -> Option<NonNull<CFType>>;
292 }
293 let ret = unsafe { WSMethodInvocationCopyProperty(self, property_name) };
294 ret.map(|ret| unsafe { CFRetained::from_raw(ret) })
295 }
296
297 #[doc(alias = "WSMethodInvocationInvoke")]
298 #[deprecated = "No longer supported"]
299 #[inline]
300 pub unsafe fn invoke(self: &WSMethodInvocation) -> Option<CFRetained<CFDictionary>> {
301 extern "C-unwind" {
302 fn WSMethodInvocationInvoke(
303 invocation: &WSMethodInvocation,
304 ) -> Option<NonNull<CFDictionary>>;
305 }
306 let ret = unsafe { WSMethodInvocationInvoke(self) };
307 ret.map(|ret| unsafe { CFRetained::from_raw(ret) })
308 }
309}
310
311pub type WSMethodInvocationCallBackProcPtr =
313 Option<unsafe extern "C-unwind" fn(*mut WSMethodInvocation, *mut c_void, *const CFDictionary)>;
314
315impl WSMethodInvocation {
316 #[doc(alias = "WSMethodInvocationSetCallBack")]
317 #[cfg(feature = "WSTypes")]
318 #[deprecated = "No longer supported"]
319 #[inline]
320 pub unsafe fn set_call_back(
321 self: &WSMethodInvocation,
322 client_cb: WSMethodInvocationCallBackProcPtr,
323 context: *mut WSClientContext,
324 ) {
325 extern "C-unwind" {
326 fn WSMethodInvocationSetCallBack(
327 invocation: &WSMethodInvocation,
328 client_cb: WSMethodInvocationCallBackProcPtr,
329 context: *mut WSClientContext,
330 );
331 }
332 unsafe { WSMethodInvocationSetCallBack(self, client_cb, context) }
333 }
334
335 #[doc(alias = "WSMethodInvocationScheduleWithRunLoop")]
336 #[deprecated = "No longer supported"]
337 #[inline]
338 pub unsafe fn schedule_with_run_loop(
339 self: &WSMethodInvocation,
340 run_loop: Option<&CFRunLoop>,
341 run_loop_mode: Option<&CFString>,
342 ) {
343 extern "C-unwind" {
344 fn WSMethodInvocationScheduleWithRunLoop(
345 invocation: &WSMethodInvocation,
346 run_loop: Option<&CFRunLoop>,
347 run_loop_mode: Option<&CFString>,
348 );
349 }
350 unsafe { WSMethodInvocationScheduleWithRunLoop(self, run_loop, run_loop_mode) }
351 }
352
353 #[doc(alias = "WSMethodInvocationUnscheduleFromRunLoop")]
354 #[deprecated = "No longer supported"]
355 #[inline]
356 pub unsafe fn unschedule_from_run_loop(
357 self: &WSMethodInvocation,
358 run_loop: Option<&CFRunLoop>,
359 run_loop_mode: Option<&CFString>,
360 ) {
361 extern "C-unwind" {
362 fn WSMethodInvocationUnscheduleFromRunLoop(
363 invocation: &WSMethodInvocation,
364 run_loop: Option<&CFRunLoop>,
365 run_loop_mode: Option<&CFString>,
366 );
367 }
368 unsafe { WSMethodInvocationUnscheduleFromRunLoop(self, run_loop, run_loop_mode) }
369 }
370}
371
372#[deprecated = "No longer supported"]
373#[inline]
374pub unsafe extern "C-unwind" fn WSMethodResultIsFault(
375 method_result: Option<&CFDictionary>,
376) -> bool {
377 extern "C-unwind" {
378 fn WSMethodResultIsFault(method_result: Option<&CFDictionary>) -> Boolean;
379 }
380 let ret = unsafe { WSMethodResultIsFault(method_result) };
381 ret != 0
382}
383
384pub type WSMethodInvocationSerializationProcPtr = Option<
386 unsafe extern "C-unwind" fn(
387 *mut WSMethodInvocation,
388 *const CFType,
389 *mut c_void,
390 ) -> *const CFString,
391>;
392
393impl WSMethodInvocation {
394 #[doc(alias = "WSMethodInvocationAddSerializationOverride")]
395 #[cfg(feature = "WSTypes")]
396 #[deprecated = "No longer supported"]
397 #[inline]
398 pub unsafe fn add_serialization_override(
399 self: &WSMethodInvocation,
400 obj_type: CFTypeID,
401 serialization_proc: WSMethodInvocationSerializationProcPtr,
402 context: *mut WSClientContext,
403 ) {
404 extern "C-unwind" {
405 fn WSMethodInvocationAddSerializationOverride(
406 invocation: &WSMethodInvocation,
407 obj_type: CFTypeID,
408 serialization_proc: WSMethodInvocationSerializationProcPtr,
409 context: *mut WSClientContext,
410 );
411 }
412 unsafe {
413 WSMethodInvocationAddSerializationOverride(self, obj_type, serialization_proc, context)
414 }
415 }
416}
417
418pub type WSMethodInvocationDeserializationProcPtr = Option<
420 unsafe extern "C-unwind" fn(
421 *mut WSMethodInvocation,
422 *mut CFXMLTree,
423 *mut CFXMLTree,
424 *mut c_void,
425 ) -> *const CFType,
426>;
427
428impl WSMethodInvocation {
429 #[doc(alias = "WSMethodInvocationAddDeserializationOverride")]
430 #[cfg(feature = "WSTypes")]
431 #[deprecated = "No longer supported"]
432 #[inline]
433 pub unsafe fn add_deserialization_override(
434 self: &WSMethodInvocation,
435 type_namespace: Option<&CFString>,
436 type_name: Option<&CFString>,
437 deserialization_proc: WSMethodInvocationDeserializationProcPtr,
438 context: *mut WSClientContext,
439 ) {
440 extern "C-unwind" {
441 fn WSMethodInvocationAddDeserializationOverride(
442 invocation: &WSMethodInvocation,
443 type_namespace: Option<&CFString>,
444 type_name: Option<&CFString>,
445 deserialization_proc: WSMethodInvocationDeserializationProcPtr,
446 context: *mut WSClientContext,
447 );
448 }
449 unsafe {
450 WSMethodInvocationAddDeserializationOverride(
451 self,
452 type_namespace,
453 type_name,
454 deserialization_proc,
455 context,
456 )
457 }
458 }
459}
460
461#[deprecated = "renamed to `WSMethodInvocation::new`"]
462#[inline]
463pub unsafe extern "C-unwind" fn WSMethodInvocationCreate(
464 url: Option<&CFURL>,
465 method_name: Option<&CFString>,
466 protocol: Option<&CFString>,
467) -> Option<CFRetained<WSMethodInvocation>> {
468 extern "C-unwind" {
469 fn WSMethodInvocationCreate(
470 url: Option<&CFURL>,
471 method_name: Option<&CFString>,
472 protocol: Option<&CFString>,
473 ) -> Option<NonNull<WSMethodInvocation>>;
474 }
475 let ret = unsafe { WSMethodInvocationCreate(url, method_name, protocol) };
476 ret.map(|ret| unsafe { CFRetained::from_raw(ret) })
477}
478
479#[deprecated = "renamed to `WSMethodInvocation::from_serialization`"]
480#[inline]
481pub unsafe extern "C-unwind" fn WSMethodInvocationCreateFromSerialization(
482 contract: Option<&CFData>,
483) -> Option<CFRetained<WSMethodInvocation>> {
484 extern "C-unwind" {
485 fn WSMethodInvocationCreateFromSerialization(
486 contract: Option<&CFData>,
487 ) -> Option<NonNull<WSMethodInvocation>>;
488 }
489 let ret = unsafe { WSMethodInvocationCreateFromSerialization(contract) };
490 ret.map(|ret| unsafe { CFRetained::from_raw(ret) })
491}
492
493#[deprecated = "renamed to `WSMethodInvocation::serialization`"]
494#[inline]
495pub unsafe extern "C-unwind" fn WSMethodInvocationCopySerialization(
496 invocation: &WSMethodInvocation,
497) -> Option<CFRetained<CFData>> {
498 extern "C-unwind" {
499 fn WSMethodInvocationCopySerialization(
500 invocation: &WSMethodInvocation,
501 ) -> Option<NonNull<CFData>>;
502 }
503 let ret = unsafe { WSMethodInvocationCopySerialization(invocation) };
504 ret.map(|ret| unsafe { CFRetained::from_raw(ret) })
505}
506
507extern "C-unwind" {
508 #[deprecated = "renamed to `WSMethodInvocation::set_parameters`"]
509 pub fn WSMethodInvocationSetParameters(
510 invocation: &WSMethodInvocation,
511 parameters: Option<&CFDictionary>,
512 parameter_order: Option<&CFArray>,
513 );
514}
515
516#[deprecated = "renamed to `WSMethodInvocation::parameters`"]
517#[inline]
518pub unsafe extern "C-unwind" fn WSMethodInvocationCopyParameters(
519 invocation: &WSMethodInvocation,
520 parameter_order: *mut *const CFArray,
521) -> Option<CFRetained<CFDictionary>> {
522 extern "C-unwind" {
523 fn WSMethodInvocationCopyParameters(
524 invocation: &WSMethodInvocation,
525 parameter_order: *mut *const CFArray,
526 ) -> Option<NonNull<CFDictionary>>;
527 }
528 let ret = unsafe { WSMethodInvocationCopyParameters(invocation, parameter_order) };
529 ret.map(|ret| unsafe { CFRetained::from_raw(ret) })
530}
531
532extern "C-unwind" {
533 #[deprecated = "renamed to `WSMethodInvocation::set_property`"]
534 pub fn WSMethodInvocationSetProperty(
535 invocation: &WSMethodInvocation,
536 property_name: Option<&CFString>,
537 property_value: Option<&CFType>,
538 );
539}
540
541#[deprecated = "renamed to `WSMethodInvocation::property`"]
542#[inline]
543pub unsafe extern "C-unwind" fn WSMethodInvocationCopyProperty(
544 invocation: &WSMethodInvocation,
545 property_name: Option<&CFString>,
546) -> Option<CFRetained<CFType>> {
547 extern "C-unwind" {
548 fn WSMethodInvocationCopyProperty(
549 invocation: &WSMethodInvocation,
550 property_name: Option<&CFString>,
551 ) -> Option<NonNull<CFType>>;
552 }
553 let ret = unsafe { WSMethodInvocationCopyProperty(invocation, property_name) };
554 ret.map(|ret| unsafe { CFRetained::from_raw(ret) })
555}
556
557#[deprecated = "renamed to `WSMethodInvocation::invoke`"]
558#[inline]
559pub unsafe extern "C-unwind" fn WSMethodInvocationInvoke(
560 invocation: &WSMethodInvocation,
561) -> Option<CFRetained<CFDictionary>> {
562 extern "C-unwind" {
563 fn WSMethodInvocationInvoke(
564 invocation: &WSMethodInvocation,
565 ) -> Option<NonNull<CFDictionary>>;
566 }
567 let ret = unsafe { WSMethodInvocationInvoke(invocation) };
568 ret.map(|ret| unsafe { CFRetained::from_raw(ret) })
569}
570
571extern "C-unwind" {
572 #[cfg(feature = "WSTypes")]
573 #[deprecated = "renamed to `WSMethodInvocation::set_call_back`"]
574 pub fn WSMethodInvocationSetCallBack(
575 invocation: &WSMethodInvocation,
576 client_cb: WSMethodInvocationCallBackProcPtr,
577 context: *mut WSClientContext,
578 );
579}
580
581extern "C-unwind" {
582 #[deprecated = "renamed to `WSMethodInvocation::schedule_with_run_loop`"]
583 pub fn WSMethodInvocationScheduleWithRunLoop(
584 invocation: &WSMethodInvocation,
585 run_loop: Option<&CFRunLoop>,
586 run_loop_mode: Option<&CFString>,
587 );
588}
589
590extern "C-unwind" {
591 #[deprecated = "renamed to `WSMethodInvocation::unschedule_from_run_loop`"]
592 pub fn WSMethodInvocationUnscheduleFromRunLoop(
593 invocation: &WSMethodInvocation,
594 run_loop: Option<&CFRunLoop>,
595 run_loop_mode: Option<&CFString>,
596 );
597}
598
599extern "C-unwind" {
600 #[cfg(feature = "WSTypes")]
601 #[deprecated = "renamed to `WSMethodInvocation::add_serialization_override`"]
602 pub fn WSMethodInvocationAddSerializationOverride(
603 invocation: &WSMethodInvocation,
604 obj_type: CFTypeID,
605 serialization_proc: WSMethodInvocationSerializationProcPtr,
606 context: *mut WSClientContext,
607 );
608}
609
610extern "C-unwind" {
611 #[cfg(feature = "WSTypes")]
612 #[deprecated = "renamed to `WSMethodInvocation::add_deserialization_override`"]
613 pub fn WSMethodInvocationAddDeserializationOverride(
614 invocation: &WSMethodInvocation,
615 type_namespace: Option<&CFString>,
616 type_name: Option<&CFString>,
617 deserialization_proc: WSMethodInvocationDeserializationProcPtr,
618 context: *mut WSClientContext,
619 );
620}