use std::convert::{TryFrom, TryInto}; use static_assertions::assert_impl_all; use crate::{ names::{BusName, InterfaceName, MemberName, UniqueName}, zvariant::{ObjectPath, Str}, Error, MatchRule, MatchRulePathSpec, MessageType, Result, }; const MAX_ARGS: u8 = 64; /// Builder for [`MatchRule`]. /// /// This is created by [`MatchRule::builder`]. #[derive(Debug)] pub struct MatchRuleBuilder<'m>(MatchRule<'m>); assert_impl_all!(MatchRuleBuilder<'_>: Send, Sync, Unpin); impl<'m> MatchRuleBuilder<'m> { /// Build the `MatchRule`. pub fn build(self) -> MatchRule<'m> { self.0 } /// Set the sender. pub fn sender(mut self, sender: B) -> Result where B: TryInto>, B::Error: Into, { self.0.sender = Some(sender.try_into().map_err(Into::into)?); Ok(self) } /// Set the message type. pub fn msg_type(mut self, msg_type: MessageType) -> Self { self.0.msg_type = Some(msg_type); self } /// Set the interface. pub fn interface(mut self, interface: I) -> Result where I: TryInto>, I::Error: Into, { self.0.interface = Some(interface.try_into().map_err(Into::into)?); Ok(self) } /// Set the member. pub fn member(mut self, member: M) -> Result where M: TryInto>, M::Error: Into, { self.0.member = Some(member.try_into().map_err(Into::into)?); Ok(self) } /// Set the path. /// /// Note: Since both a path and a path namespace are not allowed to appear in a match rule at /// the same time, this overrides any path namespace previously set. pub fn path

(mut self, path: P) -> Result where P: TryInto>, P::Error: Into, { self.0.path_spec = path .try_into() .map(MatchRulePathSpec::Path) .map(Some) .map_err(Into::into)?; Ok(self) } /// Set the path namespace. /// /// Note: Since both a path and a path namespace are not allowed to appear in a match rule at /// the same time, this overrides any path previously set. pub fn path_namespace

(mut self, path_namespace: P) -> Result where P: TryInto>, P::Error: Into, { self.0.path_spec = path_namespace .try_into() .map(MatchRulePathSpec::PathNamespace) .map(Some) .map_err(Into::into)?; Ok(self) } /// Set the destination. pub fn destination(mut self, destination: B) -> Result where B: TryInto>, B::Error: Into, { self.0.destination = Some(destination.try_into().map_err(Into::into)?); Ok(self) } /// Append an arguments. /// /// Use this in instead of [`MatchRuleBuilder::arg`] if you want to sequentially add args. /// /// # Errors /// /// [`Error::InvalidMatchRule`] on attempt to add the 65th argument. pub fn add_arg(self, arg: S) -> Result where S: Into>, { let idx = self.0.args.len() as u8; self.arg(idx, arg) } /// Add an argument of a specified index. /// /// # Errors /// /// [`Error::InvalidMatchRule`] if `idx` is greater than 64. pub fn arg(mut self, idx: u8, arg: S) -> Result where S: Into>, { if idx >= MAX_ARGS { return Err(Error::InvalidMatchRule); } let value = (idx, arg.into()); let vec_idx = match self.0.args().binary_search_by(|(i, _)| i.cmp(&idx)) { Ok(i) => { // If the argument is already present, replace it. self.0.args.remove(i); i } Err(i) => i, }; self.0.args.insert(vec_idx, value); Ok(self) } /// Append a path argument. /// /// Use this in instead of [`MatchRuleBuilder::arg_path`] if you want to sequentially add args. /// /// # Errors /// /// [`Error::InvalidMatchRule`] on attempt to add the 65th path argument. pub fn add_arg_path

(self, arg_path: P) -> Result where P: TryInto>, P::Error: Into, { let idx = self.0.arg_paths.len() as u8; self.arg_path(idx, arg_path) } /// Add a path argument of a specified index. /// /// # Errors /// /// [`Error::InvalidMatchRule`] if `idx` is greater than 64. pub fn arg_path

(mut self, idx: u8, arg_path: P) -> Result where P: TryInto>, P::Error: Into, { if idx >= MAX_ARGS { return Err(Error::InvalidMatchRule); } let value = (idx, arg_path.try_into().map_err(Into::into)?); let vec_idx = match self.0.arg_paths().binary_search_by(|(i, _)| i.cmp(&idx)) { Ok(i) => { // If the argument is already present, replace it. self.0.arg_paths.remove(i); i } Err(i) => i, }; self.0.arg_paths.insert(vec_idx, value); Ok(self) } /// Set 0th argument's namespace. /// /// This function is deprecated because the choice of `InterfaceName` was too restrictive. #[deprecated = "use arg0ns instead"] pub fn arg0namespace(mut self, namespace: I) -> Result where I: TryInto>, I::Error: Into, { let namespace = namespace.try_into().map_err(Into::into)?; self.0.arg0namespace = Some(namespace.clone()); self.0.arg0ns = Some(namespace.into()); Ok(self) } /// Set 0th argument's namespace. /// /// The namespace be a valid bus name or a valid element of a bus name. For more information, /// see [the spec](https://dbus.freedesktop.org/doc/dbus-specification.html#message-protocol-names-bus). /// /// # Examples /// /// ``` /// # use zbus::MatchRule; /// // Valid namespaces /// MatchRule::builder().arg0ns("org.mpris.MediaPlayer2").unwrap(); /// MatchRule::builder().arg0ns("org").unwrap(); /// MatchRule::builder().arg0ns(":org").unwrap(); /// MatchRule::builder().arg0ns(":1org").unwrap(); /// /// // Invalid namespaces /// MatchRule::builder().arg0ns("org.").unwrap_err(); /// MatchRule::builder().arg0ns(".org").unwrap_err(); /// MatchRule::builder().arg0ns("1org").unwrap_err(); /// MatchRule::builder().arg0ns(".").unwrap_err(); /// MatchRule::builder().arg0ns("org..freedesktop").unwrap_err(); /// ```` pub fn arg0ns(mut self, namespace: S) -> Result where S: Into>, { let namespace: Str<'m> = namespace.into(); // Rules: https://dbus.freedesktop.org/doc/dbus-specification.html#message-protocol-names-bus // minus the requirement to have more than one element. if namespace.is_empty() || namespace.len() > 255 { return Err(Error::InvalidMatchRule); } let (is_unique, namespace_str) = match namespace.strip_prefix(':') { Some(s) => (true, s), None => (false, namespace.as_str()), }; let valid_first_char = |s: &str| match s.chars().next() { None | Some('.') => false, Some('0'..='9') if !is_unique => false, _ => true, }; if !valid_first_char(namespace_str) || !namespace_str.split('.').all(valid_first_char) || !namespace_str .chars() .all(|c| c.is_ascii_alphanumeric() || c == '-' || c == '_' || c == '.') { return Err(Error::InvalidMatchRule); } self.0.arg0ns = Some(namespace.clone()); self.0.arg0namespace = InterfaceName::try_from(namespace).ok(); Ok(self) } /// Create a builder for `MatchRuleBuilder`. pub(crate) fn new() -> Self { Self(MatchRule { msg_type: None, sender: None, interface: None, member: None, path_spec: None, destination: None, args: Vec::with_capacity(MAX_ARGS as usize), arg_paths: Vec::with_capacity(MAX_ARGS as usize), arg0namespace: None, arg0ns: None, }) } }