paradis 0.2.1

Parallel processing with disjoint indices
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

use crate::internal;
use crate::RecordIndex;

/// Enables conversion of indices.
///
/// This trait is *sealed*, meaning that it cannot be implemented for external types.
/// The intention behind this trait is to permit converting e.g. `u16` or `u32` type indices
/// (or tuples thereof) to `usize`-based indices. This is primarily useful for saving space
/// when the indices need to be explicitly stored.
pub trait IndexFrom<SourceIndex>: internal::Sealed {
    /// Convert the source index to `Self`, the target index type.
    fn index_from(source: SourceIndex) -> Self;
}

impl IndexFrom<usize> for usize {
    fn index_from(source: usize) -> Self {
        source
    }
}

#[cfg(any(target_pointer_width = "32", target_pointer_width = "64",))]
impl IndexFrom<u32> for usize {
    fn index_from(source: u32) -> Self {
        source
            .try_into()
            .expect("Can always convert u32 to usize since we assume usize is at least 32 bits")
    }
}

#[cfg(any(target_pointer_width = "64"))]
impl IndexFrom<u64> for usize {
    fn index_from(source: u64) -> Self {
        source
            .try_into()
            .expect("Can always convert u64 to usize since we assume usize is at least 64 bits")
    }
}

macro_rules! replace_with_usize {
    ($content:tt) => {
        usize
    };
}

macro_rules! impl_tuple_index_from {
    ($($i:tt),*) => {
        impl<$($i),*> IndexFrom<($($i),*)> for ($(replace_with_usize!($i)),*)
        where
            $($i: RecordIndex),*,
            usize: $(IndexFrom<$i> +)*,
        {
            #[allow(non_snake_case)]
            fn index_from(($($i),*): ($($i), *)) -> Self {
                ( $(usize::index_from($i)),* )
            }
        }
    }
}

impl_tuple_index_from!(I0, I1);
impl_tuple_index_from!(I0, I1, I2);
impl_tuple_index_from!(I0, I1, I2, I3);
impl_tuple_index_from!(I0, I1, I2, I3, I4);