Skip to main content

radixip/node/
mod.rs

1//! Node module for RadixIP.
2//!
3//! This module is split into two sub-modules:
4//!
5//! - [`uncompressed`] — bit-by-bit trie nodes (Normal, Atomic, Padded, LockFree)
6//! - [`compressed`]   — Patricia trie nodes (CompressedNormal, CompressedAtomic,
7//!                       CompressedPadded, CompressedLockFree)
8//!
9//! Public API is re-exported from this module so callers just do:
10//!
11//! ```rust
12//! use crate::node::{NodeBuilder, NodeWrapper};
13//! ```
14
15pub mod compressed;
16pub mod uncompressed;
17
18pub use compressed::{
19    AtomicRadixNode, LockFreeRadixNode, NormalRadixNode, PaddedRadixNode,
20};
21pub use uncompressed::{AtomicTrieNode, LockFreeTrieNode, NormalTrieNode, PaddedTrieNode};
22
23use crate::traits::{NodeVariant, Node};
24use crate::types::Metadata;
25use ipnetwork::IpNetwork;
26use std::sync::Arc;
27
28//
29// NODE WRAPPER ENUM
30// Provides a single concrete type that implements `Node` for all variants.
31// Trees store `Arc<dyn Node>` — the NodeWrapper is the concrete type
32// that gets erased behind that pointer.
33//
34
35pub enum NodeWrapper {
36    // Uncompressed variants
37    NormalTrieNode(Arc<NormalTrieNode>),
38    AtomicTrieNode(Arc<AtomicTrieNode>),
39    PaddedTrieNode(Arc<PaddedTrieNode>),
40    LockFreeTrieNode(Arc<LockFreeTrieNode>),
41    // Compressed (Patricia) variants
42    NormalRadixNode(Arc<NormalRadixNode>),
43    AtomicRadixNode(Arc<AtomicRadixNode>),
44    PaddedRadixNode(Arc<PaddedRadixNode>),
45    LockFreeRadixNode(Arc<LockFreeRadixNode>),
46}
47
48/// Macro to dispatch all Node methods across all variants.
49macro_rules! dispatch {
50    ($self:ident, $method:ident $(, $arg:expr)*) => {
51        match $self {
52            NodeWrapper::NormalTrieNode(n)            => n.$method($($arg),*),
53            NodeWrapper::AtomicTrieNode(n)            => n.$method($($arg),*),
54            NodeWrapper::PaddedTrieNode(n)            => n.$method($($arg),*),
55            NodeWrapper::LockFreeTrieNode(n)          => n.$method($($arg),*),
56            NodeWrapper::NormalRadixNode(n)  => n.$method($($arg),*),
57            NodeWrapper::AtomicRadixNode(n)  => n.$method($($arg),*),
58            NodeWrapper::PaddedRadixNode(n)  => n.$method($($arg),*),
59            NodeWrapper::LockFreeRadixNode(n)=> n.$method($($arg),*),
60        }
61    };
62}
63
64impl Node for NodeWrapper {
65    fn bit(&self) -> Option<u8> {
66        dispatch!(self, bit)
67    }
68
69    fn left(&self) -> Option<Arc<dyn Node>> {
70        dispatch!(self, left)
71    }
72
73    fn right(&self) -> Option<Arc<dyn Node>> {
74        dispatch!(self, right)
75    }
76
77    fn metadata(&self) -> Option<Metadata> {
78        dispatch!(self, metadata)
79    }
80
81    fn prefix(&self) -> Option<IpNetwork> {
82        dispatch!(self, prefix)
83    }
84
85    fn set_left(&self, node: Option<Arc<dyn Node>>) {
86        dispatch!(self, set_left, node)
87    }
88
89    fn set_right(&self, node: Option<Arc<dyn Node>>) {
90        dispatch!(self, set_right, node)
91    }
92
93    fn set_metadata(&self, metadata: Metadata) {
94        dispatch!(self, set_metadata, metadata)
95    }
96
97    fn clear_metadata(&self) {
98        dispatch!(self, clear_metadata)
99    }
100
101    fn set_bit(&self, bit: u8) {
102        dispatch!(self, set_bit, bit)
103    }
104
105    fn set_prefix(&self, prefix: IpNetwork) {
106        dispatch!(self, set_prefix, prefix)
107    }
108
109    fn edge_bits(&self) -> Option<[u8; 16]> {
110        dispatch!(self, edge_bits)
111    }
112
113    fn edge_len(&self) -> Option<usize> {
114        dispatch!(self, edge_len)
115    }
116
117    fn set_edge(&self, bits: [u8; 16], len: usize) {
118        dispatch!(self, set_edge, bits, len)
119    }
120}
121
122//
123// NODE BUILDER
124// Factory that creates the right NodeWrapper variant from a NodeVariant enum.
125//
126
127#[derive(Clone)]
128pub struct NodeBuilder {
129    variant: NodeVariant,
130}
131
132impl NodeBuilder {
133    pub fn new(variant: NodeVariant) -> Self {
134        Self { variant }
135    }
136
137    /// Build an empty node of the configured variant.
138    pub fn build(&self) -> Arc<dyn Node> {
139        match self.variant {
140            NodeVariant::NormalTrieNode => Arc::new(NodeWrapper::NormalTrieNode(Arc::new(NormalTrieNode::new()))),
141            NodeVariant::AtomicTrieNode => Arc::new(NodeWrapper::AtomicTrieNode(Arc::new(AtomicTrieNode::new()))),
142            NodeVariant::PaddedTrieNode => Arc::new(NodeWrapper::PaddedTrieNode(Arc::new(PaddedTrieNode::new()))),
143            NodeVariant::LockFreeTrieNode => Arc::new(NodeWrapper::LockFreeTrieNode(Arc::new(LockFreeTrieNode::new()))),
144            NodeVariant::NormalRadixNode => Arc::new(NodeWrapper::NormalRadixNode(Arc::new(
145                NormalRadixNode::new(),
146            ))),
147            NodeVariant::AtomicRadixNode => Arc::new(NodeWrapper::AtomicRadixNode(Arc::new(
148                AtomicRadixNode::new(),
149            ))),
150            NodeVariant::PaddedRadixNode => Arc::new(NodeWrapper::PaddedRadixNode(Arc::new(
151                PaddedRadixNode::new(),
152            ))),
153            NodeVariant::LockFreeRadixNode => Arc::new(NodeWrapper::LockFreeRadixNode(Arc::new(
154                LockFreeRadixNode::new(),
155            ))),
156        }
157    }
158
159    /// Build a leaf node (a node that immediately stores a prefix + metadata).
160    pub fn build_leaf(&self, network: IpNetwork, metadata: Metadata) -> Arc<dyn Node> {
161        let node = self.build();
162        node.set_prefix(network);
163        node.set_metadata(metadata);
164        node
165    }
166}