fruity 0.3.0

Rusty bindings for Apple libraries
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

use super::{sys, DispatchQueue};
use crate::core::{Arc, ObjectType};
use std::{
    cell::UnsafeCell,
    ffi::c_void,
    panic::RefUnwindSafe,
    ptr::{self, NonNull},
};

/// The base type for dispatch objects.
///
/// Documentation:
/// [Swift](https://developer.apple.com/documentation/dispatch/dispatchobject) |
/// [Objective-C](https://developer.apple.com/documentation/dispatch/&DispatchObject)
#[repr(C)]
pub struct DispatchObject {
    // Stores data that may be mutated behind a shared reference. Internal
    // mutability triggers undefined behavior without `UnsafeCell`.
    _data: UnsafeCell<[u8; 0]>,
}

impl ObjectType for DispatchObject {
    #[inline]
    #[doc(alias = "dispatch_retain")]
    fn retain(obj: &Self) -> Arc<Self> {
        unsafe {
            sys::dispatch_retain(obj);
            Arc::from_raw(obj)
        }
    }

    #[inline]
    #[doc(alias = "dispatch_release")]
    unsafe fn release(obj: NonNull<Self>) {
        sys::dispatch_release(obj.as_ptr());
    }
}

unsafe impl Send for DispatchObject {}
unsafe impl Sync for DispatchObject {}

// Although this uses `UnsafeCell`, it does not point to any Rust types.
impl RefUnwindSafe for DispatchObject {}

impl AsRef<DispatchObject> for DispatchObject {
    #[inline]
    fn as_ref(&self) -> &Self {
        self
    }
}

/// Dispatch operations.
impl DispatchObject {
    /// Activates `self`.
    ///
    /// Once a dispatch object has been activated, it cannot change its target
    /// queue.
    ///
    /// See [documentation](https://developer.apple.com/documentation/dispatch/1641002-dispatch_activate).
    #[inline]
    #[doc(alias = "dispatch_activate")]
    pub fn activate(&self) {
        unsafe { sys::dispatch_activate(self) };
    }

    /// Resumes the invocation of block objects on `self`.
    ///
    /// See [documentation](https://developer.apple.com/documentation/dispatch/1452929-dispatch_resume).
    #[inline]
    #[doc(alias = "dispatch_resume")]
    pub fn resume(&self) {
        unsafe { sys::dispatch_resume(self) };
    }

    /// Suspends the invocation of block objects on `self`.
    ///
    /// See [documentation](https://developer.apple.com/documentation/dispatch/1452801-dispatch_suspend).
    #[inline]
    #[doc(alias = "dispatch_suspend")]
    pub fn suspend(&self) {
        unsafe { sys::dispatch_suspend(self) };
    }

    /// Specifies the dispatch queue on which to perform work associated with
    /// `self`.
    ///
    /// If this queue has already been activated, then this method will fail.
    ///
    /// **Important:** When setting up target queues, it is a programmer error
    /// to create cycles in the dispatch queue hierarchy. In other words, don't
    /// set the target of queue A to queue B and set the target of queue B to
    /// queue A.
    ///
    /// Documentation:
    /// [Swift](https://developer.apple.com/documentation/dispatch/dispatchobject/1452989-settarget) |
    /// [Objective-C](https://developer.apple.com/documentation/dispatch/1452989-dispatch_set_target_queue)
    ///
    /// # Safety
    ///
    /// The target queue must be expected for this dispatch object. For example,
    /// an object may expect to dispatch to the main queue.
    #[inline]
    #[doc(alias = "dispatch_set_target_queue")]
    pub unsafe fn set_target<Q>(&self, queue: Option<&DispatchQueue>) {
        let queue = match queue {
            Some(queue) => queue,
            None => ptr::null(),
        };
        sys::dispatch_set_target_queue(self, queue);
    }

    /// Returns the application-defined context of an object.
    ///
    /// See [documentation](https://developer.apple.com/documentation/dispatch/1453005-dispatch_get_context).
    #[inline]
    #[doc(alias = "dispatch_get_context")]
    pub fn context(&self) -> *mut c_void {
        unsafe { sys::dispatch_get_context(self) }
    }

    /// Associates an application-defined context with the object.
    ///
    /// See [documentation](https://developer.apple.com/documentation/dispatch/1452807-dispatch_set_context).
    ///
    /// # Safety
    ///
    /// The object or dependent code may make assumptions about its current
    /// context. Callers must be careful to not invalidate any assumptions.
    #[inline]
    #[doc(alias = "dispatch_set_context")]
    pub unsafe fn set_context(&self, context: *mut c_void) {
        sys::dispatch_set_context(self, context);
    }
}