From 2db4e5cf87a1a1819647d7417b346e89ae0d461b Mon Sep 17 00:00:00 2001 From: satler Date: Sat, 9 Aug 2025 18:23:42 +0900 Subject: [PATCH 1/3] feat: `reversed_sorter_apply_order` --- src/launcher.rs | 5 +++++ src/launcher/batcher.rs | 41 ++++++++++++++++++++++++++++------------- 2 files changed, 33 insertions(+), 13 deletions(-) diff --git a/src/launcher.rs b/src/launcher.rs index 935d52b..bb1bf66 100644 --- a/src/launcher.rs +++ b/src/launcher.rs @@ -182,6 +182,11 @@ where self } + 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. /// diff --git a/src/launcher/batcher.rs b/src/launcher/batcher.rs index 7e2983c..9d14bd7 100644 --- a/src/launcher/batcher.rs +++ b/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, } @@ -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,39 @@ 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; - } - ord => { - return if self.reverse_sorter { - ord.reverse() - } else { - ord - }; + + macro_rules! compare { + ($i:ident) => { + match self.sorters[$i].compare(lhs, rhs, &self.state.input) { + Ordering::Equal => { + continue; + } + ord => { + return if self.reverse_sorter { + ord.reverse() + } else { + ord + }; + } } + }; + } + + if self.reversed_sorter_apply_order { + for i in (0..self.sorters.len()).rev() { + compare!(i) + } + } else { + for i in 0..self.sorters.len() { + compare!(i) } } - Equal + Ordering::Equal } } From 64cc32126fb254004137afd7ac63aabef41e2af8 Mon Sep 17 00:00:00 2001 From: satler <119724672+satler-git@users.noreply.github.com> Date: Sat, 9 Aug 2025 18:37:27 +0900 Subject: [PATCH 2/3] docs: add for `Launcher::reversed_sorter_apply_order` Co-authored-by: gemini-code-assist[bot] <176961590+gemini-code-assist[bot]@users.noreply.github.com> --- src/launcher.rs | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/src/launcher.rs b/src/launcher.rs index bb1bf66..9fbcefb 100644 --- a/src/launcher.rs +++ b/src/launcher.rs @@ -182,6 +182,12 @@ 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 From 28d49f72db1ebb2574fc28e9504a143445baa9f9 Mon Sep 17 00:00:00 2001 From: satler Date: Sat, 9 Aug 2025 18:39:52 +0900 Subject: [PATCH 3/3] refactor: remove macro --- src/launcher/batcher.rs | 25 +++++++++++++++---------- 1 file changed, 15 insertions(+), 10 deletions(-) diff --git a/src/launcher/batcher.rs b/src/launcher/batcher.rs index 9d14bd7..6610bb5 100644 --- a/src/launcher/batcher.rs +++ b/src/launcher/batcher.rs @@ -144,9 +144,9 @@ where let lhs = &self.state.items[*lhs]; let rhs = &self.state.items[*rhs]; - macro_rules! compare { - ($i:ident) => { - match self.sorters[$i].compare(lhs, rhs, &self.state.input) { + 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; } @@ -158,16 +158,21 @@ where }; } } - }; - } - - if self.reversed_sorter_apply_order { - for i in (0..self.sorters.len()).rev() { - compare!(i) } } else { for i in 0..self.sorters.len() { - compare!(i) + match self.sorters[i].compare(lhs, rhs, &self.state.input) { + Ordering::Equal => { + continue; + } + ord => { + return if self.reverse_sorter { + ord.reverse() + } else { + ord + }; + } + } } }