Struct SetOptions 

pub struct SetOptions {
    pub ttl: Option<Duration>,
    pub expires_at: Option<SystemTime>,
}

Options for setting values with optional TTL

Fields

ttl: Option<Duration>

Time-to-live for this item

expires_at: Option<SystemTime>

Absolute expiration time (takes precedence over TTL)

Implementations

impl SetOptions

pub fn with_ttl(ttl: Duration) -> Self

Create options with TTL

Examples found in repository

examples/persistence_lifecycle.rs (line 201)

fn demo_graceful_shutdown() -> Result<(), Box<dyn std::error::Error>> {
    println!("--- Demo 4: Graceful Shutdown ---");

    let db_path = "/tmp/spatio_demo_shutdown.db";

    println!("Creating database and inserting critical data...");
    let mut db = Spatio::open(db_path)?;

    // Insert critical data
    db.insert("transaction:001", b"payment_processed", None)?;
    db.insert("transaction:002", b"refund_pending", None)?;

    println!("  ✓ Critical data inserted");

    // Force sync before critical operations
    db.sync()?;
    println!("  ✓ Forced sync to disk");

    // Add TTL data
    let opts = SetOptions::with_ttl(Duration::from_secs(300));
    db.insert("session:xyz", b"temporary_session", Some(opts))?;
    println!("  ✓ Added temporary session with 5-minute TTL");

    // Explicit close with error handling
    println!("Performing explicit graceful shutdown...");
    match db.close() {
        Ok(_) => println!("  ✓ Database closed successfully"),
        Err(e) => {
            eprintln!("  ✗ Error during close: {}", e);
            return Err(e.into());
        }
    }

    // Verify we can't use closed database
    match db.insert("should_fail", b"data", None) {
        Err(e) => println!("  ✓ Correctly rejected operation on closed database: {}", e),
        Ok(_) => println!("  ✗ Unexpectedly accepted operation on closed database"),
    }

    println!();
    Ok(())
}

examples/getting_started.rs (line 21)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("Spatio - Getting Started Example");
    println!("=================================");

    // Create an in-memory database
    let db = Spatio::memory()?;
    println!("Created in-memory database");

    // Basic key-value operations
    db.insert("user:123", b"John Doe", None)?;
    let value = db.get("user:123")?.unwrap();
    println!(
        "Basic storage: user:123 = {}",
        String::from_utf8_lossy(&value)
    );

    // Store data with TTL (time-to-live)
    let ttl_options = SetOptions::with_ttl(Duration::from_secs(5));
    db.insert("session:abc", b"expires_soon", Some(ttl_options))?;
    println!("Stored session data with 5-second TTL");

    // Spatial point operations
    let new_york = Point::new(40.7128, -74.0060);
    let london = Point::new(51.5074, -0.1278);
    let tokyo = Point::new(35.6762, 139.6503);

    // Store geographic points (automatically indexed for spatial queries)
    db.insert_point("cities", &new_york, b"New York", None)?;
    db.insert_point("cities", &london, b"London", None)?;
    db.insert_point("cities", &tokyo, b"Tokyo", None)?;
    println!("Stored geographic points for major cities");

    // Calculate distance between cities
    let distance_km = new_york.distance_to(&london) / 1000.0;
    println!("Distance NYC ↔ London: {:.0} km", distance_km);

    // Find nearby cities (within 2000km of NYC)
    let nearby = db.find_nearby("cities", &new_york, 2_000_000.0, 5)?;
    println!("Found {} cities within 2000km of NYC", nearby.len());
    for (point, data) in &nearby {
        println!(
            "  - {} at ({:.2}, {:.2})",
            String::from_utf8_lossy(data),
            point.lat,
            point.lon
        );
    }

    // Atomic batch operations
    db.atomic(|batch| {
        batch.insert("sensor:temperature", b"22.5C", None)?;
        batch.insert("sensor:humidity", b"65%", None)?;
        batch.insert("sensor:pressure", b"1013.25 hPa", None)?;
        Ok(())
    })?;
    println!("Performed atomic batch insert of sensor data");

    // Trajectory tracking example
    let vehicle_path = vec![
        (Point::new(40.7128, -74.0060), 1640995200), // Start: NYC
        (Point::new(40.7150, -74.0040), 1640995260), // 1 minute later
        (Point::new(40.7172, -74.0020), 1640995320), // 2 minutes later
        (Point::new(40.7194, -74.0000), 1640995380), // 3 minutes later
    ];

    db.insert_trajectory("vehicle:truck001", &vehicle_path, None)?;
    println!(
        "Stored vehicle trajectory with {} waypoints",
        vehicle_path.len()
    );

    // Query trajectory for a time range
    let path_segment = db.query_trajectory("vehicle:truck001", 1640995200, 1640995320)?;
    println!(
        "Retrieved {} waypoints for first 2 minutes",
        path_segment.len()
    );

    // Check database statistics
    let stats = db.stats()?;
    println!("Database contains {} keys", stats.key_count);

    // Wait a moment to see TTL in action
    println!("\nWaiting 6 seconds to demonstrate TTL...");
    std::thread::sleep(Duration::from_secs(6));

    // Try to retrieve expired data
    match db.get("session:abc")? {
        Some(_) => println!("TTL data still exists (unexpected)"),
        None => println!("TTL data expired as expected"),
    }

    println!("\nGetting started example completed successfully!");
    println!("\nKey features demonstrated:");
    println!("- Simple key-value storage");
    println!("- Automatic spatial indexing for points");
    println!("- Nearby point queries");
    println!("- Trajectory tracking over time");
    println!("- TTL (time-to-live) support");
    println!("- Atomic batch operations");

    println!("\nNext steps:");
    println!("- Try the 'spatial_queries' example for more spatial operations");
    println!("- See 'trajectory_tracking' for advanced movement analysis");

    Ok(())
}

