🚚 zb: rename DBusAddr to Address

As requested by Zeeshan.

zbus/src/address/address.rs

@@ -10,16 +10,16 @@ use super::{
 ///
 /// Example:
 /// ```
-/// use zbus::DBusAddr;
+/// use zbus::Address;
 ///
-/// let _: DBusAddr = "unix:path=/tmp/dbus.sock".try_into().unwrap();
+/// let _: Address = "unix:path=/tmp/dbus.sock".try_into().unwrap();
 /// ```
 #[derive(Debug, PartialEq, Eq, Clone)]
-pub struct DBusAddr<'a> {
+pub struct Address<'a> {
     pub(super) addr: Cow<'a, str>,
 }
 
-impl<'a> DBusAddr<'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())
@@ -82,30 +82,30 @@ fn validate_guid(value: &[u8]) -> Result<()> {
     Ok(())
 }
 
-impl DBusAddr<'_> {
-    pub fn to_owned(&self) -> DBusAddr<'static> {
+impl Address<'_> {
+    pub fn to_owned(&self) -> Address<'static> {
         let addr = self.addr.to_string();
-        DBusAddr { addr: addr.into() }
+        Address { addr: addr.into() }
     }
 }
 
-impl<'a> TryFrom<String> for DBusAddr<'a> {
+impl<'a> TryFrom<String> for Address<'a> {
     type Error = Error;
 
     fn try_from(addr: String) -> Result<Self> {
         Self::new(addr)
     }
 }
 
-impl<'a> TryFrom<&'a str> for DBusAddr<'a> {
+impl<'a> TryFrom<&'a str> for Address<'a> {
     type Error = Error;
 
     fn try_from(addr: &'a str) -> Result<Self> {
         Self::new(addr)
     }
 }
 
-impl fmt::Display for DBusAddr<'_> {
+impl fmt::Display for Address<'_> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let kv = KeyValFmt::new().add("guid", self.guid());
         let t = self.transport().map_err(|_| fmt::Error)?;
@@ -191,43 +191,43 @@ impl fmt::Display for KeyValFmt<'_> {
     }
 }
 
-/// A trait for objects which can be converted or resolved to one or more [`DBusAddr`] values.
-pub trait ToDBusAddrs<'a> {
-    type Iter: Iterator<Item = Result<DBusAddr<'a>>>;
+/// A trait for objects which can be converted or resolved to one or more [`Address`] values.
+pub trait ToAddresses<'a> {
+    type Iter: Iterator<Item = Result<Address<'a>>>;
 
