veilid-core 0.5.3

Core library used to create a Veilid node and operate it as part of an application
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
102
103
104
105
106
107
108
109
110
111
112
113
114

use super::*;

impl_veilid_log_facility!("rtab");

pub trait RoutingDomainEditorCommonTrait {
    fn clear_dial_info_details(
        &mut self,
        address_type: Option<AddressType>,
        protocol_type: Option<ProtocolType>,
    ) -> &mut Self;
    fn set_relays(&mut self, relays: Vec<RoutingDomainRelay>) -> &mut Self;
    fn set_relay_state(
        &mut self,
        relay: RoutingDomainRelay,
        state: RoutingDomainRelayState,
    ) -> &mut Self;
    #[cfg_attr(all(target_arch = "wasm32", target_os = "unknown"), expect(dead_code))]
    fn add_dial_info(&mut self, dial_info: DialInfo, class: DialInfoClass) -> &mut Self;
    fn setup_network(
        &mut self,
        outbound_protocols: ProtocolTypeSet,
        inbound_protocols: ProtocolTypeSet,
        address_types: AddressTypeSet,
        capabilities: Vec<VeilidCapability>,
        confirmed: bool,
    ) -> &mut Self;
    fn commit(&mut self, pause_tasks: bool) -> PinBoxFuture<'_, bool>;
    fn reset(&mut self) -> PinBoxFuture<'_, ()>;
    fn publish(&mut self);
    #[cfg_attr(all(target_arch = "wasm32", target_os = "unknown"), expect(dead_code))]
    fn unpublish(&mut self);
}

pub(super) trait RoutingDomainDetailApplyCommonChange {
    /// Make a change from the routing domain editor
    fn apply_common_change(&mut self, change: RoutingDomainChangeCommon);
}

impl<T: RoutingDomainDetailCommonAccessors + ?Sized> RoutingDomainDetailApplyCommonChange for T {
    /// Make a change from the routing domain editor
    fn apply_common_change(&mut self, change: RoutingDomainChangeCommon) {
        match change {
            RoutingDomainChangeCommon::ClearDialInfoDetails {
                address_type,
                protocol_type,
            } => {
                self.common_mut()
                    .clear_dial_info_details(address_type, protocol_type);
            }

            RoutingDomainChangeCommon::SetRelays { relays } => self.common_mut().set_relays(relays),
            RoutingDomainChangeCommon::SetRelayState { relay, state } => {
                self.common_mut().set_relay_state(&relay, state)
            }

            RoutingDomainChangeCommon::AddDialInfo { dial_info_detail } => {
                if !self.ensure_dial_info_is_valid(&dial_info_detail.dial_info) {
                    return;
                }

                self.common_mut()
                    .add_dial_info_detail(dial_info_detail.clone());
            }
            // RoutingDomainChange::RemoveDialInfoDetail { dial_info_detail } => {
            //     self.common
            //         .remove_dial_info_detail(dial_info_detail.clone());
            // }
            RoutingDomainChangeCommon::SetupNetwork {
                outbound_protocols,
                inbound_protocols,
                address_types,
                capabilities,
                confirmed,
            } => {
                self.common_mut().setup_network(
                    outbound_protocols,
                    inbound_protocols,
                    address_types,
                    capabilities.clone(),
                    confirmed,
                );
            }
        }
    }
}

#[derive(Debug)]
pub(super) enum RoutingDomainChangeCommon {
    ClearDialInfoDetails {
        address_type: Option<AddressType>,
        protocol_type: Option<ProtocolType>,
    },
    SetRelays {
        relays: Vec<RoutingDomainRelay>,
    },
    SetRelayState {
        relay: RoutingDomainRelay,
        state: RoutingDomainRelayState,
    },
    AddDialInfo {
        dial_info_detail: DialInfoDetail,
    },
    // #[cfg_attr(all(target_arch = "wasm32", target_os = "unknown"), expect(dead_code))]
    // RemoveDialInfoDetail {
    //     dial_info_detail: DialInfoDetail,
    // },
    SetupNetwork {
        outbound_protocols: ProtocolTypeSet,
        inbound_protocols: ProtocolTypeSet,
        address_types: AddressTypeSet,
        capabilities: Vec<VeilidCapability>,
        confirmed: bool,
    },
}