1 files changed, 139 insertions, 0 deletions
diff --git a/ctr-std/src/sys/horizon/condvar.rs b/ctr-std/src/sys/horizon/condvar.rs
new file mode 100644
index 0000000..f6cb49d
--- /dev/null
+++ b/ctr-std/src/sys/horizon/condvar.rs
@@ -0,0 +1,139 @@
+// Copyright 2016 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// *Implementation adapted from `/sys/redox/condvar.rs`
+
+use cell::UnsafeCell;
+use intrinsics::atomic_cxchg;
+use ptr;
+use time::Duration;
+
+use sys::mutex::{self, Mutex};
+
+pub struct Condvar {
+    lock: UnsafeCell<*mut ::libctru::LightLock>,
+}
+
+unsafe impl Send for Condvar {}
+unsafe impl Sync for Condvar {}
+
+impl Condvar {
+    pub const fn new() -> Condvar {
+        Condvar {
+            lock: UnsafeCell::new(ptr::null_mut()),
+        }
+    }
+
+    #[inline]
+    pub unsafe fn init(&self) {
+        *self.lock.get() = ptr::null_mut();
+    }
+
+    #[inline]
+    pub fn notify_one(&self) {
+        unsafe {
+            let arbiter = ::libctru::__sync_get_arbiter();
+
+            ::libctru::svcArbitrateAddress(arbiter,
+                                *self.lock.get() as u32,
+                                ::libctru::ARBITRATION_SIGNAL,
+                                1,
+                                0);
+        }
+    }
+
+    #[inline]
+    pub fn notify_all(&self) {
+        unsafe {
+            let lock = self.lock.get();
+
+            if *lock == ptr::null_mut() {
+                return;
+            }
+
+            let arbiter = ::libctru::__sync_get_arbiter();
+
+            ::libctru::svcArbitrateAddress(arbiter,
+                                *self.lock.get() as u32,
+                                ::libctru::ARBITRATION_SIGNAL,
+                                -1,
+                                0);
+        }
+    }
+
+    #[inline]
+    pub fn wait(&self, mutex: &Mutex) {
+        unsafe {
+            let lock = self.lock.get();
+
+            if *lock != mutex::raw(mutex) as *mut i32 {
+                if *lock != ptr::null_mut() {
+                    panic!("Condvar used with more than one Mutex");
+                }
+
+                atomic_cxchg(lock as *mut usize, 0, mutex::raw(mutex) as usize);
+            }
+
+            mutex.unlock();
+
+            let arbiter = ::libctru::__sync_get_arbiter();
+
+            ::libctru::svcArbitrateAddress(arbiter,
+                                *self.lock.get() as u32,
+                                ::libctru::ARBITRATION_WAIT_IF_LESS_THAN,
+                                2,
+                                0);
+
+            mutex.lock();
+        }
+    }
+
+    #[inline]
+    pub fn wait_timeout(&self, mutex: &Mutex, dur: Duration) -> bool {
+        use time::Instant;
+
+        unsafe {
+            let lock = self.lock.get();
+
+            if *lock != mutex::raw(mutex) as *mut i32 {
+                if *lock != ptr::null_mut() {
+                    panic!("Condvar used with more than one Mutex");
+                }
+
+                atomic_cxchg(lock as *mut usize, 0, mutex::raw(mutex) as usize);
+            }
+
+            let now = Instant::now();
+
+            let nanos = dur.as_secs()
+                           .saturating_mul(1_000_000_000)
+                           .saturating_add(dur.subsec_nanos() as u64);
+
+            mutex.unlock();
+
+            let arbiter = ::libctru::__sync_get_arbiter();
+
+            ::libctru::svcArbitrateAddress(arbiter,
+                                *self.lock.get() as u32,
+                                ::libctru::ARBITRATION_WAIT_IF_LESS_THAN_TIMEOUT,
+                                2,
+                                nanos as i64);
+
+            mutex.lock();
+
+            now.elapsed() < dur
+        }
+    }
+
+    #[inline]
+    pub unsafe fn destroy(&self) {
+        *self.lock.get() = ptr::null_mut();
+    }
+}
+\ No newline at end of file