-    fn to_dbus_addrs(&'a self) -> Self::Iter;
+    fn to_addresses(&'a self) -> Self::Iter;
 }
 
-impl<'a> ToDBusAddrs<'a> for DBusAddr<'a> {
-    type Iter = std::iter::Once<Result<DBusAddr<'a>>>;
+impl<'a> ToAddresses<'a> for Address<'a> {
+    type Iter = std::iter::Once<Result<Address<'a>>>;
 
     /// Get an iterator over the D-Bus addresses.
-    fn to_dbus_addrs(&'a self) -> Self::Iter {
+    fn to_addresses(&'a self) -> Self::Iter {
         std::iter::once(Ok(self.clone()))
     }
 }
 
-impl<'a> ToDBusAddrs<'a> for str {
-    type Iter = std::iter::Once<Result<DBusAddr<'a>>>;
+impl<'a> ToAddresses<'a> for str {
+    type Iter = std::iter::Once<Result<Address<'a>>>;
 
-    fn to_dbus_addrs(&'a self) -> Self::Iter {
+    fn to_addresses(&'a self) -> Self::Iter {
         std::iter::once(self.try_into())
     }
 }
 
-impl<'a> ToDBusAddrs<'a> for String {
-    type Iter = std::iter::Once<Result<DBusAddr<'a>>>;
+impl<'a> ToAddresses<'a> for String {
+    type Iter = std::iter::Once<Result<Address<'a>>>;
 
-    fn to_dbus_addrs(&'a self) -> Self::Iter {
+    fn to_addresses(&'a self) -> Self::Iter {
         std::iter::once(self.as_str().try_into())
     }
 }
 
-impl<'a> ToDBusAddrs<'a> for Vec<Result<DBusAddr<'_>>> {
-    type Iter = std::iter::Cloned<std::slice::Iter<'a, Result<DBusAddr<'a>>>>;
+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_dbus_addrs(&'a self) -> Self::Iter {
+    fn to_addresses(&'a self) -> Self::Iter {
         self.iter().cloned()
     }
 }

zbus/src/address/address_list.rs

@@ -1,26 +1,26 @@
 use std::{borrow::Cow, fmt};
 
-use super::{DBusAddr, Error, Result, ToDBusAddrs};
+use super::{Address, Error, Result, ToAddresses};
 
 /// A bus address list.
 ///
 /// D-Bus addresses are `;`-separated.
 #[derive(Debug, PartialEq, Eq, Clone)]
-pub struct DBusAddrList<'a> {
+pub struct AddressList<'a> {
     addr: Cow<'a, str>,
 }
 
-impl<'a> ToDBusAddrs<'a> for DBusAddrList<'a> {
-    type Iter = DBusAddrListIter<'a>;
+impl<'a> ToAddresses<'a> for AddressList<'a> {
+    type Iter = AddressListIter<'a>;
 
     /// Get an iterator over the D-Bus addresses.
-    fn to_dbus_addrs(&'a self) -> Self::Iter {
-        DBusAddrListIter::new(self)
+    fn to_addresses(&'a self) -> Self::Iter {
+        AddressListIter::new(self)
     }
 }
 
-impl<'a> Iterator for DBusAddrListIter<'a> {
-    type Item = Result<DBusAddr<'a>>;
+impl<'a> Iterator for AddressListIter<'a> {
+    type Item = Result<Address<'a>>;
 
     fn next(&mut self) -> Option<Self::Item> {
         if self.next_index >= self.data.len() {
@@ -34,26 +34,26 @@ impl<'a> Iterator for DBusAddrListIter<'a> {
         } else {
             self.next_index = self.data.len();
         }
-        Some(DBusAddr::try_from(addr))
+        Some(Address::try_from(addr))
     }
 }
 
 /// An iterator of D-Bus addresses.
-pub struct DBusAddrListIter<'a> {
+pub struct AddressListIter<'a> {
     data: &'a str,
     next_index: usize,
 }
 
-impl<'a> DBusAddrListIter<'a> {
-    fn new(list: &'a DBusAddrList<'_>) -> Self {
+impl<'a> AddressListIter<'a> {
+    fn new(list: &'a AddressList<'_>) -> Self {
         Self {
             data: list.addr.as_ref(),
             next_index: 0,
         }
     }
 }
 
-impl<'a> TryFrom<String> for DBusAddrList<'a> {
+impl<'a> TryFrom<String> for AddressList<'a> {
     type Error = Error;
 
     fn try_from(value: String) -> Result<Self> {
@@ -63,7 +63,7 @@ impl<'a> TryFrom<String> for DBusAddrList<'a> {
     }
 }
 
-impl<'a> TryFrom<&'a str> for DBusAddrList<'a> {
+impl<'a> TryFrom<&'a str> for AddressList<'a> {
     type Error = Error;
 
     fn try_from(value: &'a str) -> Result<Self> {
@@ -73,7 +73,7 @@ impl<'a> TryFrom<&'a str> for DBusAddrList<'a> {
     }
 }
 
-impl fmt::Display for DBusAddrList<'_> {
+impl fmt::Display for AddressList<'_> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "{}", self.addr)
     }

zbus/src/address/mod.rs

@@ -29,10 +29,10 @@ pub mod transport;
 
 #[allow(clippy::module_inception)]
 mod address;
-pub use address::{DBusAddr, ToDBusAddrs};
+pub use address::{Address, ToAddresses};
 
 mod address_list;
-pub use address_list::{DBusAddrList, DBusAddrListIter};
+pub use address_list::{AddressList, AddressListIter};
 
 mod percent;
 pub use percent::*;
@@ -75,13 +75,13 @@ pub type Result<T> = std::result::Result<T, Error>;
 /// Get the address for session socket respecting the DBUS_SESSION_BUS_ADDRESS environment
 /// variable. If we don't recognize the value (or it's not set) we fall back to
 /// $XDG_RUNTIME_DIR/bus
-pub fn session() -> Result<DBusAddrList<'static>> {
+pub fn session() -> Result<AddressList<'static>> {
     match env::var("DBUS_SESSION_BUS_ADDRESS") {
-        Ok(val) => DBusAddrList::try_from(val),
+        Ok(val) => AddressList::try_from(val),
         _ => {
             #[cfg(windows)]
             {
-                DBusAddrList::try_from("autolaunch:scope=*user;autolaunch:")
+                AddressList::try_from("autolaunch:scope=*user;autolaunch:")
             }
 
             #[cfg(all(unix, not(target_os = "macos")))]
@@ -90,12 +90,12 @@ pub fn session() -> Result<DBusAddrList<'static>> {
                     .unwrap_or_else(|_| format!("/run/user/{}", Uid::effective()));
                 let path = format!("unix:path={runtime_dir}/bus");
 
-                DBusAddrList::try_from(path)
+                AddressList::try_from(path)
             }
 
             #[cfg(target_os = "macos")]
             {
-                DBusAddrList::try_from("launchd:env=DBUS_LAUNCHD_SESSION_BUS_SOCKET")
+                AddressList::try_from("launchd:env=DBUS_LAUNCHD_SESSION_BUS_SOCKET")
             }
         }
     }
@@ -104,18 +104,18 @@ pub fn session() -> Result<DBusAddrList<'static>> {
 /// Get the address for system bus respecting the DBUS_SYSTEM_BUS_ADDRESS environment
 /// variable. If we don't recognize the value (or it's not set) we fall back to
 /// /var/run/dbus/system_bus_socket
-pub fn system() -> Result<DBusAddrList<'static>> {
+pub fn system() -> Result<AddressList<'static>> {
     match env::var("DBUS_SYSTEM_BUS_ADDRESS") {
-        Ok(val) => DBusAddrList::try_from(val),
+        Ok(val) => AddressList::try_from(val),
         _ => {
             #[cfg(all(unix, not(target_os = "macos")))]
-            return DBusAddrList::try_from("unix:path=/var/run/dbus/system_bus_socket");
+            return AddressList::try_from("unix:path=/var/run/dbus/system_bus_socket");
 
             #[cfg(windows)]
-            return DBusAddrList::try_from("autolaunch:");
+            return AddressList::try_from("autolaunch:");
 
             #[cfg(target_os = "macos")]
-            return DBusAddrList::try_from("launchd:env=DBUS_LAUNCHD_SESSION_BUS_SOCKET");
+            return AddressList::try_from("launchd:env=DBUS_LAUNCHD_SESSION_BUS_SOCKET");
         }
     }
 }