proto: use XParts types in public API

crates/proto/src/op/message.rs

@@ -685,19 +685,38 @@ impl Message {
         Ok(())
     }
 
-    #[allow(clippy::type_complexity)]
     /// Consumes `Message` and returns into components
-    pub fn into_parts(
-        self,
-    ) -> (
-        Header,
-        Vec<Query>,
-        Vec<Record>,
-        Vec<Record>,
-        Vec<Record>,
-        Vec<Record>,
-        Option<Edns>,
-    ) {
+    pub fn into_parts(self) -> MessageParts {
+        self.into()
+    }
+}
+
+/// Consumes `Message` giving public access to fields in `Message` so they can be
+/// destructured and taken by value
+/// ```rust
+///  let msg = Message::new();
+///  let MessageParts { queries, .. } = msg.into_parts();
+/// ```
+#[derive(Clone, Debug, PartialEq, Default)]
+pub struct MessageParts {
+    /// message header
+    pub header: Header,
+    /// message queries
+    pub queries: Vec<Query>,
+    /// message answers
+    pub answers: Vec<Record>,
+    /// message name_servers
+    pub name_servers: Vec<Record>,
+    /// message additional records
+    pub additionals: Vec<Record>,
+    /// sig0
+    pub sig0: Vec<Record>,
+    /// optional edns records
+    pub edns: Option<Edns>,
+}
+
+impl From<Message> for MessageParts {
+    fn from(msg: Message) -> Self {
         let Message {
             header,
             queries,
@@ -706,16 +725,16 @@ impl Message {
             additionals,
             sig0,
             edns,
-        } = self;
-        (
+        } = msg;
+        MessageParts {
             header,
             queries,
             answers,
             name_servers,
             additionals,
             sig0,
             edns,
-        )
+        }
     }
 }
 

crates/proto/src/op/query.rs

@@ -161,26 +161,41 @@ impl Query {
     }
 
     /// Consumes `Query` and returns it's components
+    pub fn into_parts(self) -> QueryParts {
+        self.into()
+    }
+}
+
+/// Consumes `Query` giving public access to fields of `Query` so they can
+/// be destructured and taken by value.
+#[derive(Clone, Debug, Eq, Hash, PartialEq)]
+pub struct QueryParts {
+    /// QNAME
+    pub name: Name,
+    /// QTYPE
+    pub query_type: RecordType,
+    /// QCLASS
+    pub query_class: DNSClass,
+    /// mDNS unicast-response bit set or not
     #[cfg(feature = "mdns")]
-    pub fn into_parts(self) -> (Name, RecordType, DNSClass, bool) {
+    pub mdns_unicast_response: bool,
+}
+
+impl From<Query> for QueryParts {
+    fn from(q: Query) -> Self {
         let Query {
             name,
             query_type,
             query_class,
             mdns_unicast_response,
-        } = self;
-        (name, query_type, query_class, mdns_unicast_response)
-    }
-
-    /// Consumes `Query` and returns it's components
-    #[cfg(not(feature = "mdns"))]
-    pub fn into_parts(self) -> (Name, RecordType, DNSClass) {
-        let Query {
+        } = q;
+        Self {
             name,
             query_type,
             query_class,
-        } = self;
-        (name, query_type, query_class)
+            #[cfg(feature = "mdns")]
+            mdns_unicast_response,
+        }
     }
 }
 

crates/proto/src/rr/resource.rs

@@ -266,37 +266,48 @@ impl Record {
     }
 
     /// Consumes `Record` and returns its components
+    pub fn into_parts(self) -> RecordParts {
+        self.into()
+    }
+}
+
+/// Consumes `Record` giving public access to fields of `Record` so they can
+/// be destructured and taken by value
+pub struct RecordParts {
+    /// label names
+    pub name_labels: Name,
+    /// record type
+    pub rr_type: RecordType,
+    /// dns class
+    pub dns_class: DNSClass,
+    /// time to live
+    pub ttl: u32,
+    /// rdata
+    pub rdata: RData,
+    /// mDNS cache flush
     #[cfg(feature = "mdns")]
-    pub fn into_parts(self) -> (Name, RecordType, DNSClass, u32, RData, bool) {
+    pub mdns_cache_flush: bool,
+}
+
+impl From<Record> for RecordParts {
+    fn from(record: Record) -> Self {
         let Record {
             name_labels,
             rr_type,
             dns_class,
             ttl,
             rdata,
             mdns_cache_flush,
-        } = self;
-        (
+        } = record;
+        RecordParts {
             name_labels,
             rr_type,
             dns_class,
             ttl,
             rdata,
+            #[cfg(feature = "mdns")]
             mdns_cache_flush,
-        )
-    }
-
-    /// Consumes `Record` and returns its components
-    #[cfg(not(feature = "mdns"))]
-    pub fn into_parts(self) -> (Name, RecordType, DNSClass, u32, RData) {
-        let Record {
-            name_labels,
-            rr_type,
-            dns_class,
-            ttl,
-            rdata,
-        } = self;
-        (name_labels, rr_type, dns_class, ttl, rdata)
+        }
     }
 }
 

crates/proto/src/rr/rr_set.rs

@@ -433,17 +433,26 @@ impl RecordSet {
     }
 
     /// Consumes `RecordSet` and returns its components
-    pub fn into_parts(
-        self,
-    ) -> (
-        Name,
-        RecordType,
-        DNSClass,
-        u32,
-        Vec<Record>,
-        Vec<Record>,
-        u32,
-    ) {
+    pub fn into_parts(self) -> RecordSetParts {
+        self.into()
+    }
+}
+
+/// Consumes `RecordSet` giving public access to fields of `RecordSet` so they can
+/// be destructured and taken by value
+#[derive(Clone, Debug, PartialEq)]
+pub struct RecordSetParts {
+    pub name: Name,
+    pub record_type: RecordType,
+    pub dns_class: DNSClass,
+    pub ttl: u32,
+    pub records: Vec<Record>,
+    pub rrsigs: Vec<Record>,
+    pub serial: u32, // serial number at which this record was modifie,
+}
+
+impl From<RecordSet> for RecordSetParts {
+    fn from(rset: RecordSet) -> Self {
         let RecordSet {
             name,
             record_type,
@@ -452,8 +461,16 @@ impl RecordSet {
             records,
             rrsigs,
             serial,
-        } = self;
-        (name, record_type, dns_class, ttl, records, rrsigs, serial)
+        } = rset;
+        RecordSetParts {
+            name,
+            record_type,
+            dns_class,
+            ttl,
+            records,
+            rrsigs,
+            serial,
+        }
     }
 }