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
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

use crate::identity::destination_identity::{DestinationIdentityRecord, DestinationIdentityTable};
use crate::identity::{DestinationIdentityRetentionState, IdentityPublicKeys};
use crate::routing::announce::stored::{AnnounceAppData, AnnounceAppDataError, AppDataHandle};
use crate::storage::TablePushError;
use crate::units::InstantMillis;
use crate::wire::DestinationHash;

#[derive(Debug, Clone, Copy, Default)]
pub struct NoDestinationIdentityTable;

impl DestinationIdentityTable for NoDestinationIdentityTable {
    fn capacity(&self) -> usize {
        0
    }

    fn len(&self) -> usize {
        0
    }

    fn destinations(&self) -> &[DestinationHash] {
        &[]
    }

    fn public_keys(&self) -> &[IdentityPublicKeys] {
        &[]
    }

    fn announced_at(&self) -> &[InstantMillis] {
        &[]
    }

    fn retention(&self) -> &[DestinationIdentityRetentionState] {
        &[]
    }

    fn app_data_handles(&self) -> &[AppDataHandle] {
        &[]
    }

    fn set_row(&mut self, _: usize, _: DestinationIdentityRecord) {}

    fn push(
        &mut self,
        _: DestinationHash,
        _: DestinationIdentityRecord,
    ) -> Result<usize, TablePushError> {
        Err(TablePushError::TableFull)
    }

    fn swap_remove(&mut self, _: usize) {}
}

#[derive(Debug, Clone, Copy, Default)]
pub struct NoDestinationIdentityAppData;

impl AnnounceAppData for NoDestinationIdentityAppData {
    fn get(&self, _: AppDataHandle) -> &[u8] {
        &[]
    }

    fn insert(&mut self, _: &[u8]) -> Result<AppDataHandle, AnnounceAppDataError> {
        Err(AnnounceAppDataError::TooManyEntries)
    }

    fn replace(&mut self, _: AppDataHandle, _: &[u8]) -> Result<(), AnnounceAppDataError> {
        Err(AnnounceAppDataError::TooManyEntries)
    }

    fn free(&mut self, _: AppDataHandle) {}
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::identity::destination_identity::DestinationIdentities;

    #[test]
    fn disabled_destination_identity_storage_is_zero_sized() {
        assert_eq!(core::mem::size_of::<NoDestinationIdentityTable>(), 0);
        assert_eq!(core::mem::size_of::<NoDestinationIdentityAppData>(), 0);
        assert_eq!(
            core::mem::size_of::<
                DestinationIdentities<NoDestinationIdentityTable, NoDestinationIdentityAppData>,
            >(),
            0,
        );
    }
}