Option index i64, Option bool i32

Author: AlexKnauth

src/runtime/sys.rs

@@ -79,14 +79,18 @@ extern "C" {
     pub fn timer_undo_split();
     /// Resets the timer.
     pub fn timer_reset();
-    /// Accesses the index of the split the attempt is currently on. If there's
-    /// no attempt in progress, `-1` is returned instead. This returns an
-    /// index that is equal to the amount of segments when the attempt is
-    /// finished, but has not been reset. So you need to be careful when using
-    /// this value for indexing.
-    pub fn timer_current_split_index() -> i32;
+    /// Accesses the index of the split the attempt is currently on.
+    /// If there's no attempt in progress, `-1` is returned instead.
+    /// This returns an index that is equal to the amount of segments
+    /// when the attempt is finished, but has not been reset.
+    /// So you need to be careful when using this value for indexing.
+    /// Same index does not imply same split on undo and then split.
+    pub fn timer_current_split_index() -> i64;
     /// Whether the segment at `idx` was splitted this attempt.
-    pub fn timer_segment_splitted(idx: i32) -> bool;
+    /// Returns `1` if the segment was splitted, or `0` if skipped.
+    /// If `idx` is greater than or equal to the current split index,
+    /// `-1` is returned instead.
+    pub fn timer_segment_splitted(idx: u64) -> i32;
     /// Sets a custom key value pair. This may be arbitrary information that the
     /// auto splitter wants to provide for visualization. The pointers need to
     /// point to valid UTF-8 encoded text with the respective given length.

src/runtime/timer.rs

@@ -112,18 +112,31 @@ pub fn state() -> TimerState {
     }
 }
 
-/// Accesses the index of the split the attempt is currently on. If there's
-/// no attempt in progress, `-1` is returned instead. This returns an
-/// index that is equal to the amount of segments when the attempt is
-/// finished, but has not been reset. So you need to be careful when using
-/// this value for indexing.
-pub fn current_split_index() -> i32 {
-    unsafe { sys::timer_current_split_index() }
+/// Accesses the index of the split the attempt is currently on.
+/// If there's no attempt in progress, `None` is returned instead.
+/// This returns an index that is equal to the amount of segments
+/// when the attempt is finished, but has not been reset.
+/// So you need to be careful when using this value for indexing.
+/// Same index does not imply same split on undo and then split.
+pub fn current_split_index() -> Option<u64> {
+    let i = unsafe { sys::timer_current_split_index() };
+    if i.is_negative() {
+        return None;
+    }
+    Some(i as u64)
 }
 
 /// Whether the segment at `idx` was splitted this attempt.
-pub fn segment_splitted(idx: i32) -> bool {
-    unsafe { sys::timer_segment_splitted(idx) }
+/// Returns `Some(true)` if the segment was splitted,
+/// or `Some(false)` if skipped.
+/// If `idx` is greater than or equal to the current split index,
+/// `None` is returned instead.
+pub fn segment_splitted(idx: u64) -> Option<bool> {
+    match unsafe { sys::timer_segment_splitted(idx) } {
+        1 => Some(true),
+        0 => Some(false),
+        _ => None,
+    }
 }
 
 /// Sets the game time.