Refactoring as requested

zbus/src/address/address_list.rs

@@ -1,6 +1,6 @@
 use std::{borrow::Cow, fmt};
 
-use super::{Address, Error, Result, ToAddresses};
+use super::{Address, Error, OwnedAddress, Result, ToAddresses, ToOwnedAddresses};
 
 /// A bus address list.
 ///
@@ -79,3 +79,47 @@ impl fmt::Display for AddressList<'_> {
         write!(f, "{}", self.addr)
     }
 }
+
+/// An iterator of D-Bus addresses.
+pub struct OwnedAddressListIter<'a> {
+    data: &'a str,
+    next_index: usize,
+}
+
+impl<'a> ToOwnedAddresses<'a> for AddressList<'a> {
+    type Iter = OwnedAddressListIter<'a>;
+
+    /// Get an iterator over the D-Bus addresses.
+    fn to_owned_addresses(&'a self) -> Self::Iter {
+        OwnedAddressListIter::new(self)
+    }
+}
+
+impl<'a> OwnedAddressListIter<'a> {
+    fn new(list: &'a AddressList<'_>) -> Self {
+        Self {
+            data: list.addr.as_ref(),
+            next_index: 0,
+        }
+    }
+}
+
+impl<'a> Iterator for OwnedAddressListIter<'a> {
+    type Item = Result<OwnedAddress>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.next_index >= self.data.len() {
+            return None;
+        }
+
+        let mut addr = &self.data[self.next_index..];
+        if let Some(end) = addr.find(';') {
+            addr = &addr[..end];
+            self.next_index += end + 1;
+        } else {
+            self.next_index = self.data.len();
+        }
+
+        Some(OwnedAddress::try_from(addr))
+    }
+}

zbus/src/address/guid.rs

@@ -0,0 +1,45 @@
+use std::fmt;
+
+use super::{Error, Result};
+
+/// Universally-unique IDs for D-Bus addresses.
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct Guid([u8; 16]);
+
+impl Guid {
+    /// Create a Guid from the given bytes.
+    pub fn new(bytes: [u8; 16]) -> Self {
+        Guid(bytes)
+    }
+
+    /// Returns a byte slice of this Guid’s contents
+    pub fn as_bytes(&self) -> &[u8; 16] {
+        &self.0
+    }
+}
+
+impl fmt::Display for Guid {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{:02x}{:02x}{:02x}{:02x}{:02x}{:02x}{:02x}{:02x}{:02x}{:02x}{:02x}{:02x}{:02x}{:02x}{:02x}{:02x}",
+               self.0[0], self.0[1], self.0[2], self.0[3], self.0[4], self.0[5], self.0[6], self.0[7],
+               self.0[8], self.0[9], self.0[10], self.0[11], self.0[12], self.0[13], self.0[14], self.0[15])
+    }
+}
+
+impl TryFrom<&str> for Guid {
+    type Error = Error;
+
+    fn try_from(s: &str) -> Result<Self> {
+        if s.len() != 32 {
+            return Err(Error::InvalidValue("guid".into()));
+        }
+
+        let mut bytes = [0u8; 16];
+        for (i, chunk) in s.as_bytes().chunks(2).enumerate() {
+            bytes[i] = u8::from_str_radix(std::str::from_utf8(chunk).unwrap(), 16)
+                .map_err(|_| Error::InvalidValue("guid".into()))?;
+        }
+
+        Ok(Guid(bytes))
+    }
+}

zbus/src/address/mod.rs

@@ -33,6 +33,10 @@ pub use address_list::{AddressList, AddressListIter};
 
 mod percent;
 pub use percent::*;
+use transport::TransportImpl;
+
+pub mod guid;
+use guid::Guid;
 
 #[cfg(test)]
 mod tests;
@@ -119,7 +123,10 @@ pub fn system() -> Result<AddressList<'static>> {
     }
 }
 
-/// A bus address.
+/// A parsed bus address.
+///
+/// The fields of this structure are references to the source. Using an [`OwnedAddress`] may be more
+/// convenient or if your context requires 'static lifetime.
 ///
 /// Example:
 /// ```
