feat: reversed_sorter_apply_order

src/launcher.rs

@@ -182,6 +182,17 @@ where
         self
     }
 
+    /// Reverses the application order of sorters.
+    ///
+    /// By default, sorters are applied in the order they are added. If this flag is set to `true`,
+    /// they will be applied in the reverse order of addition. This is useful when you want the
+    /// last-added sorter to have the highest priority in sorting.
+    /// The default value is `false`.
+    pub fn reversed_sorter_apply_order(mut self, flag: bool) -> Self {
+        self.batcher.reversed_sorter_apply_order = flag;
+        self
+    }
+
     /// A batch represents the process of retrieving items from all available sources and sorting the filtered items
     /// according to user-specified sorters.
     ///

src/launcher/batcher.rs

@@ -28,6 +28,7 @@ pub struct Batcher<'a, Cushion, UIContext> {
     pub(super) batch_size: usize,
     pub(super) filter_and: bool,
     pub(super) reverse_sorter: bool,
+    pub(super) reversed_sorter_apply_order: bool,
 
     state: BatcherState<Cushion>,
 }
@@ -46,6 +47,7 @@ where
             batch_size: 0,
             filter_and: true,
             reverse_sorter: false,
+            reversed_sorter_apply_order: false,
 
             cusion_to_ui: None,
 
@@ -137,26 +139,44 @@ where
     #[inline(always)]
     fn create_sorter(&self) -> impl Fn(&usize, &usize) -> std::cmp::Ordering {
         |lhs, rhs| {
-            use std::cmp::Ordering::*;
+            use std::cmp::Ordering;
 
             let lhs = &self.state.items[*lhs];
             let rhs = &self.state.items[*rhs];
-            for si in &self.sorters {
-                match si.compare(lhs, rhs, &self.state.input) {
-                    Equal => {
-                        continue;
+
+            if self.reversed_sorter_apply_order {
+                for i in (0..self.sorters.len()).rev() {
+                    match self.sorters[i].compare(lhs, rhs, &self.state.input) {
+                        Ordering::Equal => {
+                            continue;
+                        }
+                        ord => {
+                            return if self.reverse_sorter {
+                                ord.reverse()
+                            } else {
+                                ord
+                            };
+                        }
                     }
-                    ord => {
-                        return if self.reverse_sorter {
-                            ord.reverse()
-                        } else {
-                            ord
-                        };
+                }
+            } else {
+                for i in 0..self.sorters.len() {
+                    match self.sorters[i].compare(lhs, rhs, &self.state.input) {
+                        Ordering::Equal => {
+                            continue;
+                        }
+                        ord => {
+                            return if self.reverse_sorter {
+                                ord.reverse()
+                            } else {
+                                ord
+                            };
+                        }
                     }
                 }
             }
 
-            Equal
+            Ordering::Equal
         }
     }