objc 0.0.3

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

#![allow(unstable)]

#[macro_use]
extern crate objc;

use objc::{encode, Id, ToMessage, WeakId};
use objc::runtime::{Class, Object, Sel};

fn main() {
    // Get a class
    let cls = Class::get("NSObject").unwrap();
    println!("NSObject size: {}", cls.instance_size());

    // Inspect its ivars
    println!("NSObject ivars:");
    for ivar in cls.instance_variables().as_slice().iter() {
        println!("{}", ivar.name());
    }

    // Allocate an instance
    let obj: Id<Object> = unsafe {
        let obj = msg_send![cls, alloc];
        let obj = msg_send![obj, init];
        Id::from_retained_ptr(obj)
    };
    println!("NSObject address: {:?}", obj.as_ptr());

    // Access an ivar of the object
    let isa: *const Class = unsafe {
        *obj.get_ivar("isa")
    };
    println!("NSObject isa: {:?}", isa);

    // Inspect a method of the class
    let hash_sel = Sel::register("hash");
    let hash_method = cls.instance_method(hash_sel).unwrap();
    let hash_return = hash_method.return_type();
    println!("-[NSObject hash] return type: {}", hash_return.as_slice());
    assert!(encode::<usize>() == hash_return.as_slice());

    // Invoke a method on the object
    let hash = unsafe {
        (msg_send![obj, hash]) as usize
    };
    println!("NSObject hash: {}", hash);

    // Take a weak reference to the object
    let obj = obj.share();
    let weak = WeakId::new(&obj);
    println!("Weak reference is nil? {}", weak.load().is_none());

    println!("Releasing object");
    drop(obj);
    println!("Weak reference is nil? {}", weak.load().is_none());
}