improvement: show most recent PDUs first when searching

src/client_server/account.rs

@@ -145,7 +145,10 @@ pub fn register_route(
     }
 
     if missing_username {
-        return Err(Error::BadRequest(ErrorKind::MissingParam, "Missing username field."));
+        return Err(Error::BadRequest(
+            ErrorKind::MissingParam,
+            "Missing username field.",
+        ));
     }
 
     let password = if is_guest {

src/database/rooms.rs

@@ -965,6 +965,7 @@ pub fn search_pdus<'a>(
             self.tokenids
                 .scan_prefix(&prefix2)
                 .keys()
+                .rev() // Newest pdus first
                 .filter_map(|r| r.ok())
                 .map(|key| {
                     let pduid_index = key
@@ -983,7 +984,14 @@ pub fn search_pdus<'a>(
                 .filter_map(|r| r.ok())
         });
 
-        Ok((utils::common_elements(iterators).unwrap(), words))
+        Ok((
+            utils::common_elements(iterators, |a, b| {
+                // We compare b with a because we reversed the iterator earlier
+                b.cmp(a)
+            })
+            .unwrap(),
+            words,
+        ))
     }
 
     pub fn get_shared_rooms<'a>(
@@ -1015,7 +1023,8 @@ pub fn get_shared_rooms<'a>(
                 .filter_map(|r| r.ok())
         });
 
-        utils::common_elements(iterators)
+        // We use the default compare function because keys are sorted correctly (not reversed)
+        utils::common_elements(iterators, Ord::cmp)
             .expect("users is not empty")
             .map(|bytes| {
                 RoomId::try_from(utils::string_from_bytes(&*bytes).map_err(|_| {

src/utils.rs

 use argon2::{Config, Variant};
+use cmp::Ordering;
 use rand::prelude::*;
 use sled::IVec;
 use std::{
+    cmp,
     convert::TryInto,
     time::{SystemTime, UNIX_EPOCH},
 };
@@ -63,6 +65,7 @@ pub fn calculate_hash(password: &str) -> Result<String, argon2::Error> {
 
 pub fn common_elements(
     mut iterators: impl Iterator<Item = impl Iterator<Item = IVec>>,
+    check_order: impl Fn(&IVec, &IVec) -> Ordering,
 ) -> Option<impl Iterator<Item = IVec>> {
     let first_iterator = iterators.next()?;
     let mut other_iterators = iterators.map(|i| i.peekable()).collect::<Vec<_>>();
@@ -72,12 +75,13 @@ pub fn common_elements(
             .iter_mut()
             .map(|it| {
                 while let Some(element) = it.peek() {
-                    if element > target {
-                        return false;
-                    } else if element == target {
-                        return true;
-                    } else {
-                        it.next();
+                    match check_order(element, target) {
+                        Ordering::Greater => return false, // We went too far
+                        Ordering::Equal => return true,    // Element is in both iters
+                        Ordering::Less => {
+                            // Keep searching
+                            it.next();
+                        }
                     }
                 }