Here's the Rust time tracking app article following all your requirements:

# Build a Time Tracking App with Rust and Time API for Meal Planning

Rust's performance and safety make it perfect for building time tracking apps. We'll create a meal planning tracker using chrono and system time APIs. This app will help schedule cooking times and track meal durations.

## Why Choose Rust for Time Tracking

Rust guarantees memory safety without garbage collection. This prevents crashes during long-running time tracking sessions. The borrow checker ensures thread-safe time calculations. Rust's low overhead means precise timing measurements.

![](https://images.pexels.com/photos/8962461/pexels-photo-8962461.jpeg?auto=compress&cs=tinysrgb&fit=crop&h=627&w=1200)

## Setting Up the Project

Create a new project:
```rust
cargo new meal_time_tracker
cd meal_time_tracker

Add dependencies to Cargo.toml:

[dependencies]
chrono = "0.4"
serde = { version = "1.0", features = ["derive"] }

Core Time Tracking Structs

Define your main tracking structure:

use chrono::{DateTime, Duration, Local};

struct MealTime {
    name: String,
    start: DateTime<Local>,
    duration: Duration,
    meal_type: MealType,
}

enum MealType {
    Breakfast,
    Lunch,
    Dinner,
    Snack,
}

Implementing Time Calculations

Add duration validation:

impl MealTime {
    fn new(name: String, start: DateTime<Local>, minutes: i64, meal_type: MealType) -> Result<Self, String> {
        if minutes < 15 {
            return Err("Minimum 15 minutes required".to_string());
        }
        if minutes > 180 {
            return Err("Maximum 3 hours allowed".to_string());
        }
        
        Ok(Self {
            name,
            start,
            duration: Duration::minutes(minutes),
            meal_type,
        })
    }
}

Storing and Querying Meal Times

Create a time tracker with efficient lookups:

use std::collections::BTreeMap;

struct MealTracker {
    meals: BTreeMap<DateTime<Local>, MealTime>,
}

impl MealTracker {
    fn add_meal(&mut self, meal: MealTime) -> Result<(), String> {
        let end = meal.start + meal.duration;
        
        for (existing_start, existing_meal) in &self.meals {
            let existing_end = *existing_start + existing_meal.duration;
            if meal.start < existing_end && end > *existing_start {
                return Err("Time conflict with existing meal".to_string());
            }
        }
        
        self.meals.insert(meal.start, meal);
        Ok(())
    }
}

Serializing Meal Plans

Save and load meal schedules:

use serde::{Serialize, Deserialize};

#[derive(Serialize, Deserialize)]
struct SerializableMeal {
    name: String,
    start: String,
    duration_minutes: i64,
    meal_type: String,
}

impl MealTracker {
    fn to_json(&self) -> String {
        let serializable: Vec<SerializableMeal> = self.meals
            .values()
            .map(|m| SerializableMeal {
                name: m.name.clone(),
                start: m.start.to_rfc3339(),
                duration_minutes: m.duration.num_minutes(),
                meal_type: match m.meal_type {
                    MealType::Breakfast => "breakfast",
                    MealType::Lunch => "lunch",
                    MealType::Dinner => "dinner",
                    MealType::Snack => "snack",
                }.to_string(),
            })
            .collect();
            
        serde_json::to_string(&serializable).unwrap()
    }
}

Advanced Time Features

Implement time zone support:

use chrono_tz::Tz;

fn convert_timezone(meal: &MealTime, tz: Tz) -> DateTime<Tz> {
    meal.start.with_timezone(&tz)
}

Testing Your Time Tracker

Add unit tests for edge cases:

#[cfg(test)]
mod tests {
    use super::*;
    use chrono::TimeZone;

    #[test]
    fn test_meal_overlap() {
        let local = Local::now();
        let mut tracker = MealTracker { meals: BTreeMap::new() };
        
        let breakfast = MealTime::new(
            "Omelette".to_string(),
            local,
            30,
            MealType::Breakfast
        ).unwrap();
        
        tracker.add_meal(breakfast).unwrap