Add sorted_set::SortedSet data structure

The sorted set is a Set but sorted by a provided score associated to the
value.

Internally a B-Tree (to sort by score) and a HashMap are used (Value,
Score).

Cargo.lock

@@ -309,6 +309,12 @@ dependencies = [
 ]
 
 [[package]]
+name = "float-ord"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ce81f49ae8a0482e4c55ea62ebbd7e5a686af544c00b9d090bba3ff9be97b3d"
+
+[[package]]
 name = "fnv"
 version = "1.0.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -628,6 +634,7 @@ dependencies = [
  "bytes",
  "crc32fast",
  "flexi_logger",
+ "float-ord",
  "futures",
  "git-version",
  "glob",

Cargo.toml

@@ -15,6 +15,7 @@ tokio={version="1", features = ["full", "tracing"] }
 parking_lot="0.11.2"
 tokio-util={version="^0.6", features = ["full"] }
 crc32fast="1.3.2"
+float-ord="^0.3"
 futures = { version = "0.3.0", features = ["thread-pool"]}
 hex = "0.4.3"
 git-version = "0.3.5"

src/value/mod.rs

@@ -5,10 +5,12 @@ pub mod checksum;
 pub mod cursor;
 pub mod expiration;
 pub mod float;
+pub mod sorted_set;
 pub mod typ;
 
 use crate::{error::Error, value_try_from, value_vec_try_from};
 use bytes::{Bytes, BytesMut};
+use float_ord::FloatOrd;
 use redis_zero_protocol_parser::Value as ParsedValue;
 use sha2::{Digest, Sha256};
 use std::{
@@ -30,6 +32,8 @@ pub enum Value {
     List(VecDeque<checksum::Value>),
     /// Set. This type cannot be serialized
     Set(HashSet<Bytes>),
+    /// Sorted set
+    SortedSet(sorted_set::SortedSet<FloatOrd<f64>, Bytes>),
     /// Vector/Array of values
     Array(Vec<Value>),
     /// Bytes/Strings/Binary data

src/value/sorted_set.rs

@@ -0,0 +1,105 @@
+//! # Sorted Set module
+use std::{
+    collections::{btree_map::Iter, BTreeMap, HashMap},
+    hash::Hash,
+};
+
+/// Sorted set structure
+#[derive(Debug, Clone)]
+pub struct SortedSet<S: Clone + PartialEq + Ord, V: Clone + Eq + Hash> {
+    set: HashMap<V, (S, usize)>,
+    order: BTreeMap<S, V>,
+    position_updated: bool,
+}
+
+impl<S: PartialEq + Clone + Ord, V: Eq + Clone + Hash> PartialEq for SortedSet<S, V> {
+    fn eq(&self, other: &SortedSet<S, V>) -> bool {
+        self.order == other.order
+    }
+}
+
+impl<S: PartialEq + Clone + Ord, V: Eq + Clone + Hash> SortedSet<S, V> {
+    /// Creates a new instance
+    pub fn new() -> Self {
+        Self {
+            set: HashMap::new(),
+            order: BTreeMap::new(),
+            position_updated: true,
+        }
+    }
+
+    /// Clears the map, removing all elements.
+    pub fn clear(&mut self) {
+        self.set.clear();
+        self.order.clear();
+    }
+
+    /// Gets an iterator over the entries of the map, sorted by score.
+    pub fn iter(&self) -> Iter<'_, S, V> {
+        self.order.iter()
+    }
+
+    /// Adds a value to the set.
+    /// If the set did not have this value present, true is returned.
+    ///
+    /// If the set did have this value present, false is returned.
+    pub fn insert(&mut self, score: S, value: &V) -> bool {
+        if self.set.get(value).is_none() {
+            self.set.insert(value.clone(), (score.clone(), 0));
+            self.order.insert(score, value.clone());
+            self.position_updated = false;
+            true
+        } else {
+            false
+        }
+    }
+
+    /// Returns a reference to the score in the set, if any, that is equal to the given value.
+    pub fn get_score(&self, value: &V) -> Option<&S> {
+        self.set.get(value).map(|(value, _)| value)
+    }
+
+    /// Returns all the values sorted by their score
+    pub fn get_values(&self) -> Vec<V> {
+        self.order.values().cloned().collect()
+    }
+
+    /// Adds the position in the set to each value based on their score
+    fn update_value_position(&mut self) {
+        let mut i = 0;
+        for element in self.order.values() {
+            if let Some(value) = self.set.get_mut(element) {
+                value.1 = i;
+            }
+            i += 1;
+        }
+        self.position_updated = true;
+    }
+
+    /// Return the position into the set based on their score
+    pub fn get_value_pos(&mut self, value: &V) -> Option<usize> {
+        if self.position_updated {
+            Some(self.set.get(value)?.1)
+        } else {
+            self.update_value_position();
+            Some(self.set.get(value)?.1)
+        }
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn basic_usage() {
+        let mut set: SortedSet<i64, i64> = SortedSet::new();
+        assert!(set.insert(1, &2));
+        assert!(set.insert(0, &3));
+        assert!(!set.insert(33, &3));
+        assert_eq!(vec![3, 2], set.get_values());
+        assert_eq!(Some(1), set.get_value_pos(&2));
+        assert_eq!(Some(0), set.get_value_pos(&3));
+        assert_eq!(None, set.get_value_pos(&5));
+    }
+}