hidefix 0.12.0

Concurrent HDF5 and NetCDF4 reader (experimental)
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
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

use serde::de::Error;
use serde::ser::{Serialize, Serializer};
use serde::{Deserialize, Deserializer};

use std::borrow::Cow;
use strength_reduce::StrengthReducedU64;

use super::chunk::{Chunk, ULE};

pub mod sr_u64 {
    use super::*;

    pub fn serialize<S, const D: usize>(
        v: &[StrengthReducedU64; D],
        s: S,
    ) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        let b: Vec<u64> = v.iter().map(|s| s.get()).collect();
        b.serialize(s)
    }

    pub fn deserialize<'de, De, const D: usize>(d: De) -> Result<[StrengthReducedU64; D], De::Error>
    where
        De: Deserializer<'de>,
    {
        let mut sr: [StrengthReducedU64; D] = [StrengthReducedU64::new(1); D];

        let v = Vec::<u64>::deserialize(d)?;

        if v.len() != sr.len() {
            return Err(De::Error::custom("length mismatch"));
        }

        for (e, s) in v.iter().zip(sr.iter_mut()) {
            *s = StrengthReducedU64::new(*e);
        }

        Ok(sr)
    }
}

pub mod arr_u64 {
    use super::*;

    pub fn serialize<S, const D: usize>(v: &[u64; D], s: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        v.as_slice().serialize(s)
    }

    pub fn deserialize<'de: 'a, 'a, D, const DN: usize>(d: D) -> Result<[u64; DN], D::Error>
    where
        D: Deserializer<'de>,
    {
        let v = <Vec<u64>>::deserialize(d)?;
        let mut a: [u64; DN] = [0; DN];

        for (e, a) in v.iter().zip(a.iter_mut()) {
            *a = *e;
        }

        Ok(a)
    }
}

pub mod chunks_u64s {
    use super::*;

    pub fn serialize<S, const D: usize>(chunks: &[Chunk<D>], s: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        use zerocopy::AsBytes;

        let slice: &[u8] = Chunk::<D>::slice_as_u64s(chunks).as_bytes();
        serde_bytes::serialize(slice, s)
    }

    pub fn deserialize<'de: 'a, 'a, D, const DE: usize>(
        d: D,
    ) -> Result<Cow<'a, [Chunk<DE>]>, D::Error>
    where
        D: Deserializer<'de>,
    {
        let bytes = <&'a [u8]>::deserialize(d)?;
        let slice = zerocopy::Ref::new_slice_unaligned(bytes).unwrap();
        let slice: &[ULE] = slice.into_slice();

        let chunks: &'a [Chunk<DE>] = Chunk::<DE>::slice_from_u64s(slice);
        let chunks = Cow::<'a, [Chunk<DE>]>::from(chunks);

        debug_assert!(matches!(chunks, Cow::Borrowed(_)));

        Ok(chunks)
    }
}