prns-core 0.3.4

Pure Reticulum engine and wire contract for Personal Reticulum
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

use crate::engine::InstantMillis;
use crate::interfaces::InterfaceId;
use crate::routing::routes::interface_index::RouteInterfaceIndex;

#[derive(Debug, Default, Clone, Copy, PartialEq, Eq)]
pub struct LinearRouteInterfaceIndex;

impl RouteInterfaceIndex for LinearRouteInterfaceIndex {
    fn insert(&mut self, _row: usize, _interface: InterfaceId) {}

    fn update(&mut self, _row: usize, _previous: InterfaceId, _current: InterfaceId) {}

    fn swap_remove(
        &mut self,
        _removed: usize,
        _last: usize,
        _receiving_interfaces: &[InterfaceId],
    ) {
    }

    fn route_count_via(
        &self,
        interface: InterfaceId,
        receiving_interfaces: &[InterfaceId],
    ) -> usize {
        receiving_interfaces
            .iter()
            .filter(|&&candidate| candidate == interface)
            .count()
    }

    fn repoint_receiving_interface(
        &mut self,
        previous: InterfaceId,
        current: InterfaceId,
        now: InstantMillis,
        receiving_interfaces: &mut [InterfaceId],
        last_relayed_at: &mut [InstantMillis],
    ) -> usize {
        debug_assert_eq!(receiving_interfaces.len(), last_relayed_at.len());
        let mut moved = 0;
        for (row, interface) in receiving_interfaces.iter_mut().enumerate() {
            if *interface != previous {
                continue;
            }
            *interface = current;
            last_relayed_at[row] = now;
            moved += 1;
        }
        moved
    }
}