Delete ctr-std to use my fork of the rust repo instead

1 files changed, 0 insertions, 247 deletions

diff --git a/ctr-std/src/sys_common/remutex.rs b/ctr-std/src/sys_common/remutex.rs
deleted file mode 100644
index 071a3a2..0000000
--- a/ctr-std/src/sys_common/remutex.rs
+++ /dev/null
@@ -1,247 +0,0 @@
-// Copyright 2015 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.
-
-use fmt;
-use marker;
-use ops::Deref;
-use sys_common::poison::{self, TryLockError, TryLockResult, LockResult};
-use sys::mutex as sys;
-use panic::{UnwindSafe, RefUnwindSafe};
-
-/// A re-entrant mutual exclusion
-///
-/// This mutex will block *other* threads waiting for the lock to become
-/// available. The thread which has already locked the mutex can lock it
-/// multiple times without blocking, preventing a common source of deadlocks.
-pub struct ReentrantMutex<T> {
-    inner: Box<sys::ReentrantMutex>,
-    poison: poison::Flag,
-    data: T,
-}
-
-unsafe impl<T: Send> Send for ReentrantMutex<T> {}
-unsafe impl<T: Send> Sync for ReentrantMutex<T> {}
-
-impl<T> UnwindSafe for ReentrantMutex<T> {}
-impl<T> RefUnwindSafe for ReentrantMutex<T> {}
-
-
-/// An RAII implementation of a "scoped lock" of a mutex. When this structure is
-/// dropped (falls out of scope), the lock will be unlocked.
-///
-/// The data protected by the mutex can be accessed through this guard via its
-/// Deref implementation.
-///
-/// # Mutability
-///
-/// Unlike `MutexGuard`, `ReentrantMutexGuard` does not implement `DerefMut`,
-/// because implementation of the trait would violate Rust’s reference aliasing
-/// rules. Use interior mutability (usually `RefCell`) in order to mutate the
-/// guarded data.
-#[must_use = "if unused the ReentrantMutex will immediately unlock"]
-pub struct ReentrantMutexGuard<'a, T: 'a> {
-    // funny underscores due to how Deref currently works (it disregards field
-    // privacy).
-    __lock: &'a ReentrantMutex<T>,
-    __poison: poison::Guard,
-}
-
-impl<'a, T> !marker::Send for ReentrantMutexGuard<'a, T> {}
-
-
-impl<T> ReentrantMutex<T> {
-    /// Creates a new reentrant mutex in an unlocked state.
-    pub fn new(t: T) -> ReentrantMutex<T> {
-        unsafe {
-            let mut mutex = ReentrantMutex {
-                inner: box sys::ReentrantMutex::uninitialized(),
-                poison: poison::Flag::new(),
-                data: t,
-            };
-            mutex.inner.init();
-            mutex
-        }
-    }
-
-    /// Acquires a mutex, blocking the current thread until it is able to do so.
-    ///
-    /// This function will block the caller until it is available to acquire the mutex.
-    /// Upon returning, the thread is the only thread with the mutex held. When the thread
-    /// calling this method already holds the lock, the call shall succeed without
-    /// blocking.
-    ///
-    /// # Errors
-    ///
-    /// If another user of this mutex panicked while holding the mutex, then
-    /// this call will return failure if the mutex would otherwise be
-    /// acquired.
-    pub fn lock(&self) -> LockResult<ReentrantMutexGuard<T>> {
-        unsafe { self.inner.lock() }
-        ReentrantMutexGuard::new(&self)
-    }
-
-    /// Attempts to acquire this lock.
-    ///
-    /// If the lock could not be acquired at this time, then `Err` is returned.
-    /// Otherwise, an RAII guard is returned.
-    ///
-    /// This function does not block.
-    ///
-    /// # Errors
-    ///
-    /// If another user of this mutex panicked while holding the mutex, then
-    /// this call will return failure if the mutex would otherwise be
-    /// acquired.
-    pub fn try_lock(&self) -> TryLockResult<ReentrantMutexGuard<T>> {
-        if unsafe { self.inner.try_lock() } {
-            Ok(ReentrantMutexGuard::new(&self)?)
-        } else {
-            Err(TryLockError::WouldBlock)
-        }
-    }
-}
-
-impl<T> Drop for ReentrantMutex<T> {
-    fn drop(&mut self) {
-        // This is actually safe b/c we know that there is no further usage of
-        // this mutex (it's up to the user to arrange for a mutex to get
-        // dropped, that's not our job)
-        unsafe { self.inner.destroy() }
-    }
-}
-
-impl<T: fmt::Debug + 'static> fmt::Debug for ReentrantMutex<T> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match self.try_lock() {
-            Ok(guard) => f.debug_struct("ReentrantMutex").field("data", &*guard).finish(),
-            Err(TryLockError::Poisoned(err)) => {
-                f.debug_struct("ReentrantMutex").field("data", &**err.get_ref()).finish()
-            },
-            Err(TryLockError::WouldBlock) => {
-                struct LockedPlaceholder;
-                impl fmt::Debug for LockedPlaceholder {
-                    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { f.write_str("<locked>") }
-                }
-
-                f.debug_struct("ReentrantMutex").field("data", &LockedPlaceholder).finish()
-            }
-        }
-    }
-}
-
-impl<'mutex, T> ReentrantMutexGuard<'mutex, T> {
-    fn new(lock: &'mutex ReentrantMutex<T>)
-            -> LockResult<ReentrantMutexGuard<'mutex, T>> {
-        poison::map_result(lock.poison.borrow(), |guard| {
-            ReentrantMutexGuard {
-                __lock: lock,
-                __poison: guard,
-            }
-        })
-    }
-}
-
-impl<'mutex, T> Deref for ReentrantMutexGuard<'mutex, T> {
-    type Target = T;
-
-    fn deref(&self) -> &T {
-        &self.__lock.data
-    }
-}
-
-impl<'a, T> Drop for ReentrantMutexGuard<'a, T> {
-    #[inline]
-    fn drop(&mut self) {
-        unsafe {
-            self.__lock.poison.done(&self.__poison);
-            self.__lock.inner.unlock();
-        }
-    }
-}
-
-
-#[cfg(all(test, not(target_os = "emscripten")))]
-mod tests {
-    use sys_common::remutex::{ReentrantMutex, ReentrantMutexGuard};
-    use cell::RefCell;
-    use sync::Arc;
-    use thread;
-
-    #[test]
-    fn smoke() {
-        let m = ReentrantMutex::new(());
-        {
-            let a = m.lock().unwrap();
-            {
-                let b = m.lock().unwrap();
-                {
-                    let c = m.lock().unwrap();
-                    assert_eq!(*c, ());
-                }
-                assert_eq!(*b, ());
-            }
-            assert_eq!(*a, ());
-        }
-    }
-
-    #[test]
-    fn is_mutex() {
-        let m = Arc::new(ReentrantMutex::new(RefCell::new(0)));
-        let m2 = m.clone();
-        let lock = m.lock().unwrap();
-        let child = thread::spawn(move || {
-            let lock = m2.lock().unwrap();
-            assert_eq!(*lock.borrow(), 4950);
-        });
-        for i in 0..100 {
-            let lock = m.lock().unwrap();
-            *lock.borrow_mut() += i;
-        }
-        drop(lock);
-        child.join().unwrap();
-    }
-
-    #[test]
-    fn trylock_works() {
-        let m = Arc::new(ReentrantMutex::new(()));
-        let m2 = m.clone();
-        let _lock = m.try_lock().unwrap();
-        let _lock2 = m.try_lock().unwrap();
-        thread::spawn(move || {
-            let lock = m2.try_lock();
-            assert!(lock.is_err());
-        }).join().unwrap();
-        let _lock3 = m.try_lock().unwrap();
-    }
-
-    pub struct Answer<'a>(pub ReentrantMutexGuard<'a, RefCell<u32>>);
-    impl<'a> Drop for Answer<'a> {
-        fn drop(&mut self) {
-            *self.0.borrow_mut() = 42;
-        }
-    }
-
-    #[test]
-    fn poison_works() {
-        let m = Arc::new(ReentrantMutex::new(RefCell::new(0)));
-        let mc = m.clone();
-        let result = thread::spawn(move ||{
-            let lock = mc.lock().unwrap();
-            *lock.borrow_mut() = 1;
-            let lock2 = mc.lock().unwrap();
-            *lock.borrow_mut() = 2;
-            let _answer = Answer(lock2);
-            panic!("What the answer to my lifetimes dilemma is?");
-        }).join();
-        assert!(result.is_err());
-        let r = m.lock().err().unwrap().into_inner();
-        assert_eq!(*r.borrow(), 42);
-    }
-}