objc 0.0.7

Objective-C Runtime bindings and wrapper for Rust.
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
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160

use std::marker::MarkerTrait;
use libc::{c_char, c_void};

use runtime::{Class, Object, Sel};

/// Types that have an Objective-C type encoding.
///
/// For more information, see Apple's documentation:
/// https://developer.apple.com/library/mac/documentation/Cocoa/Conceptual/ObjCRuntimeGuide/Articles/ocrtTypeEncodings.html
pub trait Encode : MarkerTrait {
    /// Returns the encoding for Self.
    fn code() -> &'static str;
}

impl Encode for i8 {
    fn code() -> &'static str { "c" }
}

impl Encode for i16 {
    fn code() -> &'static str { "s" }
}

impl Encode for i32 {
    fn code() -> &'static str { "i" }
}

impl Encode for i64 {
    fn code() -> &'static str { "q" }
}

impl Encode for isize {
    #[cfg(target_pointer_width = "32")]
    fn code() -> &'static str { "i" }

    #[cfg(target_pointer_width = "64")]
    fn code() -> &'static str { "q" }
}

impl Encode for u8 {
    fn code() -> &'static str { "C" }
}

impl Encode for u16 {
    fn code() -> &'static str { "S" }
}

impl Encode for u32 {
    fn code() -> &'static str { "I" }
}

impl Encode for u64 {
    fn code() -> &'static str { "Q" }
}

impl Encode for usize {
    #[cfg(target_pointer_width = "32")]
    fn code() -> &'static str { "I" }

    #[cfg(target_pointer_width = "64")]
    fn code() -> &'static str { "Q" }
}

impl Encode for f32 {
    fn code() -> &'static str { "f" }
}

impl Encode for f64 {
    fn code() -> &'static str { "d" }
}

impl Encode for bool {
    fn code() -> &'static str { "B" }
}

impl Encode for () {
    fn code() -> &'static str { "v" }
}

impl Encode for *mut c_char {
    fn code() -> &'static str { "*" }
}

impl Encode for *const c_char {
    fn code() -> &'static str { "r*" }
}

impl Encode for *mut c_void {
    fn code() -> &'static str { "^v" }
}

impl Encode for *const c_void {
    fn code() -> &'static str { "r^v" }
}

impl Encode for Sel {
    fn code() -> &'static str { ":" }
}

/// Types that pointers to have an Objective-C type encoding.
///
/// This trait is largely for convenience, so that it can be implemnted once
/// to implement encode for the 6 pointer types: immutable/mutable references,
/// optional immutable/mutable references, and const/mutable pointers.
pub trait EncodePtr : MarkerTrait {
    /// Returns the encoding for pointers to Self.
    fn ptr_code() -> &'static str;
}

impl<'a, T> Encode for &'a T where T: EncodePtr {
    fn code() -> &'static str { <T as EncodePtr>::ptr_code() }
}

impl<'a, T> Encode for &'a mut T where T: EncodePtr {
    fn code() -> &'static str { <T as EncodePtr>::ptr_code() }
}

impl<'a, T> Encode for Option<&'a T> where T: EncodePtr {
    fn code() -> &'static str { <T as EncodePtr>::ptr_code() }
}

impl<'a, T> Encode for Option<&'a mut T> where T: EncodePtr {
    fn code() -> &'static str { <T as EncodePtr>::ptr_code() }
}

impl<T> Encode for *const T where T: EncodePtr {
    fn code() -> &'static str { <T as EncodePtr>::ptr_code() }
}

impl<T> Encode for *mut T where T: EncodePtr {
    fn code() -> &'static str { <T as EncodePtr>::ptr_code() }
}

impl EncodePtr for Object {
    fn ptr_code() -> &'static str { "@" }
}

impl EncodePtr for Class {
    fn ptr_code() -> &'static str { "#" }
}

/// Returns the Objective-C type encoding for a type.
pub fn encode<T>() -> &'static str where T: Encode {
    <T as Encode>::code()
}

#[cfg(test)]
mod tests {
    use runtime::{Class, Object, Sel};
    use super::encode;

    #[test]
    fn test_encode() {
        assert!(encode::<u32>() == "I");
        assert!(encode::<()>() == "v");
        assert!(encode::<&Object>() == "@");
        assert!(encode::<*mut Object>() == "@");
        assert!(encode::<&Class>() == "#");
        assert!(encode::<Sel>() == ":");
    }
}