fix: Updated examples

examples/netflow_pcap.rs

@@ -74,30 +74,28 @@ fn main() {
     let mut parsed_packets = vec![];
 
     for data in pcap_data.iter() {
-        let results = parser.parse_bytes(data);
-        for result in results.iter().cloned() {
-            match result.clone() {
-                NetflowPacket::V5(_v5) => parsed_packets.push(result),
-                NetflowPacket::V7(_v7) => parsed_packets.push(result),
-                NetflowPacket::V9(_v9) => parsed_packets.push(result),
-                NetflowPacket::IPFix(ipfix) => {
+        for result in parser.iter_packets(data) {
+            match result {
+                NetflowPacket::V5(ref _v5) => parsed_packets.push(result),
+                NetflowPacket::V7(ref _v7) => parsed_packets.push(result),
+                NetflowPacket::V9(ref _v9) => parsed_packets.push(result),
+                NetflowPacket::IPFix(ref ipfix) => {
                     let has_no_template = ipfix
                         .flowsets
                         .iter()
                         .any(|flow| matches!(flow.body, FlowSetBody::NoTemplate(_)));
                     if has_no_template {
                         no_template_packets.push(data);
                     } else {
-                        parsed_packets.push(result.clone());
+                        parsed_packets.push(result);
                     }
                 }
                 NetflowPacket::Error(e) => println!("Error: {:?}", e),
             }
         }
     }
     for item in no_template_packets.iter() {
-        let results = parser.parse_bytes(item);
-        parsed_packets.extend(results);
+        parsed_packets.extend(parser.iter_packets(item));
     }
     for (i, p) in parsed_packets.iter().enumerate() {
         println!("Parsed {}: {:?}", i, p);

examples/netflow_udp_listener_multi_threaded.rs

@@ -13,8 +13,9 @@ fn create_thread() -> Sender<Vec<u8>> {
     thread::spawn(move || {
         loop {
             if let Ok(data) = rx.recv() {
-                let result = parser.parse_bytes(data.as_slice());
-                println!("{:?}", result);
+                for packet in parser.iter_packets(data.as_slice()) {
+                    println!("{:?}", packet);
+                }
             }
         }
     });

examples/netflow_udp_listener_single_threaded.rs

@@ -16,15 +16,12 @@ fn main() {
         let filled_buf = &mut buf[..number_of_bytes];
 
         // Fetch Parser by src_addr or insert new parser for src_addr and process bytes
-        let result = match parsers.get_mut(&src_addr.clone()) {
-            Some(parser) => parser.parse_bytes(filled_buf),
-            None => {
-                let mut new_parser = NetflowParser::default();
-                let result = new_parser.parse_bytes(filled_buf);
-                parsers.insert(src_addr, new_parser);
-                result
-            }
-        };
-        println!("{:?}", result);
+        let parser = parsers
+            .entry(src_addr)
+            .or_insert_with(NetflowParser::default);
+
+        for packet in parser.iter_packets(filled_buf) {
+            println!("{:?}", packet);
+        }
     }
 }

examples/netflow_udp_listener_tokio.rs

@@ -18,15 +18,12 @@ async fn main() -> io::Result<()> {
         let data = buf[..len].to_vec();
         let data = data.as_slice();
 
-        let result = match parsers.get_mut(&addr.to_string()) {
-            Some(parser) => parser.parse_bytes(data),
-            None => {
-                let mut new_parser = NetflowParser::default();
-                let result = new_parser.parse_bytes(data);
-                parsers.insert(addr.to_string(), new_parser);
-                result
-            }
-        };
-        println!("{:?}", result);
+        let parser = parsers
+            .entry(addr.to_string())
+            .or_insert_with(NetflowParser::default);
+
+        for packet in parser.iter_packets(data) {
+            println!("{:?}", packet);
+        }
     }
 }