Cache for controlling and reducing IO calls

Overview

This caching library has been designed for specific use-cases where:

getting a "fresh" value can be time consuming and can fail (eg. IOs with hardware)
getting multiple values at once can be more efficient than getting each value independantly.

Typically, its primary use was to retrieve position/speed/temperature/etc from multiple motors using serial communication. In this setup, the motors are daisy chained, and in the protocol used to communicate with them, a specific message can be used to retrieve a register value for multiple motors at once.

Many other caching implementations exist than can better fit other need.

Documentation

Example

```rust use cache_cache::Cache; use std::{error::Error, time::Duration};

fn get_position(ids: &[u8]) -> Result, Box> { // For simplicity, this function always work. // But it's a mockup for a real world scenario where hardware IO can fail. Ok(ids.iter().map(|&id| id as f64 * 10.0).collect()) }

fn main() { let mut presentposition = Cache::withexpiryduration(Duration::frommillis(10));

present_position.insert(10, 0.0);

let pos = present_position
    .entries(&[10, 11, 12])
    .or_try_insert_with(get_position);

assert!(pos.is_ok());
assert_eq!(pos.unwrap(), vec![&0.0, &110.0, &120.0]);

} ```

See https://docs.rs/cache_cache for more information on APIs and examples.

License

This library is licensed under the Apache License 2.0.

Support

It's developed and maintained by Pollen-Robotics. They developped open-source tools for robotics manipulation. Visit https://pollen-robotics.com to learn more or join our Dicord community if you have any questions or want to share your ideas.