sleep-utils 0.2.0

Smart sleep utilities with flexible input formats and automatic zero-value handling
Documentation

sleep-utils

Crates.io Documentation License

A smart sleep utilities library for Rust with flexible input formats and automatic zero-value handling.

Features

  • 🕒 Multiple input formats: numbers, text, Duration
  • 🚫 Automatic zero/negative handling: no sleep for zero or negative values
  • 📏 Multiple time units: milliseconds, seconds, minutes
  • 💻 Platform-compatible: uses isize for cross-platform support
  • ⚡ High-performance: optimized regex parsing
  • 🎯 Smart parsing: intuitive duration string parsing

Installation

Add this to your Cargo.toml:

[dependencies]

sleep-utils = "0.1"

Quick Start

use sleep_utils::smart_sleep;
use std::time::Duration;

// Various input formats
smart_sleep(100).unwrap();           // 100 milliseconds
smart_sleep("200ms").unwrap();       // 200 milliseconds
smart_sleep("1.5s").unwrap();        // 1.5 seconds
smart_sleep("2 seconds").unwrap();   // 2 seconds
smart_sleep(0).unwrap();             // no sleep
smart_sleep(-50).unwrap();           // no sleep
smart_sleep(Duration::from_secs(1)).unwrap(); // 1 second

Supported Formats

Numbers (treated as milliseconds)

  • 100 → 100ms
  • 500 → 500ms
  • 0 → no sleep
  • -100 → no sleep

Text with Units

  • "100ms", "100 millis", "100 milliseconds"
  • "1s", "1 sec", "1 second", "1 seconds"
  • "1.5s", "1.5 seconds" → 1500ms
  • "2m", "2 min", "2 minutes" → 120,000ms

Duration Objects

  • Duration::from_millis(100)
  • Duration::from_secs(1)

API Reference

Main Functions

smart_sleep<S: Into<SleepInput>>(input: S) -> Result<()>

The primary function that accepts various input formats and performs sleep if needed.

parse_sleep_duration(input: &str) -> Result<Duration>

Parses a duration string into a Duration object.

sleep(duration: Duration) -> Result<()>

Standard sleep function for backward compatibility.

Enum SleepInput

Represents different types of sleep inputs:

  • Number(isize)
  • Text(String)
  • Duration(Duration)

Examples

Basic Usage

use sleep_utils::smart_sleep;

// Sleep for 100ms
smart_sleep(100).unwrap();

// Sleep for 2 seconds
smart_sleep("2s").unwrap();

// No sleep (zero value)
smart_sleep(0).unwrap();

// No sleep (negative value)
smart_sleep(-100).unwrap();

Advanced Parsing

use sleep_utils::parse_sleep_duration;

let duration = parse_sleep_duration("1.5 minutes").unwrap();
println!("Duration: {:?}", duration); // 90 seconds

Custom Sleep Logic

use sleep_utils::{SleepInput, parse_sleep_duration};

let input = SleepInput::from("500ms");
if input.should_sleep() {
    let duration = input.to_duration().unwrap();
    // Custom sleep logic
    std::thread::sleep(duration);
}

Error Handling

The library uses a custom Result<T> type and SleepError enum for error handling:

use sleep_utils::{SleepError, Result};

match smart_sleep("invalid") {
    Ok(()) => println!("Sleep completed"),
    Err(SleepError::InvalidDuration(msg)) => println!("Invalid duration: {}", msg),
    Err(e) => println!("Other error: {}", e),
}

Features

  • default (enabled by default): All features enabled
  • minimal: Minimal feature set without complex parsing

Performance

The library uses lazy static regex patterns for efficient parsing and avoids unnecessary allocations.

License

Dual-licensed under:

Contributing

Contributions are welcome! Please feel free to submit pull requests or open issues on GitHub.

Changelog

See CHANGELOG.md for version history and changes.