smol readablity changes

Cargo.toml

@@ -17,6 +17,7 @@ log = "0.4.6"
 fern = { version = "0.6", features = [] }
 fnv = "1.0.7"
 snafu = "0.8.0"
+durr = "2"
 
 [profile.release]
-lto = true
+lto = true

src/amx_arguments.rs

@@ -29,6 +29,7 @@ impl<'amx> StackedCallback<'amx> {
     /// the scheduling store(s) e.g. `TIMERS` and `QUEUE`.
     /// To avoid aliasing, there MUST NOT be any
     /// active references to them when this is called.
+    #[inline]
     pub unsafe fn execute(self) -> Result<i32, AmxError> {
         self.amx.exec(self.callback_idx)
     }

src/lib.rs

@@ -1,8 +1,8 @@
 #![warn(clippy::pedantic)]
 use amx_arguments::VariadicAmxArguments;
 
+use durr::{now, Durr};
 use log::{error, info};
-
 use samp::amx::Amx;
 use samp::cell::AmxString;
 use samp::error::{AmxError, AmxResult};
@@ -34,13 +34,13 @@ impl PreciseTimers {
     #[samp::native(raw, name = "SetPreciseTimer")]
     pub fn create(&self, amx: &Amx, mut args: samp::args::Args) -> AmxResult<i32> {
         // Get the basic, mandatory timer parameters
-        let callback_name = args.next::<AmxString>().ok_or(AmxError::Params)?;
+        let callback_name: AmxString = args.next().ok_or(AmxError::Params)?;
         let interval = args
-            .next::<i32>()
-            .and_then(|ms| u64::try_from(ms).ok())
-            .ok_or(AmxError::Params)
-            .map(Duration::from_millis)?;
-        let repeat = args.next::<bool>().ok_or(AmxError::Params)?;
+            .next()
+            .and_then(|ms: i32| u64::try_from(ms).ok())
+            .ok_or(AmxError::Params)?
+            .milliseconds();
+        let repeat: bool = args.next().ok_or(AmxError::Params)?;
         let passed_arguments = VariadicAmxArguments::from_amx_args::<3>(args)?;
 
         let timer = Timer {
@@ -50,7 +50,7 @@ impl PreciseTimers {
         };
         let key = insert_and_schedule_timer(timer, |key| Schedule {
             key,
-            next_trigger: Instant::now() + interval,
+            next_trigger: now() + interval,
             repeat: if repeat { Every(interval) } else { DontRepeat },
         });
         // The timer's slot in Slab<> incresed by 1, so that 0 signifies an invalid timer in PAWN
@@ -91,12 +91,12 @@ impl PreciseTimers {
     ) -> AmxResult<i32> {
         let key = timer_number - 1;
         let interval = u64::try_from(interval)
-            .map_err(|_| AmxError::Params)
-            .map(Duration::from_millis)?;
+            .map_err(|_| AmxError::Params)?
+            .milliseconds();
 
         let schedule = Schedule {
             key,
-            next_trigger: Instant::now() + interval,
+            next_trigger: now() + interval,
             repeat: if repeat { Every(interval) } else { DontRepeat },
         };
         if let Err(error) = reschedule_timer(key, schedule) {
@@ -119,7 +119,7 @@ impl SampPlugin for PreciseTimers {
     #[allow(clippy::inline_always)]
     #[inline(always)]
     fn process_tick(&self) {
-        let now = Instant::now();
+        let now = now();
 
         while let Some(callback) = reschedule_next_due_and_then(now, Timer::stack_callback_on_amx) {
             match callback {

src/scheduling.rs

@@ -133,13 +133,14 @@ pub(crate) fn reschedule_next_due_and_then<T>(
 mod test {
     use std::ptr::null_mut;
 
+    use durr::{now, Durr};
     use samp::raw::types::AMX;
 
     use crate::schedule::Repeat::{DontRepeat, Every};
     use crate::scheduling::{State, STATE};
     use crate::Timer;
     use crate::{amx_arguments::VariadicAmxArguments, scheduling::reschedule_next_due_and_then};
-    use std::time::{Duration, Instant};
+    use std::time::Instant;
 
     use super::{insert_and_schedule_timer, Schedule};
 
@@ -157,15 +158,15 @@ mod test {
     fn every_1s(key: usize) -> Schedule {
         Schedule {
             key,
-            next_trigger: Instant::now() + Duration::from_secs(key as u64),
-            repeat: Every(Duration::from_secs(1)),
+            next_trigger: now() + (key as u64).seconds(),
+            repeat: Every(1.seconds()),
         }
     }
 
     fn dont_repeat(key: usize) -> Schedule {
         Schedule {
             key,
-            next_trigger: Instant::now() + Duration::from_secs(key as u64),
+            next_trigger: now() + (key as u64).seconds(),
             repeat: DontRepeat,
         }
     }
@@ -177,18 +178,18 @@ mod test {
 
     #[test]
     fn hello() {
-        assert_eq!(reschedule_next_due_and_then(Instant::now(), noop), None);
+        assert_eq!(reschedule_next_due_and_then(now(), noop), None);
         let first = insert_and_schedule_timer(empty_timer(), every_1s);
         let second = insert_and_schedule_timer(empty_timer(), every_1s);
         let third = insert_and_schedule_timer(empty_timer(), every_1s);
         let fourth = insert_and_schedule_timer(empty_timer(), dont_repeat);
         STATE.with_borrow_mut(|&mut State { ref mut queue, .. }| {
             assert_eq!(timer_keys(queue), [fourth, third, second, first]);
         });
-        assert!(reschedule_next_due_and_then(Instant::now(), noop).is_some());
+        assert!(reschedule_next_due_and_then(now(), noop).is_some());
         STATE.with_borrow_mut(|&mut State { ref mut queue, .. }| {
             assert_eq!(timer_keys(queue), [fourth, third, first, second]);
         });
-        assert_eq!(reschedule_next_due_and_then(Instant::now(), noop), None);
+        assert_eq!(reschedule_next_due_and_then(now(), noop), None);
     }
 }

src/timer.rs

@@ -1,7 +1,7 @@
 use crate::amx_arguments::{StackedCallback, VariadicAmxArguments};
 
 use samp::{
-    amx::{Amx, AmxIdent},
+    amx::{self, Amx, AmxIdent},
     consts::AmxExecIdx,
     error::AmxError,
 };
@@ -15,13 +15,13 @@ pub(crate) struct Timer {
 }
 
 impl Timer {
-    pub fn was_scheduled_by_amx(&self, amx: &samp::amx::Amx) -> bool {
+    pub fn was_scheduled_by_amx(&self, amx: &amx::Amx) -> bool {
         self.amx_identifier == AmxIdent::from(amx.amx().as_ptr())
     }
 
     pub fn stack_callback_on_amx<'amx>(&self) -> Result<StackedCallback<'amx>, AmxError> {
         // amx::get returns an invalid amx lifetime
-        let amx: &'amx Amx = samp::amx::get(self.amx_identifier).ok_or(AmxError::NotFound)?;
+        let amx: &'amx Amx = amx::get(self.amx_identifier).ok_or(AmxError::NotFound)?;
         self.passed_arguments
             .push_onto_amx_stack(amx, self.amx_callback_index)
     }