examples/comprehensive_demo.rs (line 28)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("Spatio - Comprehensive Demo");
    println!("===========================");

    // Create an in-memory database
    let db = Spatio::memory()?;
    println!("Created in-memory database");

    // === BASIC KEY-VALUE OPERATIONS ===
    println!("\nBasic Key-Value Operations");

    // Simple string storage
    db.insert("app:name", b"Spatio Demo App", None)?;
    db.insert("app:version", b"1.0.0", None)?;
    db.insert("app:author", b"Spatio Team", None)?;

    // Retrieve and display
    let app_name = db.get("app:name")?.unwrap();
    println!("  App: {}", String::from_utf8_lossy(&app_name));

    // === TTL (TIME-TO-LIVE) OPERATIONS ===
    println!("\nTTL (Time-to-Live) Operations");

    // Short-lived session data
    let session_opts = SetOptions::with_ttl(Duration::from_secs(10));
    db.insert("session:user123", b"active", Some(session_opts))?;
    println!("  Created session with 10-second TTL");

    // Cache data with different TTL
    let cache_opts = SetOptions::with_ttl(Duration::from_secs(300)); // 5 minutes
    db.insert("cache:weather", b"sunny, 22C", Some(cache_opts.clone()))?;
    db.insert(
        "cache:news",
        b"Latest tech news...",
        Some(cache_opts.clone()),
    )?;
    println!("  Cached data with 5-minute TTL");

    // === ATOMIC BATCH OPERATIONS ===
    println!("\nAtomic Batch Operations");

    // User profile creation (all-or-nothing)
    db.atomic(|batch| {
        batch.insert("user:123:name", b"Alice Johnson", None)?;
        batch.insert("user:123:email", b"alice@example.com", None)?;
        batch.insert("user:123:role", b"admin", None)?;
        batch.insert("user:123:created", b"2024-01-01", None)?;
        Ok(())
    })?;
    println!("  Created user profile atomically");

    // Sensor data batch insert
    db.atomic(|batch| {
        batch.insert("sensor:temp", b"23.5", None)?;
        batch.insert("sensor:humidity", b"68", None)?;
        batch.insert("sensor:pressure", b"1013.2", None)?;
        batch.insert("sensor:timestamp", b"1640995200", None)?;
        Ok(())
    })?;
    println!("  Recorded sensor readings atomically");

    // === SPATIAL POINT OPERATIONS ===
    println!("\nSpatial Point Operations");

    // Major world cities
    let cities = vec![
        ("New York", Point::new(40.7128, -74.0060)),
        ("London", Point::new(51.5074, -0.1278)),
        ("Tokyo", Point::new(35.6762, 139.6503)),
        ("Paris", Point::new(48.8566, 2.3522)),
        ("Sydney", Point::new(-33.8688, 151.2093)),
        ("São Paulo", Point::new(-23.5505, -46.6333)),
        ("Mumbai", Point::new(19.0760, 72.8777)),
        ("Cairo", Point::new(30.0444, 31.2357)),
    ];

    // Insert cities with automatic spatial indexing
    for (name, point) in &cities {
        db.insert_point("cities", point, name.as_bytes(), None)?;
    }
    println!(
        "  Added {} cities with automatic spatial indexing",
        cities.len()
    );

    // Calculate distances between cities
    let london = Point::new(51.5074, -0.1278);
    let paris = Point::new(48.8566, 2.3522);
    let distance_km = london.distance_to(&paris) / 1000.0;
    println!("  London ↔ Paris: {:.0} km", distance_km);

    // Find cities near London (within 1000km)
    let nearby_london = db.find_nearby("cities", &london, 1_000_000.0, 5)?;
    println!("  Cities within 1000km of London:");
    for (point, data) in &nearby_london {
        let city_name = String::from_utf8_lossy(data);
        let distance = london.distance_to(point) / 1000.0;
        println!("    - {} ({:.0} km)", city_name, distance);
    }

    // === RESTAURANT/POI DATA ===
    println!("\nPoints of Interest");

    let london_restaurants = vec![
        ("The Shard Restaurant", Point::new(51.5045, -0.0865)),
        ("Sketch", Point::new(51.5115, -0.1442)),
        ("Dishoom", Point::new(51.5145, -0.1270)),
        ("Borough Market", Point::new(51.5055, -0.0931)),
    ];

    for (name, point) in &london_restaurants {
        db.insert_point("london_food", point, name.as_bytes(), None)?;
    }
    println!("  Added {} London restaurants", london_restaurants.len());

    // Find restaurants near a specific location (Covent Garden)
    let covent_garden = Point::new(51.5118, -0.1226);
    let nearby_food = db.find_nearby("london_food", &covent_garden, 2000.0, 10)?;
    println!("  Restaurants within 2km of Covent Garden:");
    for (point, data) in &nearby_food {
        let restaurant_name = String::from_utf8_lossy(data);
        let distance = covent_garden.distance_to(point);
        println!("    - {} ({:.0}m away)", restaurant_name, distance);
    }

    // === TRAJECTORY TRACKING ===
    println!("\nTrajectory Tracking");

    // Delivery truck route through London
    let delivery_route = vec![
        (Point::new(51.5074, -0.1278), 1640995200), // Start: London center
        (Point::new(51.5055, -0.0931), 1640995260), // Stop 1: Borough Market (1 min)
        (Point::new(51.5045, -0.0865), 1640995320), // Stop 2: The Shard (2 min)
        (Point::new(51.4994, -0.1245), 1640995380), // Stop 3: Big Ben (3 min)
        (Point::new(51.5014, -0.1419), 1640995440), // Stop 4: Buckingham Palace (4 min)
        (Point::new(51.5118, -0.1226), 1640995500), // End: Covent Garden (5 min)
    ];

    db.insert_trajectory("delivery:truck001", &delivery_route, None)?;
    println!(
        "  Stored delivery truck trajectory ({} waypoints)",
        delivery_route.len()
    );

    // Taxi route
    let taxi_route = vec![
        (Point::new(51.4700, -0.4543), 1640995200), // Heathrow Airport
        (Point::new(51.4900, -0.1743), 1640995800), // Kensington (10 min)
        (Point::new(51.5074, -0.1278), 1640996100), // Central London (15 min)
    ];

    db.insert_trajectory("taxi:cab042", &taxi_route, None)?;
    println!("  Stored taxi trajectory ({} waypoints)", taxi_route.len());

    // Query trajectories for specific time ranges
    let truck_morning = db.query_trajectory("delivery:truck001", 1640995200, 1640995380)?;
    println!(
        "  Truck trajectory (first 3 minutes): {} points",
        truck_morning.len()
    );

    let taxi_full = db.query_trajectory("taxi:cab042", 1640995200, 1640996200)?;
    println!("  Full taxi journey: {} points", taxi_full.len());

    // === SENSOR NETWORK SIMULATION ===
    println!("\nIoT Sensor Network");

    // Simulate temperature sensors across London
    let sensors = vec![
        ("sensor001", Point::new(51.5074, -0.1278), "22.5°C"), // Central
        ("sensor002", Point::new(51.5200, -0.1000), "21.8°C"), // North
        ("sensor003", Point::new(51.4900, -0.1500), "23.1°C"), // South
        ("sensor004", Point::new(51.5100, -0.0800), "22.9°C"), // East
        ("sensor005", Point::new(51.5000, -0.1800), "21.5°C"), // West
    ];

    for (sensor_id, point, reading) in &sensors {
        db.insert_point(
            "sensors",
            point,
            format!("{}:{}", sensor_id, reading).as_bytes(),
            None,
        )?;
    }
    println!("  Deployed {} temperature sensors", sensors.len());

    // Find sensors near a specific location
    let monitoring_center = Point::new(51.5100, -0.1200);
    let nearby_sensors = db.find_nearby("sensors", &monitoring_center, 5000.0, 10)?;
    println!("  Sensors within 5km of monitoring center:");
    for (point, data) in &nearby_sensors {
        let sensor_info = String::from_utf8_lossy(data);
        let distance = monitoring_center.distance_to(point);
        println!("    - {} ({:.0}m away)", sensor_info, distance);
    }

    // === REAL-TIME UPDATES ===
    println!("\nReal-time Updates");

    // Simulate updating sensor readings
    db.insert_point(
        "sensors",
        &Point::new(51.5074, -0.1278),
        b"sensor001:24.2C",
        None,
    )?;
    println!("  Updated sensor001 reading");

    // Add new vehicle to tracking
    let bus_route = vec![
        (Point::new(51.5155, -0.0922), 1640995600), // Liverpool Street
        (Point::new(51.5074, -0.1278), 1640995660), // Central London
    ];
    db.insert_trajectory("bus:route25", &bus_route, None)?;
    println!("  Added new bus to tracking system");

    // === DATABASE STATISTICS ===
    println!("\nDatabase Statistics");

    let stats = db.stats()?;
    println!("  Total keys: {}", stats.key_count);
    println!("  Operations performed: {}", stats.operations_count);

    // Count items by namespace
    let mut namespace_counts = std::collections::HashMap::new();
    // This is a simplified count - in practice you'd query by prefix
    namespace_counts.insert("cities", cities.len());
    namespace_counts.insert("restaurants", london_restaurants.len());
    namespace_counts.insert("sensors", sensors.len());
    namespace_counts.insert("trajectories", 3); // truck, taxi, bus

    println!("  Data distribution:");
    for (namespace, count) in &namespace_counts {
        println!("    - {}: {} items", namespace, count);
    }

    // === CLEANUP DEMONSTRATION ===
    println!("\nCleanup & TTL Demo");

    // Check if session has expired (it should have by now)
    if let Some(_session) = db.get("session:user123")? {
        println!("  Session still active");
    } else {
        println!("  Session expired as expected");
    }

    // Delete specific items
    db.delete("app:version")?;
    println!("  Removed app version info");

    // Final statistics
    let final_stats = db.stats()?;
    println!("  Final key count: {}", final_stats.key_count);

    println!("\nComprehensive demo completed successfully!");
    println!("\nFeatures demonstrated:");
    println!("- Key-value storage with TTL");
    println!("- Atomic batch operations");
    println!("- Automatic spatial indexing");
    println!("- Geographic point queries");
    println!("- Distance calculations");
    println!("- Trajectory tracking");
    println!("- Multi-namespace organization");
    println!("- Real-time updates");
    println!("- Data expiration");

    Ok(())
}

