1pub 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
28pub enum NodeWrapper {
36 NormalTrieNode(Arc<NormalTrieNode>),
38 AtomicTrieNode(Arc<AtomicTrieNode>),
39 PaddedTrieNode(Arc<PaddedTrieNode>),
40 LockFreeTrieNode(Arc<LockFreeTrieNode>),
41 NormalRadixNode(Arc<NormalRadixNode>),
43 AtomicRadixNode(Arc<AtomicRadixNode>),
44 PaddedRadixNode(Arc<PaddedRadixNode>),
45 LockFreeRadixNode(Arc<LockFreeRadixNode>),
46}
47
48macro_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#[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 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 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}