gribberish 0.25.1

Parse grib 2 files with 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
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101


pub struct FirstOrderSpatialDifferencing<I> {
    iter: I,
    d1: i32,
    dmin: i32,
    prev: i32,
    current_index: usize,
}

impl <I> FirstOrderSpatialDifferencing<I> {
    pub fn new(iter: I, d1: i32, dmin: i32) -> Self {
        Self {
            iter,
            d1,
            dmin,
            prev: d1,
            current_index: 0,
        }
    }
}

impl <I> Iterator for FirstOrderSpatialDifferencing<I> where I: Iterator<Item = i32> {
    type Item = i32;
    fn next(&mut self) -> Option<Self::Item> {
        let current_index = self.current_index;
        self.current_index += 1;

        if current_index == 0 {
            _ = self.iter.next()?;
            Some(self.d1)
        } else {
            let next_value = self.iter.next()?;
            let next_value = next_value + self.prev + self.dmin;
            self.prev = next_value;
            Some(next_value)
        }
    }
}


pub struct SecondOrderSpatialDifferencing<I> {
    iter: I,
    d1: i32,
    d2: i32,
    dmin: i32,
    prev: i32,
    prev2: i32,
    current_index: usize,
}

impl <I> SecondOrderSpatialDifferencing<I> {
    pub fn new(iter: I, d1: i32, d2: i32, dmin: i32) -> Self {
        Self {
            iter,
            d1,
            d2,
            dmin,
            prev: d2,
            prev2: d1,
            current_index: 0,
        }
    }
}

impl <I> Iterator for SecondOrderSpatialDifferencing<I> where I: Iterator<Item = i32> {
    type Item = i32;
    fn next(&mut self) -> Option<Self::Item> {
        let current_index = self.current_index;
        self.current_index += 1;

        match current_index {
            0 => {
                _ = self.iter.next()?;
                Some(self.d1)
            }, 
            1 => {
                _ = self.iter.next()?;
                Some(self.d2)
            },
            _ => {
                let next_value = self.iter.next()?;
                let next_value = next_value + 2 * self.prev - self.prev2 + self.dmin;
                self.prev2 = self.prev;
                self.prev = next_value;
                Some(next_value)
            }
        }
    }
}

pub trait SpatialDifferencingIterator<T>: Iterator<Item = T> + Sized {
    fn apply_first_order_spatial_differencing(self, d1: i32, dmin: i32) -> FirstOrderSpatialDifferencing<Self> {
        FirstOrderSpatialDifferencing::new(self, d1, dmin)
    }

    fn apply_second_order_spatial_differencing(self, d1: i32, d2: i32, dmin: i32) -> SecondOrderSpatialDifferencing<Self> {
        SecondOrderSpatialDifferencing::new(self, d1, d2, dmin)
    }
}

impl<T, I: Iterator<Item = T>> SpatialDifferencingIterator<T> for I {}