examples/trajectory_tracking.rs (line 94)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("Spatio - Trajectory Tracking Example");
    println!("========================================");

    // Create an in-memory database
    let db = Spatio::memory()?;
    println!("Created in-memory database");

    // === VEHICLE TRAJECTORY TRACKING ===
    println!("\n--- Vehicle Trajectory Tracking ---");

    // Simulate a delivery truck route through Manhattan
    let delivery_truck_route = vec![
        (Point::new(40.7128, -74.0060), 1640995200), // Start: Financial District
        (Point::new(40.7180, -74.0020), 1640995260), // Move north
        (Point::new(40.7230, -73.9980), 1640995320), // Continue north
        (Point::new(40.7280, -73.9940), 1640995380), // Midtown approach
        (Point::new(40.7330, -73.9900), 1640995440), // Midtown
        (Point::new(40.7380, -73.9860), 1640995500), // Times Square area
        (Point::new(40.7430, -73.9820), 1640995560), // Continue north
        (Point::new(40.7480, -73.9780), 1640995620), // Central Park area
        (Point::new(40.7530, -73.9740), 1640995680), // Upper West Side
        (Point::new(40.7580, -73.9700), 1640995740), // End: Upper Manhattan
    ];

    db.insert_trajectory("vehicle:truck001", &delivery_truck_route, None)?;
    println!(
        "Inserted delivery truck trajectory with {} waypoints",
        delivery_truck_route.len()
    );

    // Simulate a taxi route with more frequent updates
    let taxi_route = vec![
        (Point::new(40.7484, -73.9857), 1640995200), // Times Square
        (Point::new(40.7490, -73.9850), 1640995210), // 10 seconds later
        (Point::new(40.7496, -73.9843), 1640995220), // Moving northeast
        (Point::new(40.7502, -73.9836), 1640995230), // Continuing
        (Point::new(40.7508, -73.9829), 1640995240), // Heading to Central Park
        (Point::new(40.7514, -73.9822), 1640995250), // Almost there
        (Point::new(40.7520, -73.9815), 1640995260), // At Central Park South
        (Point::new(40.7526, -73.9808), 1640995270), // Into the park area
        (Point::new(40.7532, -73.9801), 1640995280), // Deeper into park
        (Point::new(40.7538, -73.9794), 1640995290), // End point
    ];

    db.insert_trajectory("vehicle:taxi042", &taxi_route, None)?;
    println!(
        "Inserted taxi trajectory with {} high-frequency waypoints",
        taxi_route.len()
    );

    // === DRONE FLIGHT PATH ===
    println!("\n--- Drone Flight Path ---");

    // Simulate a drone surveillance pattern
    let drone_pattern = vec![
        (Point::new(40.7589, -73.9851), 1640995300), // Start: Bryant Park
        (Point::new(40.7600, -73.9851), 1640995330), // North
        (Point::new(40.7600, -73.9840), 1640995360), // East
        (Point::new(40.7589, -73.9840), 1640995390), // South
        (Point::new(40.7589, -73.9851), 1640995420), // Back to start
        (Point::new(40.7600, -73.9851), 1640995450), // Repeat pattern
        (Point::new(40.7600, -73.9840), 1640995480), // East again
        (Point::new(40.7589, -73.9840), 1640995510), // South again
        (Point::new(40.7589, -73.9851), 1640995540), // Complete square
    ];

    db.insert_trajectory("drone:survey001", &drone_pattern, None)?;
    println!(
        "Inserted drone surveillance pattern with {} waypoints",
        drone_pattern.len()
    );

    // === PEDESTRIAN TRACKING ===
    println!("\n--- Pedestrian Tracking ---");

    // Simulate a jogger's route through Central Park
    let jogger_route = vec![
        (Point::new(40.7679, -73.9781), 1640995600), // Enter at 72nd St
        (Point::new(40.7700, -73.9770), 1640995660), // Move into park
        (Point::new(40.7720, -73.9750), 1640995720), // North along path
        (Point::new(40.7740, -73.9730), 1640995780), // Continue north
        (Point::new(40.7760, -73.9710), 1640995840), // Reservoir area
        (Point::new(40.7780, -73.9730), 1640995900), // Around reservoir
        (Point::new(40.7800, -73.9750), 1640995960), // North side
        (Point::new(40.7820, -73.9770), 1640996020), // Continue around
        (Point::new(40.7800, -73.9790), 1640996080), // West side
        (Point::new(40.7780, -73.9810), 1640996140), // Complete loop
    ];

    let ttl_opts = Some(SetOptions::with_ttl(Duration::from_secs(3600))); // 1 hour TTL
    db.insert_trajectory("pedestrian:jogger123", &jogger_route, ttl_opts)?;
    println!(
        "Inserted jogger trajectory with {} waypoints (1-hour TTL)",
        jogger_route.len()
    );

    // === TRAJECTORY QUERIES ===
    println!("\n--- Trajectory Queries ---");

    // Query full trajectories
    let truck_path = db.query_trajectory("vehicle:truck001", 1640995200, 1640995740)?;
    println!("Retrieved truck trajectory: {} points", truck_path.len());

    let taxi_path = db.query_trajectory("vehicle:taxi042", 1640995200, 1640995290)?;
    println!("Retrieved taxi trajectory: {} points", taxi_path.len());

    // Query partial trajectories (time windows)
    let truck_midjourney = db.query_trajectory("vehicle:truck001", 1640995320, 1640995560)?;
    println!(
        "Truck mid-journey segment: {} points",
        truck_midjourney.len()
    );

    let taxi_start = db.query_trajectory("vehicle:taxi042", 1640995200, 1640995240)?;
    println!("Taxi first 40 seconds: {} points", taxi_start.len());

    // === TRAJECTORY ANALYSIS ===
    println!("\n--- Trajectory Analysis ---");

    // Calculate trajectory distances
    println!("Calculating trajectory metrics...");

    // Truck route analysis
    let mut truck_total_distance = 0.0;
    for i in 1..delivery_truck_route.len() {
        let distance = delivery_truck_route[i - 1]
            .0
            .distance_to(&delivery_truck_route[i].0);
        truck_total_distance += distance;
    }
    let truck_duration =
        delivery_truck_route.last().unwrap().1 - delivery_truck_route.first().unwrap().1;
    let truck_avg_speed = (truck_total_distance / truck_duration as f64) * 3.6; // km/h

    println!("Delivery Truck Analysis:");
    println!("  Total distance: {:.2} km", truck_total_distance / 1000.0);
    println!("  Duration: {} seconds", truck_duration);
    println!("  Average speed: {:.1} km/h", truck_avg_speed);

    // Taxi route analysis
    let mut taxi_total_distance = 0.0;
    for i in 1..taxi_route.len() {
        let distance = taxi_route[i - 1].0.distance_to(&taxi_route[i].0);
        taxi_total_distance += distance;
    }
    let taxi_duration = taxi_route.last().unwrap().1 - taxi_route.first().unwrap().1;
    let taxi_avg_speed = (taxi_total_distance / taxi_duration as f64) * 3.6; // km/h

    println!("\nTaxi Analysis:");
    println!("  Total distance: {:.2} km", taxi_total_distance / 1000.0);
    println!("  Duration: {} seconds", taxi_duration);
    println!("  Average speed: {:.1} km/h", taxi_avg_speed);

    // === REAL-TIME TRACKING SIMULATION ===
    println!("\n--- Real-Time Tracking Simulation ---");

    // Simulate a bike messenger with real-time updates
    let current_time = 1640996200u64;
    let bike_positions = [
        Point::new(40.7505, -73.9934), // Start
        Point::new(40.7510, -73.9930), // Moving
        Point::new(40.7515, -73.9926), // Moving
        Point::new(40.7520, -73.9922), // Moving
        Point::new(40.7525, -73.9918), // End
    ];

    for (i, position) in bike_positions.iter().enumerate() {
        let timestamp = current_time + (i as u64 * 30); // 30-second intervals
        let single_point_trajectory = vec![(*position, timestamp)];

        // In real-time, you would append to existing trajectory
        db.insert_trajectory(
            &format!("vehicle:bike007:segment_{}", i),
            &single_point_trajectory,
            Some(SetOptions::with_ttl(Duration::from_secs(1800))), // 30-minute TTL
        )?;
    }
    println!("Inserted real-time bike messenger updates");

    // === GEOFENCING AND ALERTS ===
    println!("\n--- Geofencing and Alerts ---");

    // Define a restricted zone (e.g., around a hospital)
    let restricted_center = Point::new(40.7614, -73.9776); // Near Central Park
    let restricted_radius = 200.0; // 200 meters

    println!("Checking trajectories for geofence violations...");
    println!(
        "Restricted zone: {:.4}°N, {:.4}°E (radius: {}m)",
        restricted_center.lat, restricted_center.lon, restricted_radius
    );

    // Check each trajectory for violations
    let trajectories = [
        ("vehicle:truck001", &delivery_truck_route),
        ("vehicle:taxi042", &taxi_route),
        ("drone:survey001", &drone_pattern),
        ("pedestrian:jogger123", &jogger_route),
    ];

    for (vehicle_id, trajectory) in &trajectories {
        let mut violations = 0;
        for (point, timestamp) in trajectory.iter() {
            let distance = point.distance_to(&restricted_center);
            if distance <= restricted_radius {
                violations += 1;
                if violations == 1 {
                    println!(
                        "WARNING: {} entered restricted zone at timestamp {}",
                        vehicle_id, timestamp
                    );
                }
            }
        }
        if violations == 0 {
            println!("{} stayed outside restricted zone", vehicle_id);
        } else {
            println!(
                "   {} had {} geofence violations total",
                vehicle_id, violations
            );
        }
    }

    // === TRAJECTORY INTERSECTIONS ===
    println!("\n--- Trajectory Intersections ---");

    // Find where vehicles came close to each other
    println!("Analyzing trajectory intersections (within 100m)...");

    let proximity_threshold = 100.0; // meters
    let mut intersections_found = 0;

    for (truck_point, truck_time) in &delivery_truck_route {
        for (taxi_point, taxi_time) in &taxi_route {
            let distance = truck_point.distance_to(taxi_point);
            let time_diff = truck_time.abs_diff(*taxi_time);

            if distance <= proximity_threshold && time_diff <= 60 {
                intersections_found += 1;
                println!(
                    "   Truck and taxi within {:.0}m at times {} and {} ({}s apart)",
                    distance, truck_time, taxi_time, time_diff
                );
            }
        }
    }

    if intersections_found == 0 {
        println!("   No close encounters found between truck and taxi");
    }

    // === DATABASE STATISTICS ===
    println!("\n--- Database Statistics ---");

    let stats = db.stats()?;

    println!("Total database keys: {}", stats.key_count);

    // Note: In a real application, you could track trajectory keys separately
    println!("Trajectory-related operations completed successfully");

    println!("\nTrajectory tracking example completed successfully!");
    println!("\nKey capabilities demonstrated:");
    println!("- Multi-vehicle trajectory storage and retrieval");
    println!("- Time-windowed trajectory queries");
    println!("- Real-time position updates with TTL");
    println!("- Trajectory analysis (distance, speed, duration)");
    println!("- Geofencing and violation detection");
    println!("- Trajectory intersection analysis");
    println!("- Mixed vehicle types (truck, taxi, drone, pedestrian, bike)");

    Ok(())
}

pub fn with_expiration(expires_at: SystemTime) -> Self

Create options with absolute expiration time

pub fn effective_expires_at(&self) -> Option<SystemTime>

Get the effective expiration time

Trait Implementations

impl Clone for SetOptions

fn clone(&self) -> SetOptions

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for SetOptions

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for SetOptions

fn default() -> SetOptions

Returns the “default value” for a type.