Skip to content

refactor to have a consistent expiration window #10

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
demoray wants to merge 1 commit into
base: main
Choose a base branch
from
Open

refactor to have a consistent expiration window #10

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
50 changes: 16 additions & 34 deletions src/lib.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -4,8 +4,9 @@
//! ```rust
//! use std::time::Duration;
//! use expiringmap::ExpiringMap;
//! let mut map = ExpiringMap::new();
//! map.insert("key", "value", Duration::from_millis(50));
//! let mut map = ExpiringMap::new(Duration::from_millis(50));
//! map.insert("key", "value");
//! assert!(map.get(&"key").is_some());
//! std::thread::sleep(Duration::from_millis(60));
//! assert!(map.get(&"key").is_none());
//! ```
Expand Down Expand Up @@ -76,6 +77,7 @@ impl<T> ExpiryValue<T> {
#[derive(Debug)]
pub struct ExpiringMap<K, V> {
last_size: usize,
duration: Duration,
inner: ExpiringMapInner<K, V>,
}

Expand All @@ -102,15 +104,16 @@ impl<K: PartialEq + Eq + Hash, V> ExpiringMap<K, V> {
const MINIMUM_VACUUM_SIZE: usize = 8;

/// Create a new [`ExpiringMap`]
pub fn new() -> Self {
Self::with_capacity(0)
pub fn new(duration: Duration) -> Self {
Self::with_capacity(duration, 0)
}

/// Create a new [`ExpiringMap`] with the specified capacity
pub fn with_capacity(capacity: usize) -> Self {
pub fn with_capacity(duration: Duration, capacity: usize) -> Self {
Self {
inner: ExpiringMapInner::with_capacity(capacity),
last_size: Self::MINIMUM_VACUUM_SIZE,
duration,
}
}

Expand Down Expand Up @@ -194,11 +197,11 @@ impl<K: PartialEq + Eq + Hash, V> ExpiringMap<K, V> {
}

/// Insert a value into the map, returning the old value if it has not expired and existed
pub fn insert(&mut self, key: K, value: V, ttl: Duration) -> Option<ExpiryValue<V>> {
pub fn insert(&mut self, key: K, value: V) -> Option<ExpiryValue<V>> {
self.vacuum_if_needed();
let entry = ExpiryValue {
inserted: Instant::now(),
ttl,
ttl: self.duration,
value,
};
self.inner
Expand Down Expand Up @@ -270,27 +273,18 @@ impl<K: PartialEq + Eq + Hash, V> ExpiringMap<K, V> {

impl<K: PartialEq + Eq + Hash> ExpiringSet<K> {
/// Create a new [`ExpiringSet`]
pub fn new() -> Self {
Self::with_capacity(0)
pub fn new(duration: Duration) -> Self {
Self::with_capacity(duration, 0)
}

/// Create a new [`ExpiringSet`] with the specified capacity
pub fn with_capacity(capacity: usize) -> Self {
Self(ExpiringMap::with_capacity(capacity))
pub fn with_capacity(duration: Duration, capacity: usize) -> Self {
Self(ExpiringMap::with_capacity(duration, capacity))
}

/// Returns true if the set contains this value
pub fn insert(&mut self, key: K, ttl: Duration) -> bool {
self.vacuum_if_needed();
let entry = ExpiryValue {
inserted: Instant::now(),
ttl,
value: (),
};
self.inner
.insert(key, entry)
.filter(ExpiryValue::not_expired)
.is_some()
pub fn insert(&mut self, key: K) -> bool {
self.0.insert(key, ()).is_some()
}

/// Returns true if the set contains this value
Expand Down Expand Up @@ -328,15 +322,3 @@ impl<K: PartialEq + Eq + Hash> ExpiringSet<K> {
self.0.shrink_to(min_capacity);
}
}

impl<K: PartialEq + Eq + Hash, V> Default for ExpiringMap<K, V> {
fn default() -> Self {
Self::new()
}
}

impl<K: PartialEq + Eq + Hash> Default for ExpiringSet<K> {
fn default() -> Self {
Self::new()
}
}
58 changes: 30 additions & 28 deletions src/test.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -3,79 +3,81 @@ use std::{thread::sleep, time::Duration};
use crate::{ExpiringMap, ExpiringSet};
#[test]
fn map_works() {
let mut m = ExpiringMap::new();
m.insert("v", "x", Duration::from_millis(50));
let mut m = ExpiringMap::new(Duration::from_millis(50));
m.insert("v", "x");
assert_eq!(m.get(&"v"), Some(&"x"));
sleep(Duration::from_millis(75));
assert!(!m.contains_key(&"v"));
}

#[test]
fn set_works() {
let mut m = ExpiringSet::new();
m.insert("v", Duration::from_millis(50));
let mut m = ExpiringSet::new(Duration::from_millis(50));
m.insert("v");
assert!(m.contains_key(&"v"));
sleep(Duration::from_millis(75));
assert!(!m.contains_key(&"v"));
}

#[test]
fn remaining_calc() {
let mut m = ExpiringSet::new();
m.insert("v", Duration::from_millis(50));
let mut m = ExpiringSet::new(Duration::from_millis(50));
m.insert("v");
let meta = m.get_meta(&"v").unwrap();
dbg!(meta.remaining());
// we allow 10ms of slop here. Should be enough;
assert!(meta.remaining() > Duration::from_millis(40));
assert!(meta.remaining() < Duration::from_millis(60));
for _ in 0..3 {
let a = meta.remaining();
sleep(Duration::from_millis(1));
let b = meta.remaining();
assert!(a > b, "{:?} !> {:?}", a, b);
}

sleep(Duration::from_millis(75));
assert!(!m.contains_key(&"v"));
}

#[test]
fn vacuum_keeps() {
let mut m = ExpiringSet::new();
m.insert("v", Duration::from_secs(50));
let mut m = ExpiringSet::new(Duration::from_secs(50));
m.insert("v");
m.vacuum();
assert!(m.get(&"v").is_some());
}

#[test]
fn vacuum_sweeps() {
let mut m = ExpiringSet::new();
m.insert("v", Duration::from_millis(50));
let mut m = ExpiringSet::new(Duration::from_millis(50));
m.insert("v");
sleep(Duration::from_millis(75));
m.vacuum();
assert!(!m.inner.contains_key(&"v"));
}

#[test]
fn insert_replace() {
let mut m = ExpiringMap::new();
m.insert("v", "x", Duration::from_secs(5));
assert_eq!(
m.insert("v", "y", Duration::from_secs(5)).unwrap().value,
"x"
);
let mut m = ExpiringMap::new(Duration::from_secs(5));
m.insert("v", "x");
assert_eq!(m.insert("v", "y").map(|v| v.value), Some("x"));
}

#[test]
fn insert_replace_sweep() {
let mut m = ExpiringMap::new();
m.insert("v", "x", Duration::ZERO);
assert!(m.insert("v", "y", Duration::from_secs(100)).is_none());
assert!(m.insert("v", "z", Duration::from_secs(1)).is_some());
let mut m = ExpiringMap::new(Duration::from_millis(50));
m.insert("v", "x");
assert_eq!(m.insert("v", "y").map(|v| v.value), Some("x"));
sleep(Duration::from_millis(75));
assert!(m.insert("v", "z").is_none());
assert_eq!(m.get("v"), Some(&"z"))
}

#[test]
fn test_borrow() {
let mut m: ExpiringMap<String, usize> = ExpiringMap::new();
m.insert(String::from("x"), 1, Duration::from_secs(5));
let mut m: ExpiringMap<String, usize> = ExpiringMap::new(Duration::from_secs(5));
m.insert(String::from("x"), 1);
assert_eq!(m.get("x"), Some(&1));
assert_eq!(m.get(&String::from("x")), Some(&1));

let mut m: ExpiringSet<String> = ExpiringSet::new();
m.insert(String::from("x"), Duration::from_secs(5));
let mut m: ExpiringSet<String> = ExpiringSet::new(Duration::from_secs(5));
m.insert(String::from("x"));
assert!(m.contains("x"));
assert!(m.contains(&String::from("x")));
}