Function argsort_permutation_by

rust/stringzilla.rs:2213–2228

Sorts a sequence of items by comparing their corresponding byte-slice representations. The size of the permutation is inferred from the length of the `order` slice. # Example ```rust use stringzilla::stringzilla as sz; #[derive(Debug)] struct Person { name: &'static str, age: u32 } let people = [ Person { name: "Charlie", age: 20 }, Person { name: "Alice", age: 25 }, Person { name: "Bob", age:

(mapper: F, order: &mut [SortedIdx])

/// assert_eq!(&order, &[1, 2, 0]); // "Alice", "Bob", "Charlie"
/// ```
pub fn argsort_permutation_by<F, A>(mapper: F, order: &mut [SortedIdx]) -> Result<(), Status>
where
    F: Fn(usize) -> A,
    A: AsRef<[u8]>,
{
    // Adapter closure: given an index, call the provided mapper and then transmute the
    // resulting slice to have a `'static` lifetime. This transmute is safe as long as
    // the FFI call is synchronous and the returned slices are only used during the call.
    let adapter = move |i: usize| -> &'static [u8] {
        let binding = mapper(i);
        let slice = binding.as_ref();
        unsafe { core::mem::transmute(slice) }
    };

    _argsort_permutation_impl(adapter, order)
}

/// Helper that takes an adapter (with a concrete type) and performs the FFI call.
fn _argsort_permutation_impl<FAdapter>(adapter: FAdapter, order: &mut [SortedIdx]) -> Result<(), Status>