apple-cf 0.9.0

Safe Rust bindings for Apple's shared Core* frameworks (CoreFoundation, CoreMedia, CoreVideo, CoreGraphics, IOSurface, Dispatch).
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

import Foundation

@_cdecl("acf_dispatch_async_f")
public func acf_dispatch_async_f(
    _ queue: UnsafeMutableRawPointer,
    _ context: UnsafeMutableRawPointer?,
    _ work: (@convention(c) (UnsafeMutableRawPointer?) -> Void)?
) {
    guard let work else { return }
    let queue = Unmanaged<DispatchQueue>.fromOpaque(queue).takeUnretainedValue()
    queue.async {
        work(context)
    }
}

@_cdecl("acf_dispatch_async_and_wait_f")
public func acf_dispatch_async_and_wait_f(
    _ queue: UnsafeMutableRawPointer,
    _ context: UnsafeMutableRawPointer?,
    _ work: (@convention(c) (UnsafeMutableRawPointer?) -> Void)?
) {
    guard let work else { return }
    let queue = Unmanaged<DispatchQueue>.fromOpaque(queue).takeUnretainedValue()
    queue.asyncAndWait {
        work(context)
    }
}

@_cdecl("acf_dispatch_apply_f")
public func acf_dispatch_apply_f(
    _ iterations: Int,
    _ queue: UnsafeMutableRawPointer,
    _ context: UnsafeMutableRawPointer?,
    _ work: (@convention(c) (Int, UnsafeMutableRawPointer?) -> Void)?
) {
    guard let work, iterations > 0 else { return }
    let queue = Unmanaged<DispatchQueue>.fromOpaque(queue).takeUnretainedValue()
    let group = DispatchGroup()
    for iteration in 0..<iterations {
        group.enter()
        queue.async {
            work(iteration, context)
            group.leave()
        }
    }
    group.wait()
}

private func dispatchDeadline(timeoutMs: Int64) -> DispatchTime {
    if timeoutMs < 0 {
        return .distantFuture
    }
    return .now() + .milliseconds(Int(timeoutMs))
}

final class DispatchSourceTimerHolder {
    let source: DispatchSourceTimer
    private(set) var fireCount: UInt64 = 0

    init(intervalMs: UInt64, leewayMs: UInt64) {
        let queue = DispatchQueue(label: "com.doomfish.apple-cf.dispatch-source")
        source = DispatchSource.makeTimerSource(queue: queue)
        source.setEventHandler { [weak self] in
            self?.fireCount += 1
        }
        source.schedule(
            deadline: .now() + .milliseconds(Int(intervalMs)),
            repeating: .milliseconds(Int(intervalMs)),
            leeway: .milliseconds(Int(leewayMs))
        )
    }
}

@_cdecl("acf_dispatch_group_create")
public func acf_dispatch_group_create() -> UnsafeMutableRawPointer {
    return Unmanaged.passRetained(DispatchGroup()).toOpaque()
}

@_cdecl("acf_dispatch_group_enter")
public func acf_dispatch_group_enter(_ group: UnsafeMutableRawPointer) {
    let group = Unmanaged<DispatchGroup>.fromOpaque(group).takeUnretainedValue()
    group.enter()
}

@_cdecl("acf_dispatch_group_leave")
public func acf_dispatch_group_leave(_ group: UnsafeMutableRawPointer) {
    let group = Unmanaged<DispatchGroup>.fromOpaque(group).takeUnretainedValue()
    group.leave()
}

@_cdecl("acf_dispatch_group_wait")
public func acf_dispatch_group_wait(_ group: UnsafeMutableRawPointer, _ timeoutMs: Int64) -> Bool {
    let group = Unmanaged<DispatchGroup>.fromOpaque(group).takeUnretainedValue()
    return group.wait(timeout: dispatchDeadline(timeoutMs: timeoutMs)) == .success
}

@_cdecl("acf_dispatch_semaphore_create")
public func acf_dispatch_semaphore_create(_ value: Int64) -> UnsafeMutableRawPointer {
    return Unmanaged.passRetained(DispatchSemaphore(value: Int(value))).toOpaque()
}

@_cdecl("acf_dispatch_semaphore_signal")
public func acf_dispatch_semaphore_signal(_ semaphore: UnsafeMutableRawPointer) -> Int64 {
    let semaphore = Unmanaged<DispatchSemaphore>.fromOpaque(semaphore).takeUnretainedValue()
    return Int64(semaphore.signal())
}

@_cdecl("acf_dispatch_semaphore_wait")
public func acf_dispatch_semaphore_wait(_ semaphore: UnsafeMutableRawPointer, _ timeoutMs: Int64) -> Bool {
    let semaphore = Unmanaged<DispatchSemaphore>.fromOpaque(semaphore).takeUnretainedValue()
    return semaphore.wait(timeout: dispatchDeadline(timeoutMs: timeoutMs)) == .success
}

@_cdecl("acf_dispatch_source_timer_create")
public func acf_dispatch_source_timer_create(_ intervalMs: UInt64, _ leewayMs: UInt64) -> UnsafeMutableRawPointer {
    return Unmanaged.passRetained(DispatchSourceTimerHolder(intervalMs: intervalMs, leewayMs: leewayMs)).toOpaque()
}

@_cdecl("acf_dispatch_source_timer_resume")
public func acf_dispatch_source_timer_resume(_ source: UnsafeMutableRawPointer) {
    let source = Unmanaged<DispatchSourceTimerHolder>.fromOpaque(source).takeUnretainedValue()
    source.source.resume()
}

@_cdecl("acf_dispatch_source_timer_cancel")
public func acf_dispatch_source_timer_cancel(_ source: UnsafeMutableRawPointer) {
    let source = Unmanaged<DispatchSourceTimerHolder>.fromOpaque(source).takeUnretainedValue()
    source.source.cancel()
}

@_cdecl("acf_dispatch_source_timer_fire_count")
public func acf_dispatch_source_timer_fire_count(_ source: UnsafeMutableRawPointer) -> UInt64 {
    let source = Unmanaged<DispatchSourceTimerHolder>.fromOpaque(source).takeUnretainedValue()
    return source.fireCount
}