From 58f79b15286d511bdd2a0b5d438abfde4e07af8f Mon Sep 17 00:00:00 2001 From: Andreas Fackler Date: Mon, 1 Feb 2016 11:02:02 +0200 Subject: [PATCH 1/4] Count the number of times a message has been added. Also, make the behaviour of `insert` consistent: Whether it moves a re-inserted entry back to the end of the queue should not depend on whether an expiry time was specified. --- src/lib.rs | 92 +++++++++++++++++++++++++++++------------------------- 1 file changed, 50 insertions(+), 42 deletions(-) diff --git a/src/lib.rs b/src/lib.rs index b03797aa..4e5783b5 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -107,25 +107,26 @@ impl MessageFilter where Message: Ord + Clone { } } + /// Adds a message to the filter. + /// /// Removes any expired messages, then adds `message`, then removes enough older messages until /// the message count is at or below `capacity`. If `message` already exists in the filter and - /// is not already expired, its original expiry time and place in the FIFO queue remains - /// unchanged by this call. - pub fn insert(&mut self, message: Message) -> Option { - if !self.contains(&message) { // This call prunes expired entries + /// is not already expired, its expiry time is updated and it is moved to the back of the FIFO + /// queue again. + /// + /// The return value is the number of times this specific message has already been added. + pub fn insert(&mut self, message: Message) -> usize { + self.remove_expired(); + if let Some(index) = self.entries.iter().position(|ref t| t.message == message) { + let mut timestamped_message = self.entries.remove(index); + timestamped_message.update_expiry_point(self.time_to_live); + let count = timestamped_message.increment_count(); + self.entries.push(timestamped_message); + count + } else { self.entries.push(TimestampedMessage::new(message, self.time_to_live)); self.remove_excess(); - None - } else { - if self.time_to_live.is_none() { - return Some(message.clone()) - } - if let Some(index) = self.entries.iter().position(|ref t| t.message == message) { - let timestamped_message = self.entries.remove(index); - self.entries.push(TimestampedMessage::new(message, self.time_to_live)); - return Some(timestamped_message.message) - } - None + 0 } } @@ -169,6 +170,8 @@ impl MessageFilter where Message: Ord + Clone { struct TimestampedMessage { pub message: Message, pub expiry_point: ::time::SteadyTime, + /// How many copies of this message have been seen before this one. + pub count: usize, } impl TimestampedMessage { @@ -181,8 +184,23 @@ impl TimestampedMessage { Some(time_to_live) => ::time::SteadyTime::now() + time_to_live, None => ::time::SteadyTime::now(), }, + count: 0, } } + + /// Updates the expiry point to set the given time to live from now. + pub fn update_expiry_point(&mut self, time_to_live: Option<::time::Duration>) { + self.expiry_point = match time_to_live { + Some(time_to_live) => ::time::SteadyTime::now() + time_to_live, + None => ::time::SteadyTime::now(), + }; + } + + /// Increments the counter and returns its new value. + pub fn increment_count(&mut self) -> usize { + self.count += 1; + self.count + } } @@ -199,8 +217,7 @@ mod test { // Add `size` messages - all should be added. for i in 0..size { assert_eq!(msg_filter.len(), i); - let element = msg_filter.insert(i); - assert_eq!(element, None); + assert_eq!(0, msg_filter.insert(i)); assert_eq!(msg_filter.len(), i + 1); } @@ -209,7 +226,7 @@ mod test { // Add further messages - all should be added, each time pushing out the oldest message. for i in size..1000 { - let _ = msg_filter.insert(i); + assert_eq!(0, msg_filter.insert(i)); assert_eq!(msg_filter.len(), size); assert!(msg_filter.contains(&i)); if size > 1 { @@ -230,8 +247,7 @@ mod test { // Add 10 messages - all should be added. for i in 0..10 { - let element = msg_filter.insert(i); - assert_eq!(element, None); + assert_eq!(0, msg_filter.insert(i)); assert!(msg_filter.contains(&i)); } assert_eq!(msg_filter.len(), 10); @@ -242,14 +258,14 @@ mod test { ::std::thread::sleep(sleep_duration); // Add a new message which should cause the expired values to be removed. - let _ = msg_filter.insert(11); + assert_eq!(0, msg_filter.insert(11)); assert!(msg_filter.contains(&11)); assert_eq!(msg_filter.len(), 1); // Check we can add the initial messages again. for i in 0..10 { assert_eq!(msg_filter.len(), i + 1); - let _ = msg_filter.insert(i); + assert_eq!(0, msg_filter.insert(i)); assert!(msg_filter.contains(&i)); assert_eq!(msg_filter.len(), i + 2); } @@ -274,8 +290,7 @@ mod test { } // Add a new message and check that it has been added successfully. - let element = msg_filter.insert(i); - assert_eq!(element, None); + assert_eq!(0, msg_filter.insert(i)); assert!(msg_filter.contains(&i)); // Check `size` has not been exceeded. @@ -329,7 +344,7 @@ mod test { // Add a new message and check that it has been added successfully. let temp = Temp::new(); - let _ = msg_filter.insert(temp.clone()); + assert_eq!(0, msg_filter.insert(temp.clone())); assert!(msg_filter.contains(&temp)); // Check `size` has not been exceeded. @@ -347,7 +362,7 @@ mod test { // Add a new message which should cause the expired values to be removed. let temp = Temp::new(); - let _ = msg_filter.insert(temp.clone()); + assert_eq!(0, msg_filter.insert(temp.clone())); assert_eq!(msg_filter.len(), 1); assert!(msg_filter.contains(&temp)); } @@ -361,23 +376,19 @@ mod test { // Add `size` messages - all should be added. for i in 0..size { - let element = capacity_filter.insert(i); - assert_eq!(element, None); + assert_eq!(0, capacity_filter.insert(i)); } // Check all added messages remain. assert!((0..size).all(|index| capacity_filter.contains(&index))); // Add "0" again. - let element = capacity_filter.insert(0); - assert!(element.is_some()); - assert_eq!(element.unwrap(), 0); - - // Add "3" and check it's pushed out "0". - let element = capacity_filter.insert(3); - assert_eq!(element, None); - assert!(!capacity_filter.contains(&0)); - assert!(capacity_filter.contains(&1)); + assert_eq!(1, capacity_filter.insert(0)); + + // Add "3" and check it's pushed out "1". + assert_eq!(0, capacity_filter.insert(3)); + assert!(capacity_filter.contains(&0)); + assert!(!capacity_filter.contains(&1)); assert!(capacity_filter.contains(&2)); assert!(capacity_filter.contains(&3)); @@ -386,16 +397,13 @@ mod test { let mut time_filter = super::MessageFilter::::with_expiry_duration(time_to_live); // Add "0". - let element = time_filter.insert(0); - assert_eq!(element, None); + assert_eq!(0, time_filter.insert(0)); // Wait for half the expiry time and re-add "0". let sleep_duration = ::std::time::Duration::from_millis((time_to_live.num_milliseconds() as u64 / 2) + 10); ::std::thread::sleep(sleep_duration); - let element = time_filter.insert(0); - assert!(element.is_some()); - assert_eq!(element.unwrap(), 0); + assert_eq!(1, time_filter.insert(0)); // Wait for another half of the expiry time and check it's not been removed. ::std::thread::sleep(sleep_duration); From 4fbacb06d74f5e371e89aaa18e2109f765e43568 Mon Sep 17 00:00:00 2001 From: Andreas Fackler Date: Mon, 1 Feb 2016 11:18:42 +0200 Subject: [PATCH 2/4] A few cleanups, rustfmt and clippy. --- src/lib.rs | 84 ++++++++++++++++++++++++++++++------------------------ 1 file changed, 47 insertions(+), 37 deletions(-) diff --git a/src/lib.rs b/src/lib.rs index 4e5783b5..c3c9ce50 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -70,14 +70,18 @@ extern crate rand; extern crate time; +use time::SteadyTime; + /// Implementation of [message filter](index.html#message-filter). -pub struct MessageFilter where Message: Ord + Clone { +pub struct MessageFilter { entries: Vec>, capacity: Option, time_to_live: Option<::time::Duration>, } -impl MessageFilter where Message: Ord + Clone { +impl MessageFilter + where Message: PartialEq +{ /// Constructor for capacity based `MessageFilter`. pub fn with_capacity(capacity: usize) -> MessageFilter { MessageFilter { @@ -141,6 +145,11 @@ impl MessageFilter where Message: Ord + Clone { self.entries.len() } + /// Returns whether there are no entries in the filter. + pub fn is_empty(&self) -> bool { + self.entries.is_empty() + } + fn remove_excess(&mut self) { // If capacity is Some, remove the first entry if we're above the limit (should only ever be // at most one entry above capacity). @@ -154,7 +163,7 @@ impl MessageFilter where Message: Ord + Clone { fn remove_expired(&mut self) { if self.time_to_live.is_some() { - let now = ::time::SteadyTime::now(); + let now = SteadyTime::now(); // The entries are sorted from oldest to newest, so just split off the vector at the // first unexpired entry and the returned vector is the remaining unexpired values. If // we don't find any unexpired value, just clear the vector. @@ -169,7 +178,7 @@ impl MessageFilter where Message: Ord + Clone { struct TimestampedMessage { pub message: Message, - pub expiry_point: ::time::SteadyTime, + pub expiry_point: SteadyTime, /// How many copies of this message have been seen before this one. pub count: usize, } @@ -177,13 +186,13 @@ struct TimestampedMessage { impl TimestampedMessage { pub fn new(message: Message, time_to_live: Option<::time::Duration>) - -> TimestampedMessage{ + -> TimestampedMessage { TimestampedMessage { message: message, expiry_point: match time_to_live { - Some(time_to_live) => ::time::SteadyTime::now() + time_to_live, - None => ::time::SteadyTime::now(), - }, + Some(time_to_live) => SteadyTime::now() + time_to_live, + None => SteadyTime::now(), + }, count: 0, } } @@ -191,8 +200,8 @@ impl TimestampedMessage { /// Updates the expiry point to set the given time to live from now. pub fn update_expiry_point(&mut self, time_to_live: Option<::time::Duration>) { self.expiry_point = match time_to_live { - Some(time_to_live) => ::time::SteadyTime::now() + time_to_live, - None => ::time::SteadyTime::now(), + Some(time_to_live) => SteadyTime::now() + time_to_live, + None => SteadyTime::now(), }; } @@ -207,10 +216,15 @@ impl TimestampedMessage { #[cfg(test)] mod test { + use super::*; + use rand; + use rand::Rng; + use std::thread; + #[test] fn size_only() { - let size = ::rand::random::() as usize + 1; - let mut msg_filter = super::MessageFilter::::with_capacity(size); + let size = rand::random::() as usize + 1; + let mut msg_filter = MessageFilter::::with_capacity(size); assert!(msg_filter.time_to_live.is_none()); assert_eq!(Some(size), msg_filter.capacity); @@ -239,9 +253,8 @@ mod test { #[test] fn time_only() { - use ::rand::Rng; - let time_to_live = ::time::Duration::milliseconds(::rand::thread_rng().gen_range(50, 150)); - let mut msg_filter = super::MessageFilter::::with_expiry_duration(time_to_live); + let time_to_live = ::time::Duration::milliseconds(rand::thread_rng().gen_range(50, 150)); + let mut msg_filter = MessageFilter::::with_expiry_duration(time_to_live); assert_eq!(Some(time_to_live), msg_filter.time_to_live); assert_eq!(None, msg_filter.capacity); @@ -255,7 +268,7 @@ mod test { // Allow the added messages time to expire. let sleep_duration = ::std::time::Duration::from_millis(time_to_live.num_milliseconds() as u64 + 10); - ::std::thread::sleep(sleep_duration); + thread::sleep(sleep_duration); // Add a new message which should cause the expired values to be removed. assert_eq!(0, msg_filter.insert(11)); @@ -273,11 +286,10 @@ mod test { #[test] fn time_and_size() { - use ::rand::Rng; - let size = ::rand::random::() as usize + 1; - let time_to_live = ::time::Duration::milliseconds(::rand::thread_rng().gen_range(50, 150)); + let size = rand::random::() as usize + 1; + let time_to_live = ::time::Duration::milliseconds(rand::thread_rng().gen_range(50, 150)); let mut msg_filter = - super::MessageFilter::::with_expiry_duration_and_capacity(time_to_live, size); + MessageFilter::::with_expiry_duration_and_capacity(time_to_live, size); assert_eq!(Some(time_to_live), msg_filter.time_to_live); assert_eq!(Some(size), msg_filter.capacity); @@ -302,9 +314,9 @@ mod test { } // Allow the added messages time to expire. - let sleep_duration = ::std::time::Duration::from_millis( - time_to_live.num_milliseconds() as u64 + 10); - ::std::thread::sleep(sleep_duration); + let sleep_duration = + ::std::time::Duration::from_millis(time_to_live.num_milliseconds() as u64 + 10); + thread::sleep(sleep_duration); // Check for the last message, which should cause all the values to be removed. assert!(!msg_filter.contains(&1000)); @@ -313,8 +325,6 @@ mod test { #[test] fn time_size_struct_value() { - use ::rand::Rng; - #[derive(PartialEq, PartialOrd, Ord, Clone, Eq, Hash)] struct Temp { id: Vec, @@ -322,15 +332,15 @@ mod test { impl Temp { fn new() -> Temp { - let mut rng = ::rand::thread_rng(); - Temp { id: ::rand::sample(&mut rng, 0u8..255, 64) } + let mut rng = rand::thread_rng(); + Temp { id: rand::sample(&mut rng, 0u8..255, 64) } } } - let size = ::rand::random::() as usize + 1; - let time_to_live = ::time::Duration::milliseconds(::rand::thread_rng().gen_range(50, 150)); - let mut msg_filter = - super::MessageFilter::::with_expiry_duration_and_capacity(time_to_live, size); + let size = rand::random::() as usize + 1; + let time_to_live = ::time::Duration::milliseconds(rand::thread_rng().gen_range(50, 150)); + let mut msg_filter = MessageFilter::::with_expiry_duration_and_capacity(time_to_live, + size); assert_eq!(Some(time_to_live), msg_filter.time_to_live); assert_eq!(Some(size), msg_filter.capacity); @@ -358,7 +368,7 @@ mod test { // Allow the added messages time to expire. let sleep_duration = ::std::time::Duration::from_millis(time_to_live.num_milliseconds() as u64 + 10); - ::std::thread::sleep(sleep_duration); + thread::sleep(sleep_duration); // Add a new message which should cause the expired values to be removed. let temp = Temp::new(); @@ -372,7 +382,7 @@ mod test { // Check re-adding a message to a capacity-based filter doesn't alter its position in the // FIFO queue. let size = 3; - let mut capacity_filter = super::MessageFilter::::with_capacity(size); + let mut capacity_filter = MessageFilter::::with_capacity(size); // Add `size` messages - all should be added. for i in 0..size { @@ -394,7 +404,7 @@ mod test { // Check re-adding a message to a time-based filter alter's its expiry time. let time_to_live = ::time::Duration::milliseconds(200); - let mut time_filter = super::MessageFilter::::with_expiry_duration(time_to_live); + let mut time_filter = MessageFilter::::with_expiry_duration(time_to_live); // Add "0". assert_eq!(0, time_filter.insert(0)); @@ -402,15 +412,15 @@ mod test { // Wait for half the expiry time and re-add "0". let sleep_duration = ::std::time::Duration::from_millis((time_to_live.num_milliseconds() as u64 / 2) + 10); - ::std::thread::sleep(sleep_duration); + thread::sleep(sleep_duration); assert_eq!(1, time_filter.insert(0)); // Wait for another half of the expiry time and check it's not been removed. - ::std::thread::sleep(sleep_duration); + thread::sleep(sleep_duration); assert!(time_filter.contains(&0)); // Wait for another half of the expiry time and check it's been removed. - ::std::thread::sleep(sleep_duration); + thread::sleep(sleep_duration); assert!(!time_filter.contains(&0)); } } From a139db917adaa43c6073fa019a93e29b7c3adddc Mon Sep 17 00:00:00 2001 From: Andreas Fackler Date: Mon, 1 Feb 2016 12:58:29 +0200 Subject: [PATCH 3/4] Add count method. --- src/lib.rs | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/src/lib.rs b/src/lib.rs index c3c9ce50..2085550d 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -134,6 +134,11 @@ impl MessageFilter } } + /// Returns the number of times this message has already been inserted. + pub fn count(&self, message: &Message) -> usize { + self.entries.iter().find(|t| &t.message == message).map(|t| t.count).unwrap_or(0) + } + /// Removes any expired messages, then returns whether `message` exists in the filter or not. pub fn contains(&mut self, message: &Message) -> bool { self.remove_expired(); @@ -393,7 +398,9 @@ mod test { assert!((0..size).all(|index| capacity_filter.contains(&index))); // Add "0" again. + assert_eq!(0, capacity_filter.count(&0)); assert_eq!(1, capacity_filter.insert(0)); + assert_eq!(1, capacity_filter.count(&0)); // Add "3" and check it's pushed out "1". assert_eq!(0, capacity_filter.insert(3)); @@ -402,6 +409,9 @@ mod test { assert!(capacity_filter.contains(&2)); assert!(capacity_filter.contains(&3)); + assert_eq!(2, capacity_filter.insert(0)); + assert_eq!(2, capacity_filter.count(&0)); + // Check re-adding a message to a time-based filter alter's its expiry time. let time_to_live = ::time::Duration::milliseconds(200); let mut time_filter = MessageFilter::::with_expiry_duration(time_to_live); From 7e75665278f5009ffe1f4e3e31001bc6594d4d81 Mon Sep 17 00:00:00 2001 From: Andreas Fackler Date: Mon, 1 Feb 2016 16:21:48 +0200 Subject: [PATCH 4/4] Only store hash codes instead of complete messages. --- src/lib.rs | 73 ++++++++++++++++++++++++++++++++---------------------- 1 file changed, 43 insertions(+), 30 deletions(-) diff --git a/src/lib.rs b/src/lib.rs index 2085550d..0794c0a7 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -70,24 +70,34 @@ extern crate rand; extern crate time; +use std::hash::{Hash, Hasher, SipHasher}; +use std::marker::PhantomData; use time::SteadyTime; + +fn hash(t: &T) -> u64 { + let mut s = SipHasher::new(); + t.hash(&mut s); + s.finish() +} + + /// Implementation of [message filter](index.html#message-filter). pub struct MessageFilter { - entries: Vec>, + entries: Vec, capacity: Option, time_to_live: Option<::time::Duration>, + phantom: PhantomData, } -impl MessageFilter - where Message: PartialEq -{ +impl MessageFilter { /// Constructor for capacity based `MessageFilter`. pub fn with_capacity(capacity: usize) -> MessageFilter { MessageFilter { entries: vec![], capacity: Some(capacity), time_to_live: None, + phantom: PhantomData, } } @@ -97,6 +107,7 @@ impl MessageFilter entries: vec![], capacity: None, time_to_live: Some(time_to_live), + phantom: PhantomData, } } @@ -108,6 +119,7 @@ impl MessageFilter entries: vec![], capacity: Some(capacity), time_to_live: Some(time_to_live), + phantom: PhantomData, } } @@ -119,16 +131,17 @@ impl MessageFilter /// queue again. /// /// The return value is the number of times this specific message has already been added. - pub fn insert(&mut self, message: Message) -> usize { + pub fn insert(&mut self, message: &Message) -> usize { self.remove_expired(); - if let Some(index) = self.entries.iter().position(|ref t| t.message == message) { + let hash_code = hash(message); + if let Some(index) = self.entries.iter().position(|ref t| t.hash_code == hash_code) { let mut timestamped_message = self.entries.remove(index); timestamped_message.update_expiry_point(self.time_to_live); let count = timestamped_message.increment_count(); self.entries.push(timestamped_message); count } else { - self.entries.push(TimestampedMessage::new(message, self.time_to_live)); + self.entries.push(TimestampedMessage::new(hash_code, self.time_to_live)); self.remove_excess(); 0 } @@ -136,13 +149,15 @@ impl MessageFilter /// Returns the number of times this message has already been inserted. pub fn count(&self, message: &Message) -> usize { - self.entries.iter().find(|t| &t.message == message).map(|t| t.count).unwrap_or(0) + let hash_code = hash(message); + self.entries.iter().find(|t| t.hash_code == hash_code).map(|t| t.count).unwrap_or(0) } /// Removes any expired messages, then returns whether `message` exists in the filter or not. pub fn contains(&mut self, message: &Message) -> bool { self.remove_expired(); - self.entries.iter().any(|ref entry| entry.message == *message) + let hash_code = hash(message); + self.entries.iter().any(|ref entry| entry.hash_code == hash_code) } /// Returns the size of the filter, i.e. the number of added messages. @@ -181,19 +196,17 @@ impl MessageFilter } } -struct TimestampedMessage { - pub message: Message, +struct TimestampedMessage { + pub hash_code: u64, pub expiry_point: SteadyTime, /// How many copies of this message have been seen before this one. pub count: usize, } -impl TimestampedMessage { - pub fn new(message: Message, - time_to_live: Option<::time::Duration>) - -> TimestampedMessage { +impl TimestampedMessage { + pub fn new(hash_code: u64, time_to_live: Option<::time::Duration>) -> TimestampedMessage { TimestampedMessage { - message: message, + hash_code: hash_code, expiry_point: match time_to_live { Some(time_to_live) => SteadyTime::now() + time_to_live, None => SteadyTime::now(), @@ -236,7 +249,7 @@ mod test { // Add `size` messages - all should be added. for i in 0..size { assert_eq!(msg_filter.len(), i); - assert_eq!(0, msg_filter.insert(i)); + assert_eq!(0, msg_filter.insert(&i)); assert_eq!(msg_filter.len(), i + 1); } @@ -245,7 +258,7 @@ mod test { // Add further messages - all should be added, each time pushing out the oldest message. for i in size..1000 { - assert_eq!(0, msg_filter.insert(i)); + assert_eq!(0, msg_filter.insert(&i)); assert_eq!(msg_filter.len(), size); assert!(msg_filter.contains(&i)); if size > 1 { @@ -265,7 +278,7 @@ mod test { // Add 10 messages - all should be added. for i in 0..10 { - assert_eq!(0, msg_filter.insert(i)); + assert_eq!(0, msg_filter.insert(&i)); assert!(msg_filter.contains(&i)); } assert_eq!(msg_filter.len(), 10); @@ -276,14 +289,14 @@ mod test { thread::sleep(sleep_duration); // Add a new message which should cause the expired values to be removed. - assert_eq!(0, msg_filter.insert(11)); + assert_eq!(0, msg_filter.insert(&11)); assert!(msg_filter.contains(&11)); assert_eq!(msg_filter.len(), 1); // Check we can add the initial messages again. for i in 0..10 { assert_eq!(msg_filter.len(), i + 1); - assert_eq!(0, msg_filter.insert(i)); + assert_eq!(0, msg_filter.insert(&i)); assert!(msg_filter.contains(&i)); assert_eq!(msg_filter.len(), i + 2); } @@ -307,7 +320,7 @@ mod test { } // Add a new message and check that it has been added successfully. - assert_eq!(0, msg_filter.insert(i)); + assert_eq!(0, msg_filter.insert(&i)); assert!(msg_filter.contains(&i)); // Check `size` has not been exceeded. @@ -359,7 +372,7 @@ mod test { // Add a new message and check that it has been added successfully. let temp = Temp::new(); - assert_eq!(0, msg_filter.insert(temp.clone())); + assert_eq!(0, msg_filter.insert(&temp)); assert!(msg_filter.contains(&temp)); // Check `size` has not been exceeded. @@ -377,7 +390,7 @@ mod test { // Add a new message which should cause the expired values to be removed. let temp = Temp::new(); - assert_eq!(0, msg_filter.insert(temp.clone())); + assert_eq!(0, msg_filter.insert(&temp)); assert_eq!(msg_filter.len(), 1); assert!(msg_filter.contains(&temp)); } @@ -391,7 +404,7 @@ mod test { // Add `size` messages - all should be added. for i in 0..size { - assert_eq!(0, capacity_filter.insert(i)); + assert_eq!(0, capacity_filter.insert(&i)); } // Check all added messages remain. @@ -399,17 +412,17 @@ mod test { // Add "0" again. assert_eq!(0, capacity_filter.count(&0)); - assert_eq!(1, capacity_filter.insert(0)); + assert_eq!(1, capacity_filter.insert(&0)); assert_eq!(1, capacity_filter.count(&0)); // Add "3" and check it's pushed out "1". - assert_eq!(0, capacity_filter.insert(3)); + assert_eq!(0, capacity_filter.insert(&3)); assert!(capacity_filter.contains(&0)); assert!(!capacity_filter.contains(&1)); assert!(capacity_filter.contains(&2)); assert!(capacity_filter.contains(&3)); - assert_eq!(2, capacity_filter.insert(0)); + assert_eq!(2, capacity_filter.insert(&0)); assert_eq!(2, capacity_filter.count(&0)); // Check re-adding a message to a time-based filter alter's its expiry time. @@ -417,13 +430,13 @@ mod test { let mut time_filter = MessageFilter::::with_expiry_duration(time_to_live); // Add "0". - assert_eq!(0, time_filter.insert(0)); + assert_eq!(0, time_filter.insert(&0)); // Wait for half the expiry time and re-add "0". let sleep_duration = ::std::time::Duration::from_millis((time_to_live.num_milliseconds() as u64 / 2) + 10); thread::sleep(sleep_duration); - assert_eq!(1, time_filter.insert(0)); + assert_eq!(1, time_filter.insert(&0)); // Wait for another half of the expiry time and check it's not been removed. thread::sleep(sleep_duration);