@@ -134,13 +141,17 @@ pub struct Address<'a> {
 
 impl<'a> Address<'a> {
     /// The connection GUID if any.
-    pub fn guid(&self) -> Option<Cow<'_, str>> {
-        self.get_string("guid").and_then(|res| res.ok())
+    pub fn guid(&self) -> Result<Option<Guid>> {
+        if let Some(guid) = self.get_string("guid") {
+            Ok(Some(guid?.as_ref().try_into()?))
+        } else {
+            Ok(None)
+        }
     }
 
     /// Transport connection details
     pub fn transport(&self) -> Result<transport::Transport<'_>> {
-        self.try_into()
+        transport::Transport::for_address(self)
     }
 
     pub(super) fn key_val_iter(&'a self) -> KeyValIter<'a> {
@@ -163,12 +174,14 @@ impl<'a> Address<'a> {
     fn validate(&self) -> Result<()> {
         self.transport()?;
         for (k, v) in self.key_val_iter() {
-            let v = match v {
-                Some(v) => decode_percents(v)?,
-                _ => Cow::from(b"" as &[_]),
-            };
-            if k == "guid" {
-                validate_guid(v.as_ref())?;
+            match (k, v) {
+                ("guid", Some(v)) => {
+                    guid::Guid::try_from(decode_percents_str(v)?.as_ref())?;
+                }
+                (_, Some(v)) => {
+                    decode_percents(v)?;
+                }
+                _ => {}
             }
         }
 
@@ -187,21 +200,6 @@ impl<'a> Address<'a> {
     }
 }
 
-fn validate_guid(value: &[u8]) -> Result<()> {
-    if value.len() != 32 || value.iter().any(|&c| !c.is_ascii_hexdigit()) {
-        return Err(Error::InvalidValue("guid".into()));
-    }
-
-    Ok(())
-}
-
-impl Address<'_> {
-    pub fn to_owned(&self) -> Address<'static> {
-        let addr = self.addr.to_string();
-        Address { addr: addr.into() }
-    }
-}
-
 impl<'a> TryFrom<String> for Address<'a> {
     type Error = Error;
 
@@ -220,14 +218,73 @@ impl<'a> TryFrom<&'a str> for Address<'a> {
 
 impl fmt::Display for Address<'_> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let kv = KeyValFmt::new().add("guid", self.guid());
+        let kv = KeyValFmt::new().add("guid", self.guid().map_err(|_| fmt::Error)?);
         let t = self.transport().map_err(|_| fmt::Error)?;
-        let kv = t.key_val_fmt_add(kv);
+        let kv = t.fmt_key_val(kv);
+        write!(f, "{t}:{kv}")?;
+        Ok(())
+    }
+}
+
+/// An owned bus address.
+///
+/// Example:
+/// ```
+/// use zbus::address::OwnedAddress;
+///
+/// let _: OwnedAddress = "unix:path=/tmp/dbus.sock".try_into().unwrap();
+/// ```
+#[derive(Debug, PartialEq, Eq, Clone)]
+pub struct OwnedAddress {
+    transport: transport::Transport<'static>,
+    guid: Option<Guid>,
+}
+
+impl OwnedAddress {
+    /// The connection GUID if any.
+    pub fn guid(&self) -> Option<&Guid> {
+        self.guid.as_ref()
+    }
+
+    /// Transport connection details
+    pub fn transport(&self) -> &transport::Transport<'static> {
+        &self.transport
+    }
+
+    fn new(addr: &str) -> Result<Self> {
+        let addr = Address { addr: addr.into() };
+        let transport = addr.transport()?.into_owned();
+        let guid = addr.guid()?;
+        Ok(Self { transport, guid })
+    }
+}
+
+impl fmt::Display for OwnedAddress {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let kv = KeyValFmt::new().add("guid", self.guid.as_ref());
+        let t = &self.transport;
+        let kv = t.fmt_key_val(kv);
         write!(f, "{t}:{kv}")?;
         Ok(())
     }
 }
 
+impl TryFrom<&str> for OwnedAddress {
+    type Error = Error;
+
+    fn try_from(addr: &str) -> Result<Self> {
+        Self::new(addr)
+    }
+}
+
+impl TryFrom<String> for OwnedAddress {
+    type Error = Error;
+
+    fn try_from(addr: String) -> Result<Self> {
+        Self::new(&addr)
+    }
+}
+
 pub(super) struct KeyValIter<'a> {
     data: &'a str,
     next_index: usize,
@@ -265,10 +322,10 @@ impl<'a> Iterator for KeyValIter<'a> {
     }
 }
 
-pub(crate) trait KeyValFmtAdd {
-    fn key_val_fmt_add<'a: 'b, 'b>(&'a self, kv: KeyValFmt<'b>) -> KeyValFmt<'b>;
-}
-
+// A structure for formatting key-value pairs.
+//
+// This struct allows for the dynamic collection and formatting of key-value pairs,
+// where keys implement `fmt::Display` and values implement `Encodable`.
 pub(crate) struct KeyValFmt<'a> {
     fields: Vec<(Box<dyn fmt::Display + 'a>, Box<dyn Encodable + 'a>)>,
 }
