faex 0.1.2

A fast and efficient Compact Data Structures Library
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

use crate::util::ceil_div;

// TODO: see https://github.com/dtolnay/syn/tree/master/examples/heapsize
pub trait HeapSize {
    /// Returns the size of the data structure in bits.
    fn heap_size_in_bits(&self) -> usize;

    /// Returns the size of the data structure in bytes.
    fn heap_size_in_bytes(&self) -> usize {
        // Round-up to the nearest byte
        ceil_div(self.heap_size_in_bits(), 8)
    }

    /// Returns the size of the data structure in kibibytes.
    fn heap_size_in_kib(&self) -> usize {
        ceil_div(self.heap_size_in_bytes(), 1024)
    }

    /// Returns the size of the data structure in mebibytes.
    fn heap_size_in_mib(&self) -> usize {
        ceil_div(self.heap_size_in_kib(), 1024)
    }
    /// Returns the size of the data structure in gibibytes.
    fn heap_size_in_gib(&self) -> usize {
        ceil_div(self.heap_size_in_mib(), 1024)
    }

    /// Returns the exact size of the data structure in bytes as a floating point number.
    fn exact_heap_size_in_bytes(&self) -> f64 {
        self.heap_size_in_bits() as f64 / 8.0
    }

    /// Returns the exact size of the data structure in kibibytes as a floating point number.
    fn exact_heap_size_in_kib(&self) -> f64 {
        self.exact_heap_size_in_bytes() / 1024.0
    }

    /// Returns the exact size of the data structure in mebibytes as a floating point number.
    fn exact_heap_size_in_mib(&self) -> f64 {
        self.exact_heap_size_in_kib() / 1024.0
    }

    /// Returns the exact size of the data structure in gibibytes as a floating point number.
    fn exact_heap_size_in_gib(&self) -> f64 {
        self.exact_heap_size_in_mib() / 1024.0
    }
}

impl<T> HeapSize for &[T] {
    fn heap_size_in_bits(&self) -> usize {
        std::mem::size_of_val(*self) * 8
    }
}
impl<T> HeapSize for Vec<T> {
    fn heap_size_in_bits(&self) -> usize {
        std::mem::size_of::<T>() * 8 * self.len()
    }
}