compression 0.1.5

Compression libraries implemented by pure Rust.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

//! rust-compression
//!
//! # Licensing
//! This Source Code is subject to the terms of the Mozilla Public License
//! version 2.0 (the "License"). You can obtain a copy of the License at
//! <http://mozilla.org/MPL/2.0/>.
#![cfg(any(feature = "bzip2", feature = "deflate", feature = "lzhuf"))]

use crate::core::ops::{Add, Sub};
use crate::core::usize;
#[cfg(not(feature = "std"))]
#[allow(unused_imports)]
use alloc::vec;
#[cfg(not(feature = "std"))]
use alloc::vec::Vec;
use num_traits::{cast, Bounded, NumCast};

pub(crate) trait BucketSort {
    type Item;
    fn bucket_sort_by_key<
        K: Clone + Add + Sub<Output = K> + NumCast,
        F: Fn(&Self::Item) -> K,
    >(
        &self,
        key_selector: F,
        min: K,
        max: K,
    ) -> Vec<Self::Item>;

    fn bucket_sort_all_by_key<K, F>(&self, key_selector: F) -> Vec<Self::Item>
    where
        K: Bounded + Clone + Add + Sub<Output = K> + NumCast,
        F: Fn(&Self::Item) -> K,
    {
        self.bucket_sort_by_key(
            key_selector,
            Bounded::min_value(),
            Bounded::max_value(),
        )
    }
}

impl<T: Clone> BucketSort for [T] {
    type Item = T;
    fn bucket_sort_by_key<
        K: Clone + Add + Sub<Output = K> + NumCast,
        F: Fn(&T) -> K,
    >(
        &self,
        key_selector: F,
        min: K,
        max: K,
    ) -> Vec<T> {
        let mut ret = self.to_vec();
        let mut bucket =
            vec![0; cast::<K, usize>(max - min.clone()).unwrap() + 2];

        for i in 0..self.len() {
            bucket[cast::<_, usize>(key_selector(&self[i]) - min.clone())
                .unwrap()
                + 1] += 1;
        }
        for i in 2..bucket.len() {
            bucket[i] += bucket[i - 1];
        }
        for i in self {
            let val = i.clone();
            let idx =
                cast::<_, usize>(key_selector(&val) - min.clone()).unwrap();
            ret[bucket[idx]] = val;
            bucket[idx] += 1;
        }
        ret
    }
}