@@ -342,8 +399,23 @@ impl<'a> ToAddresses<'a> for String {
 impl<'a> ToAddresses<'a> for Vec<Result<Address<'_>>> {
     type Iter = std::iter::Cloned<std::slice::Iter<'a, Result<Address<'a>>>>;
 
-    /// Get an iterator over the D-Bus addresses.
     fn to_addresses(&'a self) -> Self::Iter {
         self.iter().cloned()
     }
 }
+
+/// A trait for objects which can be converted or resolved to one or more [`OwnedAddress`] values.
+pub trait ToOwnedAddresses<'a> {
+    type Iter: Iterator<Item = Result<OwnedAddress>>;
+
+    /// Get an iterator over the D-Bus addresses.
+    fn to_owned_addresses(&'a self) -> Self::Iter;
+}
+
+impl<'a> ToOwnedAddresses<'a> for str {
+    type Iter = std::iter::Once<Result<OwnedAddress>>;
+
+    fn to_owned_addresses(&'a self) -> Self::Iter {
+        std::iter::once(self.try_into())
+    }
+}

zbus/src/address/percent.rs

@@ -6,39 +6,6 @@ use std::{
 
 use super::{Error, Result};
 
-// A trait for types that can be percent-encoded and written to a [`fmt::Formatter`].
-pub(crate) trait Encodable {
-    fn encode(&self, f: &mut fmt::Formatter<'_>) -> std::fmt::Result;
-}
-
-impl<T: ToString> Encodable for T {
-    fn encode(&self, f: &mut fmt::Formatter<'_>) -> std::fmt::Result {
-        encode_percents(f, self.to_string().as_bytes())
-    }
-}
-
-pub(crate) struct EncData<T: ?Sized>(pub T);
-
-impl<T: AsRef<[u8]>> Encodable for EncData<T> {
-    fn encode(&self, f: &mut fmt::Formatter<'_>) -> std::fmt::Result {
-        encode_percents(f, self.0.as_ref())
-    }
-}
-
-pub(crate) struct EncOsStr<T: ?Sized>(pub T);
-
-impl Encodable for EncOsStr<&Cow<'_, OsStr>> {
-    fn encode(&self, f: &mut fmt::Formatter<'_>) -> std::fmt::Result {
-        encode_percents(f, self.0.to_string_lossy().as_bytes())
-    }
-}
-
-impl Encodable for EncOsStr<&OsStr> {
-    fn encode(&self, f: &mut fmt::Formatter<'_>) -> std::fmt::Result {
-        encode_percents(f, self.0.to_string_lossy().as_bytes())
-    }
-}
-
 /// Percent-encode the value.
 pub fn encode_percents(f: &mut dyn fmt::Write, value: &[u8]) -> std::fmt::Result {
     for &byte in value {
@@ -86,6 +53,39 @@ pub fn decode_percents(value: &str) -> Result<Cow<'_, [u8]>> {
     Ok(Cow::Owned(decoded))
 }
 
+// A trait for types that can be percent-encoded and written to a [`fmt::Formatter`].
+pub(crate) trait Encodable {
+    fn encode(&self, f: &mut fmt::Formatter<'_>) -> std::fmt::Result;
+}
+
+impl<T: ToString> Encodable for T {
+    fn encode(&self, f: &mut fmt::Formatter<'_>) -> std::fmt::Result {
+        encode_percents(f, self.to_string().as_bytes())
+    }
+}
+
+pub(crate) struct EncData<T: ?Sized>(pub T);
+
+impl<T: AsRef<[u8]>> Encodable for EncData<T> {
+    fn encode(&self, f: &mut fmt::Formatter<'_>) -> std::fmt::Result {
+        encode_percents(f, self.0.as_ref())
+    }
+}
+
+pub(crate) struct EncOsStr<T: ?Sized>(pub T);
+
+impl Encodable for EncOsStr<&Cow<'_, OsStr>> {
+    fn encode(&self, f: &mut fmt::Formatter<'_>) -> std::fmt::Result {
+        encode_percents(f, self.0.to_string_lossy().as_bytes())
+    }
+}
+
+impl Encodable for EncOsStr<&OsStr> {
+    fn encode(&self, f: &mut fmt::Formatter<'_>) -> std::fmt::Result {
+        encode_percents(f, self.0.to_string_lossy().as_bytes())
+    }
+}
+
 fn is_allowed_char(c: char) -> bool {
     matches!(c, '-' | '0'..='9' | 'A'..='Z' | 'a'..='z' | '_' | '/' | '.' | '\\' | '*')
 }