grapl_graph_descriptions/
node.rs

1use log::warn;
2use serde_json::Value;
3
4use crate::graph_description::node::WhichNode;
5use crate::graph_description::{
6    Asset, DynamicNode, File, IpAddress, IpConnection, IpPort, NetworkConnection, Node, Process,
7    ProcessInboundConnection, ProcessOutboundConnection,
8};
9
10pub trait NodeT {
11    fn get_asset_id(&self) -> Option<&str>;
12
13    fn clone_asset_id(&self) -> Option<String> {
14        self.get_asset_id().map(String::from)
15    }
16
17    fn set_asset_id(&mut self, asset_id: impl Into<String>);
18
19    fn get_node_key(&self) -> &str;
20
21    fn clone_node_key(&self) -> String {
22        self.get_node_key().to_string()
23    }
24
25    fn set_node_key(&mut self, node_key: impl Into<String>);
26
27    fn merge(&mut self, other: &Self) -> bool;
28
29    fn merge_into(&mut self, other: Self) -> bool;
30}
31
32impl From<IpConnection> for Node {
33    fn from(ip_connection: IpConnection) -> Self {
34        Self {
35            which_node: Some(WhichNode::IpConnectionNode(ip_connection)),
36        }
37    }
38}
39
40impl From<Asset> for Node {
41    fn from(asset: Asset) -> Self {
42        Self {
43            which_node: Some(WhichNode::AssetNode(asset)),
44        }
45    }
46}
47
48impl From<Process> for Node {
49    fn from(process: Process) -> Self {
50        Self {
51            which_node: Some(WhichNode::ProcessNode(process)),
52        }
53    }
54}
55
56impl From<File> for Node {
57    fn from(file: File) -> Self {
58        Self {
59            which_node: Some(WhichNode::FileNode(file)),
60        }
61    }
62}
63
64impl From<IpAddress> for Node {
65    fn from(ip_address: IpAddress) -> Self {
66        Self {
67            which_node: Some(WhichNode::IpAddressNode(ip_address)),
68        }
69    }
70}
71
72impl From<ProcessOutboundConnection> for Node {
73    fn from(process_outbound_connection: ProcessOutboundConnection) -> Self {
74        Self {
75            which_node: Some(WhichNode::ProcessOutboundConnectionNode(
76                process_outbound_connection,
77            )),
78        }
79    }
80}
81
82impl From<ProcessInboundConnection> for Node {
83    fn from(process_inbound_connection: ProcessInboundConnection) -> Self {
84        Self {
85            which_node: Some(WhichNode::ProcessInboundConnectionNode(
86                process_inbound_connection,
87            )),
88        }
89    }
90}
91
92impl From<IpPort> for Node {
93    fn from(ip_port: IpPort) -> Self {
94        Self {
95            which_node: Some(WhichNode::IpPortNode(ip_port)),
96        }
97    }
98}
99
100impl From<NetworkConnection> for Node {
101    fn from(network_connection: NetworkConnection) -> Self {
102        Self {
103            which_node: Some(WhichNode::NetworkConnectionNode(network_connection)),
104        }
105    }
106}
107
108impl From<DynamicNode> for Node {
109    fn from(dynamic_node: DynamicNode) -> Self {
110        Self {
111            which_node: Some(WhichNode::DynamicNode(dynamic_node)),
112        }
113    }
114}
115
116impl Node {
117    pub fn as_asset(&self) -> Option<&Asset> {
118        let which_node = match self.which_node {
119            Some(ref which_node) => which_node,
120            None => return None,
121        };
122
123        if let WhichNode::AssetNode(ref asset) = which_node {
124            Some(asset)
125        } else {
126            None
127        }
128    }
129
130    pub fn into_asset(self) -> Option<Asset> {
131        let which_node = match self.which_node {
132            Some(which_node) => which_node,
133            None => return None,
134        };
135
136        if let WhichNode::AssetNode(asset) = which_node {
137            Some(asset)
138        } else {
139            None
140        }
141    }
142
143    pub fn as_mut_asset(&mut self) -> Option<&mut Asset> {
144        let which_node = match self.which_node {
145            Some(ref mut which_node) => which_node,
146            None => return None,
147        };
148
149        if let WhichNode::AssetNode(ref mut asset) = which_node {
150            Some(asset)
151        } else {
152            None
153        }
154    }
155
156    pub fn as_process(&self) -> Option<&Process> {
157        let which_node = match self.which_node {
158            Some(ref which_node) => which_node,
159            None => return None,
160        };
161
162        if let WhichNode::ProcessNode(ref process) = which_node {
163            Some(process)
164        } else {
165            None
166        }
167    }
168
169    pub fn into_process(self) -> Option<Process> {
170        let which_node = match self.which_node {
171            Some(which_node) => which_node,
172            None => return None,
173        };
174
175        if let WhichNode::ProcessNode(process) = which_node {
176            Some(process)
177        } else {
178            None
179        }
180    }
181
182    pub fn as_mut_process(&mut self) -> Option<&mut Process> {
183        let which_node = match self.which_node {
184            Some(ref mut which_node) => which_node,
185            None => return None,
186        };
187
188        if let WhichNode::ProcessNode(ref mut process) = which_node {
189            Some(process)
190        } else {
191            None
192        }
193    }
194
195    pub fn as_file(&self) -> Option<&File> {
196        let which_node = match self.which_node {
197            Some(ref which_node) => which_node,
198            None => return None,
199        };
200
201        if let WhichNode::FileNode(ref file) = which_node {
202            Some(file)
203        } else {
204            None
205        }
206    }
207
208    pub fn into_file(self) -> Option<File> {
209        let which_node = match self.which_node {
210            Some(which_node) => which_node,
211            None => return None,
212        };
213
214        if let WhichNode::FileNode(file) = which_node {
215            Some(file)
216        } else {
217            None
218        }
219    }
220
221    pub fn as_mut_file(&mut self) -> Option<&mut File> {
222        let which_node = match self.which_node {
223            Some(ref mut which_node) => which_node,
224            None => return None,
225        };
226
227        if let WhichNode::FileNode(ref mut file) = which_node {
228            Some(file)
229        } else {
230            None
231        }
232    }
233
234    pub fn as_ip_address(&self) -> Option<&IpAddress> {
235        let which_node = match self.which_node {
236            Some(ref which_node) => which_node,
237            None => return None,
238        };
239
240        if let WhichNode::IpAddressNode(ref ip_address) = which_node {
241            Some(ip_address)
242        } else {
243            None
244        }
245    }
246
247    pub fn into_ip_address(self) -> Option<IpAddress> {
248        let which_node = match self.which_node {
249            Some(which_node) => which_node,
250            None => return None,
251        };
252
253        if let WhichNode::IpAddressNode(ip_address) = which_node {
254            Some(ip_address)
255        } else {
256            None
257        }
258    }
259
260    pub fn as_mut_ip_address(&mut self) -> Option<&mut IpAddress> {
261        let which_node = match self.which_node {
262            Some(ref mut which_node) => which_node,
263            None => return None,
264        };
265
266        if let WhichNode::IpAddressNode(ref mut ip_address) = which_node {
267            Some(ip_address)
268        } else {
269            None
270        }
271    }
272
273    pub fn as_process_outbound_connection(&self) -> Option<&ProcessOutboundConnection> {
274        let which_node = match self.which_node {
275            Some(ref which_node) => which_node,
276            None => return None,
277        };
278
279        if let WhichNode::ProcessOutboundConnectionNode(ref process_outbound_connection) =
280            which_node
281        {
282            Some(process_outbound_connection)
283        } else {
284            None
285        }
286    }
287
288    pub fn into_process_outbound_connection(self) -> Option<ProcessOutboundConnection> {
289        let which_node = match self.which_node {
290            Some(which_node) => which_node,
291            None => return None,
292        };
293
294        if let WhichNode::ProcessOutboundConnectionNode(process_outbound_connection) = which_node {
295            Some(process_outbound_connection)
296        } else {
297            None
298        }
299    }
300
301    pub fn as_mut_process_outbound_connection(&mut self) -> Option<&mut ProcessOutboundConnection> {
302        let which_node = match self.which_node {
303            Some(ref mut which_node) => which_node,
304            None => return None,
305        };
306
307        if let WhichNode::ProcessOutboundConnectionNode(ref mut process_outbound_connection) =
308            which_node
309        {
310            Some(process_outbound_connection)
311        } else {
312            None
313        }
314    }
315
316    pub fn as_process_inbound_connection(&self) -> Option<&ProcessInboundConnection> {
317        let which_node = match self.which_node {
318            Some(ref which_node) => which_node,
319            None => return None,
320        };
321
322        if let WhichNode::ProcessInboundConnectionNode(ref process_inbound_connection) = which_node
323        {
324            Some(process_inbound_connection)
325        } else {
326            None
327        }
328    }
329
330    pub fn into_process_inbound_connection(self) -> Option<ProcessInboundConnection> {
331        let which_node = match self.which_node {
332            Some(which_node) => which_node,
333            None => return None,
334        };
335
336        if let WhichNode::ProcessInboundConnectionNode(process_inbound_connection) = which_node {
337            Some(process_inbound_connection)
338        } else {
339            None
340        }
341    }
342
343    pub fn as_mut_process_inbound_connection(&mut self) -> Option<&mut ProcessInboundConnection> {
344        let which_node = match self.which_node {
345            Some(ref mut which_node) => which_node,
346            None => return None,
347        };
348
349        if let WhichNode::ProcessInboundConnectionNode(ref mut process_inbound_connection) =
350            which_node
351        {
352            Some(process_inbound_connection)
353        } else {
354            None
355        }
356    }
357
358    pub fn as_ip_port(&self) -> Option<&IpPort> {
359        let which_node = match self.which_node {
360            Some(ref which_node) => which_node,
361            None => return None,
362        };
363
364        if let WhichNode::IpPortNode(ref ip_port) = which_node {
365            Some(ip_port)
366        } else {
367            None
368        }
369    }
370
371    pub fn as_network_connection(&self) -> Option<&NetworkConnection> {
372        let which_node = match self.which_node {
373            Some(ref which_node) => which_node,
374            None => return None,
375        };
376
377        if let WhichNode::NetworkConnectionNode(ref network_connection) = which_node {
378            Some(network_connection)
379        } else {
380            None
381        }
382    }
383
384    pub fn into_network_connection(self) -> Option<NetworkConnection> {
385        let which_node = match self.which_node {
386            Some(which_node) => which_node,
387            None => return None,
388        };
389
390        if let WhichNode::NetworkConnectionNode(network_connection) = which_node {
391            Some(network_connection)
392        } else {
393            None
394        }
395    }
396
397    pub fn as_mut_network_connection(&mut self) -> Option<&mut NetworkConnection> {
398        let which_node = match self.which_node {
399            Some(ref mut which_node) => which_node,
400            None => return None,
401        };
402
403        if let WhichNode::NetworkConnectionNode(ref mut network_connection) = which_node {
404            Some(network_connection)
405        } else {
406            None
407        }
408    }
409
410    pub fn as_ip_connection(&self) -> Option<&IpConnection> {
411        let which_node = match self.which_node {
412            Some(ref which_node) => which_node,
413            None => return None,
414        };
415
416        if let WhichNode::IpConnectionNode(ref ip_connection) = which_node {
417            Some(ip_connection)
418        } else {
419            None
420        }
421    }
422
423    pub fn into_ip_connection(self) -> Option<IpConnection> {
424        let which_node = match self.which_node {
425            Some(which_node) => which_node,
426            None => return None,
427        };
428
429        if let WhichNode::IpConnectionNode(ip_connection) = which_node {
430            Some(ip_connection)
431        } else {
432            None
433        }
434    }
435
436    pub fn as_mut_ip_connection(&mut self) -> Option<&mut IpConnection> {
437        let which_node = match self.which_node {
438            Some(ref mut which_node) => which_node,
439            None => return None,
440        };
441
442        if let WhichNode::IpConnectionNode(ref mut ip_connection) = which_node {
443            Some(ip_connection)
444        } else {
445            None
446        }
447    }
448
449    pub fn as_dynamic_node(&self) -> Option<&DynamicNode> {
450        let which_node = match self.which_node {
451            Some(ref which_node) => which_node,
452            None => return None,
453        };
454
455        if let WhichNode::DynamicNode(ref dynamic_node) = which_node {
456            Some(dynamic_node)
457        } else {
458            None
459        }
460    }
461
462    pub fn into_dynamic_node(self) -> Option<DynamicNode> {
463        let which_node = match self.which_node {
464            Some(which_node) => which_node,
465            None => return None,
466        };
467
468        if let WhichNode::DynamicNode(dynamic_node) = which_node {
469            Some(dynamic_node)
470        } else {
471            None
472        }
473    }
474
475    pub fn as_mut_dynamic_node(&mut self) -> Option<&mut DynamicNode> {
476        let which_node = match self.which_node {
477            Some(ref mut which_node) => which_node,
478            None => {
479                warn!("Failed to determine variant of node");
480                return None;
481            }
482        };
483
484        if let WhichNode::DynamicNode(ref mut dynamic_node) = which_node {
485            Some(dynamic_node)
486        } else {
487            None
488        }
489    }
490
491    pub fn into_json(self) -> Value {
492        let which_node = match self.which_node {
493            Some(which_node) => which_node,
494            None => {
495                panic!("Failed to determine variant of node");
496            }
497        };
498
499        match which_node {
500            WhichNode::AssetNode(asset_node) => asset_node.into_json(),
501            WhichNode::ProcessNode(process_node) => process_node.into_json(),
502            WhichNode::FileNode(file_node) => file_node.into_json(),
503            WhichNode::IpAddressNode(ip_address_node) => ip_address_node.into_json(),
504            WhichNode::ProcessOutboundConnectionNode(process_outbound_connection_node) => {
505                process_outbound_connection_node.into_json()
506            }
507            WhichNode::ProcessInboundConnectionNode(process_inbound_connection_node) => {
508                process_inbound_connection_node.into_json()
509            }
510            WhichNode::IpPortNode(ip_port_node) => ip_port_node.into_json(),
511            WhichNode::NetworkConnectionNode(network_connection_node) => {
512                network_connection_node.into_json()
513            }
514            WhichNode::IpConnectionNode(ip_connection_node) => ip_connection_node.into_json(),
515            WhichNode::DynamicNode(dynamic_node) => dynamic_node.into_json(),
516        }
517    }
518}
519
520impl NodeT for Node {
521    fn get_asset_id(&self) -> Option<&str> {
522        let which_node = match self.which_node {
523            Some(ref which_node) => which_node,
524            None => {
525                warn!("Failed to determine variant of node");
526                return None;
527            }
528        };
529
530        match which_node {
531            WhichNode::AssetNode(asset_node) => asset_node.get_asset_id(),
532            WhichNode::ProcessNode(process_node) => process_node.get_asset_id(),
533            WhichNode::FileNode(file_node) => file_node.get_asset_id(),
534            WhichNode::IpAddressNode(ip_address_node) => ip_address_node.get_asset_id(),
535            WhichNode::ProcessOutboundConnectionNode(process_outbound_connection_node) => {
536                process_outbound_connection_node.get_asset_id()
537            }
538            WhichNode::ProcessInboundConnectionNode(process_inbound_connection_node) => {
539                process_inbound_connection_node.get_asset_id()
540            }
541            WhichNode::IpPortNode(ip_port_node) => ip_port_node.get_asset_id(),
542            WhichNode::NetworkConnectionNode(network_connection_node) => {
543                network_connection_node.get_asset_id()
544            }
545            WhichNode::IpConnectionNode(ip_connection_node) => ip_connection_node.get_asset_id(),
546            WhichNode::DynamicNode(dynamic_node) => dynamic_node.get_asset_id(),
547        }
548    }
549
550    fn set_asset_id(&mut self, asset_id: impl Into<String>) {
551        let which_node = match self.which_node {
552            Some(ref mut which_node) => which_node,
553            None => {
554                warn!("Failed to determine variant of node");
555                return;
556            }
557        };
558
559        match which_node {
560            WhichNode::AssetNode(ref mut asset_node) => asset_node.set_asset_id(asset_id.into()),
561            WhichNode::ProcessNode(ref mut process_node) => {
562                process_node.set_asset_id(asset_id.into())
563            }
564            WhichNode::FileNode(ref mut file_node) => file_node.set_asset_id(asset_id.into()),
565            WhichNode::IpAddressNode(ref mut ip_address_node) => {
566                ip_address_node.set_asset_id(asset_id.into())
567            }
568            WhichNode::ProcessOutboundConnectionNode(ref mut process_outbound_connection_node) => {
569                process_outbound_connection_node.set_asset_id(asset_id.into())
570            }
571            WhichNode::ProcessInboundConnectionNode(ref mut process_inbound_connection_node) => {
572                process_inbound_connection_node.set_asset_id(asset_id.into())
573            }
574            WhichNode::IpPortNode(ref mut ip_port_node) => {
575                ip_port_node.set_asset_id(asset_id.into())
576            }
577            WhichNode::NetworkConnectionNode(ref mut network_connection_node) => {
578                network_connection_node.set_asset_id(asset_id.into())
579            }
580            WhichNode::IpConnectionNode(ip_connection_node) => {
581                ip_connection_node.set_asset_id(asset_id.into())
582            }
583            WhichNode::DynamicNode(ref mut dynamic_node) => {
584                dynamic_node.set_asset_id(asset_id.into())
585            }
586        }
587    }
588
589    fn get_node_key(&self) -> &str {
590        let which_node = match self.which_node {
591            Some(ref which_node) => which_node,
592            None => {
593                panic!("Failed to determine variant of node");
594            }
595        };
596
597        match which_node {
598            WhichNode::AssetNode(asset_node) => asset_node.get_node_key(),
599            WhichNode::ProcessNode(process_node) => process_node.get_node_key(),
600            WhichNode::FileNode(file_node) => file_node.get_node_key(),
601            WhichNode::IpAddressNode(ip_address_node) => ip_address_node.get_node_key(),
602            WhichNode::ProcessOutboundConnectionNode(process_outbound_connection_node) => {
603                process_outbound_connection_node.get_node_key()
604            }
605            WhichNode::ProcessInboundConnectionNode(process_inbound_connection_node) => {
606                process_inbound_connection_node.get_node_key()
607            }
608            WhichNode::IpPortNode(ip_port_node) => ip_port_node.get_node_key(),
609            WhichNode::NetworkConnectionNode(network_connection_node) => {
610                network_connection_node.get_node_key()
611            }
612            WhichNode::IpConnectionNode(ip_connection_node) => ip_connection_node.get_node_key(),
613            WhichNode::DynamicNode(dynamic_node) => dynamic_node.get_node_key(),
614        }
615    }
616
617    fn set_node_key(&mut self, node_key: impl Into<String>) {
618        let which_node = match self.which_node {
619            Some(ref mut which_node) => which_node,
620            None => {
621                warn!("Failed to determine variant of node");
622                return;
623            }
624        };
625
626        match which_node {
627            WhichNode::AssetNode(ref mut asset_node) => asset_node.set_node_key(node_key.into()),
628            WhichNode::ProcessNode(ref mut process_node) => {
629                process_node.set_node_key(node_key.into())
630            }
631            WhichNode::FileNode(ref mut file_node) => file_node.set_node_key(node_key.into()),
632            WhichNode::IpAddressNode(ref mut ip_address_node) => {
633                ip_address_node.set_node_key(node_key.into())
634            }
635            WhichNode::ProcessOutboundConnectionNode(ref mut process_outbound_connection_node) => {
636                process_outbound_connection_node.set_node_key(node_key.into())
637            }
638            WhichNode::ProcessInboundConnectionNode(ref mut process_inbound_connection_node) => {
639                process_inbound_connection_node.set_node_key(node_key.into())
640            }
641            WhichNode::IpPortNode(ref mut ip_port_node) => {
642                ip_port_node.set_node_key(node_key.into())
643            }
644            WhichNode::NetworkConnectionNode(ref mut network_connection_node) => {
645                network_connection_node.set_node_key(node_key.into())
646            }
647            WhichNode::IpConnectionNode(ip_connection_node) => {
648                ip_connection_node.set_node_key(node_key.into())
649            }
650            WhichNode::DynamicNode(ref mut dynamic_node) => {
651                dynamic_node.set_node_key(node_key.into())
652            }
653        }
654    }
655
656    fn merge(&mut self, other: &Self) -> bool {
657        let which_node = match self.which_node {
658            Some(ref mut which_node) => which_node,
659            None => {
660                warn!("Failed to determine variant of node");
661                return false;
662            }
663        };
664
665        match which_node {
666            WhichNode::AssetNode(ref mut asset_node) => {
667                if let Some(WhichNode::AssetNode(ref other)) = other.which_node {
668                    asset_node.merge(other)
669                } else {
670                    warn!("Attempted to merge AssetNode with non-AssetNode ");
671                    false
672                }
673            }
674            WhichNode::ProcessNode(ref mut process_node) => {
675                if let Some(WhichNode::ProcessNode(ref other)) = other.which_node {
676                    process_node.merge(other)
677                } else {
678                    warn!("Attempted to merge ProcessNode with non-ProcessNode ");
679                    false
680                }
681            }
682            WhichNode::FileNode(ref mut file_node) => {
683                if let Some(WhichNode::FileNode(ref other)) = other.which_node {
684                    file_node.merge(other)
685                } else {
686                    warn!("Attempted to merge FileNode with non-FileNode ");
687                    false
688                }
689            }
690            WhichNode::IpAddressNode(ref mut ip_address_node) => {
691                if let Some(WhichNode::IpAddressNode(ref other)) = other.which_node {
692                    ip_address_node.merge(other)
693                } else {
694                    warn!("Attempted to merge IpAddressNode with non-IpAddressNode ");
695                    false
696                }
697            }
698            WhichNode::ProcessOutboundConnectionNode(ref mut process_outbound_connection_node) => {
699                if let Some(WhichNode::ProcessOutboundConnectionNode(ref other)) = other.which_node
700                {
701                    process_outbound_connection_node.merge(other)
702                } else {
703                    warn!("Attempted to merge ProcessOutboundConnectionNode with non-ProcessOutboundConnectionNode ");
704                    false
705                }
706            }
707            WhichNode::ProcessInboundConnectionNode(ref mut process_inbound_connection_node) => {
708                if let Some(WhichNode::ProcessInboundConnectionNode(ref other)) = other.which_node {
709                    process_inbound_connection_node.merge(other)
710                } else {
711                    warn!("Attempted to merge ProcessInboundConnectionNode with non-ProcessInboundConnectionNode ");
712                    false
713                }
714            }
715            WhichNode::IpPortNode(ref mut ip_port_node) => {
716                if let Some(WhichNode::IpPortNode(ref other)) = other.which_node {
717                    ip_port_node.merge(other)
718                } else {
719                    warn!("Attempted to merge IpPortNode with non-IpPortNode ");
720                    false
721                }
722            }
723            WhichNode::NetworkConnectionNode(ref mut network_connection_node) => {
724                if let Some(WhichNode::NetworkConnectionNode(ref other)) = other.which_node {
725                    network_connection_node.merge(other)
726                } else {
727                    warn!(
728                        "Attempted to merge NetworkConnectionNode with non-NetworkConnectionNode "
729                    );
730                    false
731                }
732            }
733            WhichNode::IpConnectionNode(ip_connection_node) => {
734                if let Some(WhichNode::IpConnectionNode(ref other)) = other.which_node {
735                    ip_connection_node.merge(other)
736                } else {
737                    warn!("Attempted to merge IpConnectionNode with non-NetworkConnectionNode ");
738                    false
739                }
740            }
741            WhichNode::DynamicNode(ref mut dynamic_node) => {
742                if let Some(WhichNode::DynamicNode(ref other)) = other.which_node {
743                    dynamic_node.merge(other)
744                } else {
745                    warn!("Attempted to merge DynamicNode with non-DynamicNode ");
746                    false
747                }
748            }
749        }
750    }
751
752    fn merge_into(&mut self, other: Self) -> bool {
753        let which_node = match self.which_node {
754            Some(ref mut which_node) => which_node,
755            None => {
756                warn!("Failed to determine variant of node");
757                return false;
758            }
759        };
760
761        match which_node {
762            WhichNode::AssetNode(ref mut asset_node) => {
763                if let Some(WhichNode::AssetNode(other)) = other.which_node {
764                    asset_node.merge_into(other)
765                } else {
766                    warn!("Attempted to merge AssetNode with non-AssetNode ");
767                    false
768                }
769            }
770            WhichNode::ProcessNode(ref mut process_node) => {
771                if let Some(WhichNode::ProcessNode(other)) = other.which_node {
772                    process_node.merge_into(other)
773                } else {
774                    warn!("Attempted to merge ProcessNode with non-ProcessNode ");
775                    false
776                }
777            }
778            WhichNode::FileNode(ref mut file_node) => {
779                if let Some(WhichNode::FileNode(other)) = other.which_node {
780                    file_node.merge_into(other)
781                } else {
782                    warn!("Attempted to merge FileNode with non-FileNode ");
783                    false
784                }
785            }
786            WhichNode::IpAddressNode(ref mut ip_address_node) => {
787                if let Some(WhichNode::IpAddressNode(other)) = other.which_node {
788                    ip_address_node.merge_into(other)
789                } else {
790                    warn!("Attempted to merge IpAddressNode with non-IpAddressNode ");
791                    false
792                }
793            }
794            WhichNode::ProcessOutboundConnectionNode(ref mut process_outbound_connection_node) => {
795                if let Some(WhichNode::ProcessOutboundConnectionNode(other)) = other.which_node {
796                    process_outbound_connection_node.merge_into(other)
797                } else {
798                    warn!("Attempted to merge ProcessOutboundConnectionNode with non-ProcessOutboundConnectionNode ");
799                    false
800                }
801            }
802            WhichNode::ProcessInboundConnectionNode(ref mut process_inbound_connection_node) => {
803                if let Some(WhichNode::ProcessInboundConnectionNode(other)) = other.which_node {
804                    process_inbound_connection_node.merge_into(other)
805                } else {
806                    warn!("Attempted to merge ProcessInboundConnectionNode with non-ProcessInboundConnectionNode ");
807                    false
808                }
809            }
810            WhichNode::IpPortNode(ref mut ip_port_node) => {
811                if let Some(WhichNode::IpPortNode(other)) = other.which_node {
812                    ip_port_node.merge_into(other)
813                } else {
814                    warn!("Attempted to merge IpPortNode with non-IpPortNode ");
815                    false
816                }
817            }
818            WhichNode::NetworkConnectionNode(ref mut network_connection_node) => {
819                if let Some(WhichNode::NetworkConnectionNode(other)) = other.which_node {
820                    network_connection_node.merge_into(other)
821                } else {
822                    warn!(
823                        "Attempted to merge NetworkConnectionNode with non-NetworkConnectionNode "
824                    );
825                    false
826                }
827            }
828            WhichNode::IpConnectionNode(ip_connection_node) => {
829                if let Some(WhichNode::IpConnectionNode(other)) = other.which_node {
830                    ip_connection_node.merge_into(other)
831                } else {
832                    warn!("Attempted to merge IpConnectionNode with non-NetworkConnectionNode ");
833                    false
834                }
835            }
836            WhichNode::DynamicNode(ref mut dynamic_node) => {
837                if let Some(WhichNode::DynamicNode(other)) = other.which_node {
838                    dynamic_node.merge_into(other)
839                } else {
840                    warn!("Attempted to merge DynamicNode with non-DynamicNode ");
841                    false
842                }
843            }
844        }
845    }
846}
grapl_graph_descriptions/node.rs

grapl_graph_descriptions/
node.rs
