Added a SuspendGuard struct for suspending queues.

Author: SSheldon

src/lib.rs

@@ -307,6 +307,10 @@ impl Queue {
             dispatch_barrier_async_f(self.ptr, context, work);
         }
     }
+
+    pub fn suspend(&self) -> SuspendGuard {
+        SuspendGuard::new(self)
+    }
 }
 
 unsafe impl Sync for Queue { }
@@ -329,6 +333,35 @@ impl Drop for Queue {
     }
 }
 
+pub struct SuspendGuard {
+    queue: Queue,
+}
+
+impl SuspendGuard {
+    fn new(queue: &Queue) -> SuspendGuard {
+        unsafe {
+            dispatch_suspend(queue.ptr);
+        }
+        SuspendGuard { queue: queue.clone() }
+    }
+
+    pub fn resume(self) { }
+}
+
+impl Clone for SuspendGuard {
+    fn clone(&self) -> Self {
+        SuspendGuard::new(&self.queue)
+    }
+}
+
+impl Drop for SuspendGuard {
+    fn drop(&mut self) {
+        unsafe {
+            dispatch_resume(self.queue.ptr);
+        }
+    }
+}
+
 pub struct Group {
     ptr: dispatch_group_t,
 }
@@ -399,6 +432,14 @@ impl GroupGuard {
         }
         GroupGuard { group: group.clone() }
     }
+
+    pub fn leave(self) { }
+}
+
+impl Clone for GroupGuard {
+    fn clone(&self) -> Self {
+        GroupGuard::new(&self.group)
+    }
 }
 
 impl Drop for GroupGuard {
@@ -542,6 +583,25 @@ mod tests {
         assert!(*num.lock().unwrap() == 12);
     }
 
+    #[test]
+    fn test_suspend() {
+        let q = Queue::create("", QueueAttribute::Serial);
+        let num = Arc::new(Mutex::new(0));
+
+        // Suspend the queue and then dispatch some work to it
+        let guard = q.suspend();
+        async_increment(&q, &num);
+
+        // Sleep and ensure the work doesn't occur
+        ::std::thread::sleep_ms(5);
+        assert!(*num.lock().unwrap() == 0);
+
+        // But ensure the work does complete after we resume
+        guard.resume();
+        q.sync(|| ());
+        assert!(*num.lock().unwrap() == 1);
+    }
+
     #[test]
     fn test_group() {
         let group = Group::create();
@@ -559,7 +619,7 @@ mod tests {
         q.async(move || {
             let mut num = num3.lock().unwrap();
             *num += 1;
-            drop(guard);
+            guard.leave();
         });
 
         let num4 = num.clone();