Merge pull request #693 from GuillaumeGomez/duration-for-milliseconds

Use Duration instead of u32 when representing milliseconds

Author: GuillaumeGomez

src/source.rs

@@ -10,6 +10,7 @@ use std::mem::transmute;
 use std::num::NonZeroU32;
 #[cfg(unix)]
 use std::os::unix::io::RawFd;
+use std::time::Duration;
 use translate::{from_glib, from_glib_full, FromGlib, ToGlib, ToGlibPtr};
 #[cfg(any(unix, feature = "dox"))]
 use IOCondition;
@@ -197,14 +198,14 @@ where
 ///
 /// The default main loop almost always is the main loop of the main thread.
 /// Thus the closure is called on the main thread.
-pub fn timeout_add<F>(interval: u32, func: F) -> SourceId
+pub fn timeout_add<F>(interval: Duration, func: F) -> SourceId
 where
     F: FnMut() -> Continue + Send + 'static,
 {
     unsafe {
         from_glib(glib_sys::g_timeout_add_full(
             glib_sys::G_PRIORITY_DEFAULT,
-            interval,
+            interval.as_millis() as _,
             Some(trampoline::<F>),
             into_raw(func),
             Some(destroy_closure::<F>),
@@ -228,15 +229,15 @@ where
 ///
 /// This function panics if called from a different thread than the one that
 /// owns the main context.
-pub fn timeout_add_local<F>(interval: u32, func: F) -> SourceId
+pub fn timeout_add_local<F>(interval: Duration, func: F) -> SourceId
 where
     F: FnMut() -> Continue + 'static,
 {
     unsafe {
         assert!(MainContext::default().is_owner());
         from_glib(glib_sys::g_timeout_add_full(
             glib_sys::G_PRIORITY_DEFAULT,
-            interval,
+            interval.as_millis() as _,
             Some(trampoline::<F>),
             into_raw(func),
             Some(destroy_closure::<F>),
@@ -536,7 +537,7 @@ where
 /// be delayed by other events. Prefer `timeout_add_seconds` when millisecond
 /// precision is not necessary.
 pub fn timeout_source_new<F>(
-    interval: u32,
+    interval: Duration,
     name: Option<&str>,
     priority: Priority,
     func: F,
@@ -545,7 +546,7 @@ where
     F: FnMut() -> Continue + Send + 'static,
 {
     unsafe {
-        let source = glib_sys::g_timeout_source_new(interval);
+        let source = glib_sys::g_timeout_source_new(interval.as_millis() as _);
         glib_sys::g_source_set_callback(
             source,
             Some(trampoline::<F>),

src/source_futures.rs

@@ -12,6 +12,7 @@ use futures_util::stream::StreamExt;
 use std::marker::Unpin;
 use std::pin;
 use std::pin::Pin;
+use std::time::Duration;
 
 use Continue;
 use MainContext;
@@ -108,7 +109,7 @@ impl<T, F> Drop for SourceFuture<T, F> {
 /// Create a `Future` that will resolve after the given number of milliseconds.
 ///
 /// The `Future` must be spawned on an `Executor` backed by a `glib::MainContext`.
-pub fn timeout_future(value: u32) -> Pin<Box<dyn Future<Output = ()> + Send + 'static>> {
+pub fn timeout_future(value: Duration) -> Pin<Box<dyn Future<Output = ()> + Send + 'static>> {
     timeout_future_with_priority(::PRIORITY_DEFAULT, value)
 }
 
@@ -117,7 +118,7 @@ pub fn timeout_future(value: u32) -> Pin<Box<dyn Future<Output = ()> + Send + 's
 /// The `Future` must be spawned on an `Executor` backed by a `glib::MainContext`.
 pub fn timeout_future_with_priority(
     priority: Priority,
-    value: u32,
+    value: Duration,
 ) -> Pin<Box<dyn Future<Output = ()> + Send + 'static>> {
     Box::pin(SourceFuture::new(move |send| {
         let mut send = Some(send);
@@ -295,7 +296,7 @@ impl<T, F> Drop for SourceStream<T, F> {
 /// Create a `Stream` that will provide a value every given number of milliseconds.
 ///
 /// The `Future` must be spawned on an `Executor` backed by a `glib::MainContext`.
-pub fn interval_stream(value: u32) -> Pin<Box<dyn Stream<Item = ()> + Send + 'static>> {
+pub fn interval_stream(value: Duration) -> Pin<Box<dyn Stream<Item = ()> + Send + 'static>> {
     interval_stream_with_priority(::PRIORITY_DEFAULT, value)
 }
 
@@ -304,7 +305,7 @@ pub fn interval_stream(value: u32) -> Pin<Box<dyn Stream<Item = ()> + Send + 'st
 /// The `Future` must be spawned on an `Executor` backed by a `glib::MainContext`.
 pub fn interval_stream_with_priority(
     priority: Priority,
-    value: u32,
+    value: Duration,
 ) -> Pin<Box<dyn Stream<Item = ()> + Send + 'static>> {
     Box::pin(SourceStream::new(move |send| {
         ::timeout_source_new(value, None, priority, move || {
@@ -372,13 +373,14 @@ pub fn unix_signal_stream_with_priority(
 #[cfg(test)]
 mod tests {
     use super::*;
+    use std::time::Duration;
     use std::thread;
 
     #[test]
     fn test_timeout() {
         let c = MainContext::new();
 
-        c.block_on(timeout_future(20));
+        c.block_on(timeout_future(Duration::from_millis(20)));
     }
 
     #[test]
@@ -387,7 +389,7 @@ mod tests {
         let l = ::MainLoop::new(Some(&c), false);
 
         let l_clone = l.clone();
-        c.spawn(timeout_future(20).then(move |()| {
+        c.spawn(timeout_future(Duration::from_millis(20)).then(move |()| {
             l_clone.quit();
             futures_util::future::ready(())
         }));
@@ -404,7 +406,7 @@ mod tests {
         {
             let count = &mut count;
             c.block_on(
-                interval_stream(20)
+                interval_stream(Duration::from_millis(20))
                     .take(2)
                     .for_each(|()| {
                         *count += 1;
@@ -422,7 +424,7 @@ mod tests {
     fn test_timeout_and_channel() {
         let c = MainContext::default();
 
-        let res = c.block_on(timeout_future(20).then(|()| {
+        let res = c.block_on(timeout_future(Duration::from_millis(20)).then(|()| {
             let (sender, receiver) = oneshot::channel();
 
             thread::spawn(move || {