objc2-foundation 0.3.2

Bindings to the Foundation framework
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139

//! This file has been automatically generated by `objc2`'s `header-translator`.
//! DO NOT EDIT
use core::ffi::*;
use core::ptr::NonNull;
use objc2::__framework_prelude::*;

use crate::*;

extern_class!(
    /// [Apple's documentation](https://developer.apple.com/documentation/foundation/nsinvocation?language=objc)
    #[unsafe(super(NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct NSInvocation;
);

extern_conformance!(
    unsafe impl NSObjectProtocol for NSInvocation {}
);

impl NSInvocation {
    extern_methods!(
        #[cfg(feature = "NSMethodSignature")]
        #[unsafe(method(invocationWithMethodSignature:))]
        #[unsafe(method_family = none)]
        pub unsafe fn invocationWithMethodSignature(
            sig: &NSMethodSignature,
        ) -> Retained<NSInvocation>;

        #[cfg(feature = "NSMethodSignature")]
        #[unsafe(method(methodSignature))]
        #[unsafe(method_family = none)]
        pub unsafe fn methodSignature(&self) -> Retained<NSMethodSignature>;

        #[unsafe(method(retainArguments))]
        #[unsafe(method_family = none)]
        pub unsafe fn retainArguments(&self);

        #[unsafe(method(argumentsRetained))]
        #[unsafe(method_family = none)]
        pub unsafe fn argumentsRetained(&self) -> bool;

        /// # Safety
        ///
        /// This is not retained internally, you must ensure the object is still alive.
        #[unsafe(method(target))]
        #[unsafe(method_family = none)]
        pub unsafe fn target(&self) -> Option<Retained<AnyObject>>;

        /// Setter for [`target`][Self::target].
        ///
        /// # Safety
        ///
        /// - `target` should be of the correct type.
        /// - This is unretained, you must ensure the object is kept alive while in use.
        #[unsafe(method(setTarget:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setTarget(&self, target: Option<&AnyObject>);

        #[unsafe(method(selector))]
        #[unsafe(method_family = none)]
        pub unsafe fn selector(&self) -> Sel;

        /// Setter for [`selector`][Self::selector].
        ///
        /// # Safety
        ///
        /// `selector` must be a valid selector.
        #[unsafe(method(setSelector:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setSelector(&self, selector: Sel);

        /// # Safety
        ///
        /// `ret_loc` must be a valid pointer.
        #[unsafe(method(getReturnValue:))]
        #[unsafe(method_family = none)]
        pub unsafe fn getReturnValue(&self, ret_loc: NonNull<c_void>);

        /// # Safety
        ///
        /// `ret_loc` must be a valid pointer.
        #[unsafe(method(setReturnValue:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setReturnValue(&self, ret_loc: NonNull<c_void>);

        /// # Safety
        ///
        /// `argument_location` must be a valid pointer.
        #[unsafe(method(getArgument:atIndex:))]
        #[unsafe(method_family = none)]
        pub unsafe fn getArgument_atIndex(
            &self,
            argument_location: NonNull<c_void>,
            idx: NSInteger,
        );

        /// # Safety
        ///
        /// `argument_location` must be a valid pointer.
        #[unsafe(method(setArgument:atIndex:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setArgument_atIndex(
            &self,
            argument_location: NonNull<c_void>,
            idx: NSInteger,
        );

        #[unsafe(method(invoke))]
        #[unsafe(method_family = none)]
        pub unsafe fn invoke(&self);

        /// # Safety
        ///
        /// `target` should be of the correct type.
        #[unsafe(method(invokeWithTarget:))]
        #[unsafe(method_family = none)]
        pub unsafe fn invokeWithTarget(&self, target: &AnyObject);

        /// # Safety
        ///
        /// `imp` must be a valid IMP.
        #[unsafe(method(invokeUsingIMP:))]
        #[unsafe(method_family = none)]
        pub unsafe fn invokeUsingIMP(&self, imp: Option<Imp>);
    );
}

/// Methods declared on superclass `NSObject`.
impl NSInvocation {
    extern_methods!(
        #[unsafe(method(init))]
        #[unsafe(method_family = init)]
        pub unsafe fn init(this: Allocated<Self>) -> Retained<Self>;

        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}