diff --git a/Cargo.toml b/Cargo.toml index 593c2fa..5101e40 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -14,3 +14,4 @@ build = "build.rs" [dependencies] libc = "0.2" +mach = "0.0.5" diff --git a/src/base.rs b/src/base.rs index b6b434b..68ecd01 100644 --- a/src/base.rs +++ b/src/base.rs @@ -65,6 +65,17 @@ pub struct __CFAllocator { pub type CFAllocatorRef = *const __CFAllocator; +pub type CFAllocatorAllocateCallBack = extern "C" fn(allocSize: CFIndex, hint: CFOptionFlags, info: *mut c_void) + -> *mut c_void; +pub type CFAllocatorCopyDescriptionCallBack = extern "C" fn(info: *const c_void) -> CFStringRef; +pub type CFAllocatorDeallocateCallBack = extern "C" fn(ptr: *mut c_void, info: *mut c_void); +pub type CFAllocatorPreferredSizeCallBack = extern "C" fn(size: CFIndex, hint: CFOptionFlags, info: *mut c_void) + -> CFIndex; +pub type CFAllocatorReallocateCallBack = extern "C" fn(ptr: *mut c_void, newSize: CFIndex, hint: CFOptionFlags, + info: *mut c_void) -> *mut c_void; +pub type CFAllocatorReleaseCallBack = extern "C" fn(info: *const c_void); +pub type CFAllocatorRetainCallBack = extern "C" fn(info: *const c_void) -> *const c_void; + extern "C" { pub static kCFAllocatorDefault: CFAllocatorRef; pub static kCFAllocatorSystemDefault: CFAllocatorRef; diff --git a/src/date.rs b/src/date.rs new file mode 100644 index 0000000..98cbcd5 --- /dev/null +++ b/src/date.rs @@ -0,0 +1,4 @@ +use libc::c_double; + +pub type CFAbsoluteTime = CFTimeInterval; +pub type CFTimeInterval = c_double; diff --git a/src/lib.rs b/src/lib.rs index 92135bc..31da818 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -1,14 +1,17 @@ -#![allow(non_upper_case_globals,non_snake_case)] +#![allow(non_upper_case_globals, non_snake_case)] extern crate libc; +extern crate mach; pub use array::*; pub use base::*; pub use character_set::*; pub use data::*; +pub use date::*; pub use dictionary::*; pub use locale::*; pub use number::*; +pub use runloop::*; pub use set::*; pub use string::*; pub use uuid::*; @@ -18,9 +21,11 @@ pub mod array; pub mod base; pub mod character_set; pub mod data; +pub mod date; pub mod dictionary; pub mod locale; pub mod number; +pub mod runloop; pub mod set; pub mod string; pub mod uuid; diff --git a/src/runloop.rs b/src/runloop.rs new file mode 100644 index 0000000..dbfa47b --- /dev/null +++ b/src/runloop.rs @@ -0,0 +1,188 @@ +use libc::c_void; +use mach::port::mach_port_t; +use ::{Boolean, CFAbsoluteTime, CFAllocatorRef, CFAllocatorCopyDescriptionCallBack, CFAllocatorReleaseCallBack, + CFAllocatorRetainCallBack, CFArrayRef, CFHashCode, CFIndex, CFOptionFlags, CFStringRef, CFTimeInterval, + CFTypeID, CFTypeRef}; + +#[doc(hidden)] +#[repr(C)] +pub struct __CFRunLoop { + __private: c_void +} + +pub type CFRunLoopRef = *mut __CFRunLoop; + +pub type CFRunLoopRunResult = i32; + +pub const kCFRunLoopRunFinished: CFRunLoopRunResult = 1; +pub const kCFRunLoopRunStopped: CFRunLoopRunResult = 2; +pub const kCFRunLoopRunTimedOut: CFRunLoopRunResult = 3; +pub const kCFRunLoopRunHandledSource: CFRunLoopRunResult = 4; + +extern "C" { + pub static kCFRunLoopCommonModes: CFStringRef; + pub static kCFRunLoopDefaultMode: CFStringRef; + + pub fn CFRunLoopGetCurrent() -> CFRunLoopRef; + pub fn CFRunLoopGetMain() -> CFRunLoopRef; + + pub fn CFRunLoopRun(); + pub fn CFRunLoopRunInMode(mode: CFStringRef, seconds: CFTimeInterval, returnAfterSourceHandled: Boolean) + -> CFRunLoopRunResult; + + pub fn CFRunLoopWakeUp(rl: CFRunLoopRef); + pub fn CFRunLoopStop(rl: CFRunLoopRef); + pub fn CFRunLoopIsWaiting(rl: CFRunLoopRef) -> Boolean; + + pub fn CFRunLoopAddSource(rl: CFRunLoopRef, source: CFRunLoopSourceRef, mode: CFStringRef); + pub fn CFRunLoopContainsSource(rl: CFRunLoopRef, source: CFRunLoopSourceRef, mode: CFStringRef) -> Boolean; + pub fn CFRunLoopRemoveSource(rl: CFRunLoopRef, source: CFRunLoopSourceRef, mode: CFStringRef); + + pub fn CFRunLoopAddObserver(rl: CFRunLoopRef, observer: CFRunLoopObserverRef, mode: CFStringRef); + pub fn CFRunLoopContainsObserver(rl: CFRunLoopRef, source: CFRunLoopObserverRef, mode: CFStringRef) -> Boolean; + pub fn CFRunLoopRemoveObserver(rl: CFRunLoopRef, source: CFRunLoopObserverRef, mode: CFStringRef); + + pub fn CFRunLoopAddCommonMode(rl: CFRunLoopRef, mode: CFStringRef); + pub fn CFRunLoopCopyAllModes(rl: CFRunLoopRef) -> CFArrayRef; + pub fn CFRunLoopCopyCurrentMode(rl: CFRunLoopRef) -> CFStringRef; + + pub fn CFRunLoopAddTimer(rl: CFRunLoopRef, timer: CFRunLoopTimerRef, mode: CFStringRef); + pub fn CFRunLoopGetNextTimerFireDate(rl: CFRunLoopRef, mode: CFStringRef) -> CFAbsoluteTime; + pub fn CFRunLoopRemoveTimer(rl: CFRunLoopRef, timer: CFRunLoopTimerRef, mode: CFStringRef); + pub fn CFRunLoopContainsTimer(rl: CFRunLoopRef, timer: CFRunLoopTimerRef, mode: CFStringRef) -> Boolean; + + pub fn CFRunLoopPerformBlock(rl: CFRunLoopRef, mode: CFTypeRef, block: *mut c_void); + pub fn CFRunLoopGetTypeID() -> CFTypeID; +} + +#[doc(hidden)] +#[repr(C)] +pub struct __CFRunLoopSource { + __private: c_void +} + +pub type CFRunLoopSourceRef = *mut __CFRunLoopSource; + +#[repr(C)] +pub struct CFRunLoopSourceContext { + pub version: CFIndex, + pub info: *mut c_void, + pub retain: extern "C" fn(info: *const c_void) -> *const c_void, + pub release: extern "C" fn(info: *const c_void), + pub copyDescription: extern "C" fn(info: *const c_void) -> CFStringRef, + pub equal: extern "C" fn(info1: *const c_void, info2: *const c_void) -> Boolean, + pub hash: extern "C" fn(info: *const c_void) -> CFHashCode, + pub schedule: extern "C" fn(info: *mut c_void, rl: CFRunLoopRef, mode: CFStringRef), + pub cancel: extern "C" fn(info: *mut c_void, rl: CFRunLoopRef, mode: CFStringRef), + pub perform: extern "C" fn(info: *mut c_void) +} + +#[repr(C)] +pub struct CFRunLoopSourceContext1 { + pub version: CFIndex, + pub info: *mut c_void, + pub retain: extern "C" fn(info: *const c_void) -> *const c_void, + pub release: extern "C" fn(info: *const c_void), + pub copyDescription: extern "C" fn(info: *const c_void) -> CFStringRef, + pub equal: extern "C" fn(info1: *const c_void, info2: *const c_void) -> Boolean, + pub hash: extern "C" fn(info: *const c_void) -> CFHashCode, + pub getPort: extern "C" fn(info: *mut c_void) -> mach_port_t, + pub perform: extern "C" fn(msg: *mut c_void, size: CFIndex, allocator: CFAllocatorRef, + info: *mut c_void) -> *mut c_void +} + +extern "C" { + pub fn CFRunLoopSourceCreate(allocator: CFAllocatorRef, order: CFIndex, context: *mut CFRunLoopSourceContext) + -> CFRunLoopSourceRef; + pub fn CFRunLoopSourceGetContext(source: CFRunLoopSourceRef, context: *mut CFRunLoopSourceContext); + pub fn CFRunLoopSourceGetOrder(source: CFRunLoopSourceRef) -> CFIndex; + pub fn CFRunLoopSourceGetTypeID() -> CFTypeID; + pub fn CFRunLoopSourceInvalidate(source: CFRunLoopSourceRef); + pub fn CFRunLoopSourceIsValid(source: CFRunLoopSourceRef) -> Boolean; + pub fn CFRunLoopSourceSignal(source: CFRunLoopSourceRef); +} + +#[doc(hidden)] +#[repr(C)] +pub struct __CFRunLoopObserver { + __private: c_void +} + +pub type CFRunLoopObserverRef = *mut __CFRunLoopObserver; + +#[repr(C)] +pub struct CFRunLoopObserverContext { + pub version: CFIndex, + pub info: *mut c_void, + pub retain: extern "C" fn(info: *const c_void) -> *const c_void, + pub release: extern "C" fn(info: *const c_void), + pub copyDescription: extern "C" fn(info: *const c_void) -> CFStringRef, +} + +pub type CFRunLoopObserverCallBack = extern "C" fn(observer: CFRunLoopObserverRef, activity: CFRunLoopActivity, + info: *mut c_void); + +pub type CFRunLoopActivity = CFOptionFlags; + +pub const kCFRunLoopEntry: CFRunLoopActivity = (1 << 0); +pub const kCFRunLoopBeforeTimers: CFRunLoopActivity = (1 << 1); +pub const kCFRunLoopBeforeSources: CFRunLoopActivity = (1 << 2); +pub const kCFRunLoopBeforeWaiting: CFRunLoopActivity = (1 << 5); +pub const kCFRunLoopAfterWaiting: CFRunLoopActivity = (1 << 6); +pub const kCFRunLoopExit: CFRunLoopActivity = (1 << 7); +pub const kCFRunLoopAllActivities: CFRunLoopActivity = 0x0FFFFFFF; + +extern "C" { + pub fn CFRunLoopObserverCreateWithHandler(allocator: CFAllocatorRef, activities: CFOptionFlags, repeats: Boolean, + order: CFIndex, block: *mut c_void) -> CFRunLoopObserverRef; + pub fn CFRunLoopObserverCreate(allocator: CFAllocatorRef, activities: CFOptionFlags, repeats: Boolean, + order: CFIndex, callout: CFRunLoopObserverCallBack, + context: *mut CFRunLoopObserverContext) -> CFRunLoopObserverRef; + + pub fn CFRunLoopObserverDoesRepeat(observer: CFRunLoopObserverRef) -> Boolean; + pub fn CFRunLoopObserverGetActivities(observer: CFRunLoopObserverRef) -> CFOptionFlags; + pub fn CFRunLoopObserverGetContext(observer: CFRunLoopObserverRef, context: *mut CFRunLoopObserverContext); + pub fn CFRunLoopObserverGetOrder(observer: CFRunLoopObserverRef) -> CFIndex; + + pub fn CFRunLoopObserverGetTypeID() -> CFTypeID; + + pub fn CFRunLoopObserverInvalidate(observer: CFRunLoopObserverRef); + pub fn CFRunLoopObserverIsValid(observer: CFRunLoopObserverRef) -> Boolean; +} + +#[doc(hidden)] +#[repr(C)] +pub struct __CFRunLoopTimer { + __private: c_void +} + +pub type CFRunLoopTimerRef = *mut __CFRunLoopTimer; + +pub type CFRunLoopTimerCallBack = extern "C" fn(timer: CFRunLoopTimerRef, info: *mut c_void); + +#[repr(C)] +pub struct CFRunLoopTimerContext { + pub version: CFIndex, + pub info: *mut c_void, + pub retain: CFAllocatorRetainCallBack, + pub release: CFAllocatorReleaseCallBack, + pub copyDescription: CFAllocatorCopyDescriptionCallBack +} + +extern "C" { + pub fn CFRunLoopTimerCreateWithHandler(allocator: CFAllocatorRef, fireDate: CFAbsoluteTime, interval: CFTimeInterval, + flags: CFOptionFlags, order: CFIndex, block: *mut c_void) -> CFRunLoopTimerRef; + pub fn CFRunLoopTimerCreate(allocator: CFAllocatorRef, fireDate: CFAbsoluteTime, interval: CFTimeInterval, + flags: CFOptionFlags, order: CFIndex, callout: CFRunLoopTimerCallBack, + context: *mut CFRunLoopTimerContext) -> CFRunLoopTimerRef; + + pub fn CFRunLoopTimerDoesRepeat(timer: CFRunLoopTimerRef) -> Boolean; + pub fn CFRunLoopTimerGetContext(timer: CFRunLoopTimerRef, context: *mut CFRunLoopTimerContext); + pub fn CFRunLoopTimerGetInterval(timer: CFRunLoopTimerRef) -> CFTimeInterval; + pub fn CFRunLoopTimerGetNextFireDate(timer: CFRunLoopTimerRef) -> CFAbsoluteTime; + pub fn CFRunLoopTimerGetOrder(timer: CFRunLoopTimerRef) -> CFIndex; + pub fn CFRunLoopTimerGetTypeID() -> CFTypeID; + pub fn CFRunLoopTimerInvalidate(timer: CFRunLoopTimerRef); + pub fn CFRunLoopTimerIsValid(timer: CFRunLoopTimerRef) -> Boolean; + pub fn CFRunLoopTimerSetNextFireDate(timer: CFRunLoopTimerRef, fireDate: CFAbsoluteTime); +}