Separate conversation drafts and voice view state, add native settings and restricted CSS themes, implement validated avatar cropping, and refresh dependencies with documented desktop compatibility backports.
886 lines
31 KiB
Rust
Vendored
886 lines
31 KiB
Rust
Vendored
#![allow(unused_macros)]
|
|
#![allow(dead_code)]
|
|
#![allow(unused_imports)]
|
|
|
|
use std::{fs, path::PathBuf, str::FromStr};
|
|
|
|
use crate::Result;
|
|
|
|
/// Resolve XML path from either:
|
|
///
|
|
/// - provided argument,
|
|
/// - default location (`xml/`, `XML/`, `../xml` or `../XML`) or
|
|
/// - env_variable (`LOCKSTEP_XML_PATH`)
|
|
///
|
|
/// If no XML path is provided, it tries to find the default XML path.
|
|
/// If the environment variable is set, it overrides the default, or
|
|
/// argument path.
|
|
///
|
|
/// # Example
|
|
///
|
|
/// ```rust
|
|
/// # use zbus_lockstep::resolve_xml_path;
|
|
/// # use std::path::PathBuf;
|
|
/// # fn main() {
|
|
/// // path to XML files
|
|
/// std::env::set_var("LOCKSTEP_XML_PATH", "../xml");
|
|
///
|
|
/// let xml_path = resolve_xml_path(None).unwrap();
|
|
/// assert_eq!(xml_path, PathBuf::from("../xml").canonicalize().unwrap());
|
|
/// # }
|
|
/// ```
|
|
/// # Panics
|
|
///
|
|
/// Panics if no XML path is provided and the default XML path is not found.
|
|
pub fn resolve_xml_path(xml: Option<&str>) -> Result<PathBuf> {
|
|
let mut xml = xml;
|
|
let current_dir: PathBuf = PathBuf::from(
|
|
std::env::var("CARGO_MANIFEST_DIR")
|
|
.expect("the CARGO_MANIFEST_DIR environment variable should be set"),
|
|
);
|
|
|
|
// We want to know the name of the crate we are expanded in.
|
|
let crate_name = std::env::var("CARGO_PKG_NAME").unwrap_or_else(|_| String::from("unknown"));
|
|
|
|
let current_dir_lower_case = current_dir.join("xml");
|
|
let current_dir_upper_case = current_dir.join("XML");
|
|
|
|
let parent_dir_lower_case = current_dir.join("../xml");
|
|
let parent_dir_upper_case = current_dir.join("../XML");
|
|
|
|
let crate_dir_lower_case = current_dir.join(&crate_name).join("xml");
|
|
let crate_dir_upper_case = current_dir.join(&crate_name).join("XML");
|
|
|
|
// If no XML path is provided, try to find the default XML path.
|
|
if xml.is_none() {
|
|
if current_dir_lower_case.exists() {
|
|
xml = Some(
|
|
current_dir_lower_case
|
|
.to_str()
|
|
.expect("current_dir_lower_case is valid UTF-8"),
|
|
);
|
|
}
|
|
|
|
if current_dir_upper_case.exists() {
|
|
xml = Some(
|
|
current_dir_upper_case
|
|
.to_str()
|
|
.expect("current_dir_upper_case is valid UTF-8"),
|
|
);
|
|
}
|
|
|
|
if parent_dir_lower_case.exists() {
|
|
xml = Some(
|
|
parent_dir_lower_case
|
|
.to_str()
|
|
.expect("parent_dir_lower_case is valid UTF-8"),
|
|
);
|
|
}
|
|
|
|
if parent_dir_upper_case.exists() {
|
|
xml = Some(
|
|
parent_dir_upper_case
|
|
.to_str()
|
|
.expect("parent_dir_upper_case is valid UTF-8"),
|
|
);
|
|
}
|
|
|
|
if crate_dir_lower_case.exists() {
|
|
xml = Some(
|
|
crate_dir_lower_case
|
|
.to_str()
|
|
.expect("crate_dir_lower_case is valid UTF-8"),
|
|
);
|
|
}
|
|
|
|
if crate_dir_upper_case.exists() {
|
|
xml = Some(
|
|
crate_dir_upper_case
|
|
.to_str()
|
|
.expect("crate_dir_upper_case is valid UTF-8"),
|
|
);
|
|
}
|
|
}
|
|
|
|
let env_xml_path = std::env::var("LOCKSTEP_XML_PATH");
|
|
if env_xml_path.is_ok() {
|
|
// Override the default, or argument path if the environment variable is set.
|
|
xml = env_xml_path.as_ref().map(|s| s.as_str()).ok();
|
|
}
|
|
|
|
// If no XML path is provided and the default XML path is not found, panic.
|
|
if xml.is_none() {
|
|
panic!(
|
|
"No XML path provided and default XML path not found. Current dir: \"{}\" ",
|
|
current_dir.to_str().expect("current_dir is valid UTF-8")
|
|
);
|
|
}
|
|
|
|
// Convert, canonicalize and return the XML path.
|
|
let xml = PathBuf::from_str(xml.unwrap())?;
|
|
Ok(xml.canonicalize()?)
|
|
}
|
|
|
|
/// A generic helper to find the file path and interface name of a member.
|
|
#[doc(hidden)]
|
|
#[macro_export]
|
|
macro_rules! find_definition_in_dbus_xml {
|
|
($xml_path_buf:expr, $member:expr, $iface:expr, $msg_type:expr) => {{
|
|
use $crate::MsgType;
|
|
|
|
let xml_path_buf: std::path::PathBuf = $xml_path_buf;
|
|
let member: &str = $member;
|
|
let iface: Option<String> = $iface;
|
|
let msg_type: MsgType = $msg_type;
|
|
|
|
let mut xml_file_path = None;
|
|
let mut interface_name = None;
|
|
|
|
let read_dir = std::fs::read_dir(&xml_path_buf).expect("Failed to read XML directory");
|
|
|
|
// Walk the XML files in the directory.
|
|
for entry in read_dir {
|
|
let entry = entry.expect("Failed to read entry");
|
|
|
|
// Skip directories and non-XML files.
|
|
if entry.path().is_dir() || entry.path().extension() != Some(std::ffi::OsStr::new("xml")) {
|
|
continue;
|
|
}
|
|
|
|
let entry_path = entry.path().clone();
|
|
let file = std::fs::File::open(entry.path()).expect("Failed to open file");
|
|
let node = $crate::zbus_xml::Node::from_reader(file).expect("Failed to parse XML file");
|
|
|
|
for interface in node.interfaces() {
|
|
// If called with an `iface` arg, skip he interfaces that do not match.
|
|
if iface.is_some() && interface.name().as_str() != iface.clone().unwrap() {
|
|
continue;
|
|
}
|
|
|
|
match msg_type {
|
|
MsgType::Method => {
|
|
for dbus_item in interface.methods() {
|
|
if dbus_item.name() == member {
|
|
if interface_name.is_some() {
|
|
panic!(
|
|
"Multiple interfaces offer the same {:?} member: {}, please specify the interface name.",
|
|
msg_type, member
|
|
);
|
|
}
|
|
interface_name = Some(interface.name().to_string());
|
|
xml_file_path = Some(entry_path.clone());
|
|
}
|
|
}
|
|
}
|
|
MsgType::Signal => {
|
|
for dbus_item in interface.signals() {
|
|
if dbus_item.name() == member {
|
|
if interface_name.is_some() {
|
|
panic!(
|
|
"Multiple interfaces offer the same {:?} member: {}, please specify the interface name.",
|
|
msg_type, member
|
|
);
|
|
}
|
|
interface_name = Some(interface.name().to_string());
|
|
xml_file_path = Some(entry_path.clone());
|
|
}
|
|
}
|
|
}
|
|
MsgType::Property => {
|
|
for dbus_item in interface.properties() {
|
|
if dbus_item.name() == member {
|
|
if interface_name.is_some() {
|
|
panic!(
|
|
"Multiple interfaces offer the same {:?} member: {}, please specify the interface name.",
|
|
msg_type, member
|
|
);
|
|
}
|
|
interface_name = Some(interface.name().to_string());
|
|
xml_file_path = Some(entry_path.clone());
|
|
}
|
|
}
|
|
}
|
|
};
|
|
}
|
|
}
|
|
|
|
// If the interface member was not found, return an error.
|
|
if xml_file_path.is_none() {
|
|
panic!("Member not found in XML files.");
|
|
}
|
|
|
|
(xml_file_path.unwrap(), interface_name.unwrap())
|
|
}};
|
|
}
|
|
|
|
/// Retrieve the signature of a method's return type.
|
|
///
|
|
/// This macro will take a method member name and return the signature of the
|
|
/// return type.
|
|
///
|
|
/// Essentially a wrapper around [`zbus_lockstep::get_method_return_type`],
|
|
/// but this macro tries to do its job with less arguments.
|
|
///
|
|
/// It will search in the XML specification of the method for the return type
|
|
/// and return the signature of that type.
|
|
///
|
|
/// If multiple interfaces offer the same method, you will need to specify the
|
|
/// interface name as well.
|
|
///
|
|
/// This macro can be called with or without the interface name.
|
|
///
|
|
/// # Examples
|
|
///
|
|
/// Basic usage:
|
|
///
|
|
/// ```rust
|
|
/// use std::str::FromStr;
|
|
/// use zbus_lockstep::method_return_signature;
|
|
/// use zbus::wire::Signature;
|
|
///
|
|
/// std::env::set_var("LOCKSTEP_XML_PATH", "../xml");
|
|
///
|
|
/// let sig = method_return_signature!("RequestName");
|
|
/// assert_eq!(&sig, &Signature::from_str("u").expect("Valid signature pattern"));
|
|
/// ```
|
|
/// The macro supports colling arguments with identifiers as well as without.
|
|
/// The macro may also be called with an interface name or interface and argument name:
|
|
///
|
|
/// ```rust
|
|
/// # use zbus_lockstep::{method_return_signature};
|
|
/// # std::env::set_var("LOCKSTEP_XML_PATH", "../xml");
|
|
/// let _sig = method_return_signature!("RequestName", "org.example.Node", "grape");
|
|
///
|
|
/// // or alternatively
|
|
///
|
|
/// let _sig = method_return_signature!(member: "RequestName", interface: "org.example.Node", argument: "grape");
|
|
/// ```
|
|
#[macro_export]
|
|
macro_rules! method_return_signature {
|
|
($member:expr) => {{
|
|
use $crate::MsgType;
|
|
let member = $member;
|
|
|
|
// Looking for default path or path specified by environment variable.
|
|
let current_dir: std::path::PathBuf = std::env::current_dir().unwrap();
|
|
let xml_path = $crate::resolve_xml_path(None).expect(&format!(
|
|
"Failed to resolve XML path, current dir: {}",
|
|
current_dir.to_str().unwrap()
|
|
));
|
|
|
|
// Find the definition of the method in the XML specification.
|
|
let (file_path, interface_name) =
|
|
$crate::find_definition_in_dbus_xml!(xml_path, member, None, MsgType::Method);
|
|
|
|
let file = std::fs::File::open(file_path).expect("Failed to open file");
|
|
$crate::get_method_return_type(file, &interface_name, member, None)
|
|
.expect("Failed to get method arguments type signature")
|
|
}};
|
|
|
|
(member: $member:expr) => {
|
|
$crate::method_return_signature!($member)
|
|
};
|
|
|
|
($member:expr, $interface:expr) => {{
|
|
let member = $member;
|
|
use $crate::MsgType;
|
|
|
|
let interface = Some($interface.to_string());
|
|
|
|
// Looking for default path or path specified by environment variable.
|
|
let current_dir: std::path::PathBuf = std::env::current_dir().unwrap();
|
|
let xml_path = $crate::resolve_xml_path(None).expect(&format!(
|
|
"Failed to resolve XML path, current dir: {}",
|
|
current_dir.to_str().unwrap()
|
|
));
|
|
|
|
// Find the definition of the method in the XML specification.
|
|
let (file_path, interface_name) =
|
|
$crate::find_definition_in_dbus_xml!(xml_path, member, interface, MsgType::Method);
|
|
|
|
let file = std::fs::File::open(file_path).expect("Failed to open file");
|
|
$crate::get_method_return_type(file, &interface_name, member, None)
|
|
.expect("Failed to get method arguments type signature")
|
|
}};
|
|
|
|
(member: $member:expr, interface: $interface:expr) => {
|
|
$crate::method_return_signature!($member, $interface)
|
|
};
|
|
|
|
($member:expr, $interface:expr, $argument:expr) => {{
|
|
let member = $member;
|
|
use $crate::MsgType;
|
|
|
|
let interface = Some($interface.to_string());
|
|
let argument = Some($argument);
|
|
|
|
// Looking for default path or path specified by environment variable.
|
|
let current_dir: std::path::PathBuf = std::env::current_dir().unwrap();
|
|
let xml_path = $crate::resolve_xml_path(None).expect(&format!(
|
|
"Failed to resolve XML path, current dir: {}",
|
|
current_dir.to_str().unwrap()
|
|
));
|
|
|
|
// Find the definition of the method in the XML specification.
|
|
let (file_path, interface_name) =
|
|
$crate::find_definition_in_dbus_xml!(xml_path, member, interface, MsgType::Method);
|
|
|
|
let file = std::fs::File::open(file_path).expect("Failed to open file");
|
|
$crate::get_method_return_type(file, &interface_name, member, argument)
|
|
.expect("Failed to get method argument(s) type signature")
|
|
}};
|
|
|
|
(member: $member:expr, interface: $interface:expr, argument: $argument:expr) => {
|
|
$crate::method_return_signature!($member, $interface, $argument)
|
|
};
|
|
}
|
|
|
|
/// Retrieve the signature of a method's arguments.
|
|
///
|
|
/// Essentially a wrapper around [`zbus_lockstep::get_method_args_type`],
|
|
/// but this macro tries to do its job with less arguments.
|
|
///
|
|
/// This macro will take a method member name and return the signature of the
|
|
/// arguments type.
|
|
///
|
|
/// It will search in the XML specification of the method for the arguments type
|
|
/// and return the signature of that type.
|
|
///
|
|
/// If multiple interfaces offer the same member, you will need to
|
|
/// specify the interface name as well.
|
|
///
|
|
/// This macro can be called with or without the interface name.
|
|
///
|
|
/// # Examples
|
|
///
|
|
/// ```rust
|
|
/// use std::str::FromStr;
|
|
/// use zbus_lockstep::method_args_signature;
|
|
/// use zbus::wire::Signature;
|
|
///
|
|
/// std::env::set_var("LOCKSTEP_XML_PATH", "../xml");
|
|
///
|
|
/// let sig = method_args_signature!("RequestName");
|
|
/// assert_eq!(&sig, &Signature::from_str("(su)").expect("Valid signature pattern"));
|
|
/// ```
|
|
/// The macro supports colling arguments with identifiers as well as without.
|
|
/// The macro may also be called with an interface name or interface and argument name:
|
|
///
|
|
/// ```rust
|
|
/// # use zbus_lockstep::{method_args_signature};
|
|
/// # std::env::set_var("LOCKSTEP_XML_PATH", "../xml");
|
|
/// let _sig = method_args_signature!("RequestName", "org.example.Node", "apple");
|
|
///
|
|
/// // or alternatively
|
|
///
|
|
/// let _sig = method_args_signature!(member: "RequestName", interface: "org.example.Node", argument: "apple");
|
|
/// ```
|
|
#[macro_export]
|
|
macro_rules! method_args_signature {
|
|
($member:expr) => {{
|
|
use $crate::MsgType;
|
|
let member = $member;
|
|
|
|
// Looking for default path or path specified by environment variable.
|
|
let current_dir: std::path::PathBuf = std::env::current_dir().unwrap();
|
|
let xml_path = $crate::resolve_xml_path(None).expect(&format!(
|
|
"Failed to resolve XML path, current dir: {}",
|
|
current_dir.to_str().unwrap()
|
|
));
|
|
|
|
// Find the definition of the method in the XML specification.
|
|
let (file_path, interface_name) =
|
|
$crate::find_definition_in_dbus_xml!(xml_path, member, None, MsgType::Method);
|
|
|
|
let file = std::fs::File::open(file_path).expect("Failed to open file");
|
|
$crate::get_method_args_type(file, &interface_name, member, None)
|
|
.expect("Failed to get method arguments type signature")
|
|
}};
|
|
|
|
(member: $member:expr) => {
|
|
$crate::method_args_signature!($member)
|
|
};
|
|
|
|
($member:expr, $interface:expr) => {{
|
|
use $crate::MsgType;
|
|
let member = $member;
|
|
|
|
let interface = Some($interface.to_string());
|
|
|
|
// Looking for default path or path specified by environment variable.
|
|
let current_dir: std::path::PathBuf = std::env::current_dir().unwrap();
|
|
let xml_path = $crate::resolve_xml_path(None).expect(&format!(
|
|
"Failed to resolve XML path, current dir: {}",
|
|
current_dir.to_str().unwrap()
|
|
));
|
|
|
|
// Find the definition of the method in the XML specification.
|
|
let (file_path, interface_name) =
|
|
$crate::find_definition_in_dbus_xml!(xml_path, member, interface, MsgType::Method);
|
|
|
|
let file = std::fs::File::open(file_path).expect("Failed to open file");
|
|
$crate::get_method_args_type(file, &interface_name, member, None)
|
|
.expect("Failed to get method arguments type signature")
|
|
}};
|
|
|
|
(member: $member:expr, interface: $interface:expr) => {
|
|
$crate::method_args_signature!($member, $interface)
|
|
};
|
|
|
|
($member:expr, $interface:expr, $argument:expr) => {{
|
|
use $crate::MsgType;
|
|
let member = $member;
|
|
let interface = Some($interface.to_string());
|
|
|
|
let argument = Some($argument);
|
|
|
|
// Looking for default path or path specified by environment variable.
|
|
let current_dir: std::path::PathBuf = std::env::current_dir().unwrap();
|
|
|
|
let xml_path = $crate::resolve_xml_path(None).expect(&format!(
|
|
"Failed to resolve XML path, current dir: {}",
|
|
current_dir.to_str().unwrap()
|
|
));
|
|
// Find the definition of the method in the XML specification.
|
|
let (file_path, interface_name) =
|
|
$crate::find_definition_in_dbus_xml!(xml_path, member, interface, MsgType::Method);
|
|
|
|
let file = std::fs::File::open(file_path).expect("Failed to open file");
|
|
$crate::get_method_args_type(file, &interface_name, member, argument)
|
|
.expect("Failed to get method argument(s) type signature")
|
|
}};
|
|
|
|
(member: $member:expr, interface: $interface:expr, argument: $argument:expr) => {
|
|
$crate::method_args_signature!($member, $interface, $argument)
|
|
};
|
|
}
|
|
|
|
/// Retrieve the signature of a signal's body type.
|
|
///
|
|
/// Essentially a wrapper around [`zbus_lockstep::get_signal_body_type`],
|
|
/// but this macro tries to find it with less arguments.
|
|
///
|
|
/// This macro will take a signal member name and return the signature of the
|
|
/// signal body type.
|
|
///
|
|
/// If multiple interfaces offer the same member, you will need to
|
|
/// specify the interface name as well.
|
|
///
|
|
/// This macro can be called with or without the interface name.
|
|
///
|
|
/// # Examples
|
|
///
|
|
/// ```rust
|
|
/// use std::str::FromStr;
|
|
/// use zbus_lockstep::signal_body_type_signature;
|
|
/// use zbus::wire::Signature;
|
|
///
|
|
/// std::env::set_var("LOCKSTEP_XML_PATH", "../xml");
|
|
///
|
|
/// let sig = signal_body_type_signature!("AddNode");
|
|
/// assert_eq!(&sig, &Signature::from_str("(so)").expect("Valid signature pattern"));
|
|
/// ```
|
|
/// The macro supports colling arguments with identifiers as well as without.
|
|
/// The macro may also be called with an interface name or interface and argument name:
|
|
///
|
|
/// ```rust
|
|
/// # use zbus_lockstep::{signal_body_type_signature};
|
|
/// # std::env::set_var("LOCKSTEP_XML_PATH", "../xml");
|
|
/// let _sig = signal_body_type_signature!("Alert", "org.example.Node", "color");
|
|
///
|
|
/// // or alternatively
|
|
///
|
|
/// let _sig = signal_body_type_signature!(member: "Alert", interface: "org.example.Node", argument: "color");
|
|
/// ```
|
|
#[macro_export]
|
|
macro_rules! signal_body_type_signature {
|
|
($member:expr) => {{
|
|
use $crate::MsgType;
|
|
let member = $member;
|
|
|
|
// Looking for default path or path specified by environment variable.
|
|
let current_dir: std::path::PathBuf = std::env::current_dir().unwrap();
|
|
let xml_path = $crate::resolve_xml_path(None).expect(&format!(
|
|
"Failed to resolve XML path, current dir: {}",
|
|
current_dir.to_str().unwrap()
|
|
));
|
|
|
|
// Find the definition of the method in the XML specification.
|
|
let (file_path, interface_name) =
|
|
$crate::find_definition_in_dbus_xml!(xml_path, member, None, MsgType::Signal);
|
|
|
|
let file = std::fs::File::open(file_path).expect("Failed to open file");
|
|
|
|
$crate::get_signal_body_type(file, &interface_name, member, None)
|
|
.expect("Failed to get method arguments type signature")
|
|
}};
|
|
|
|
(member: $member:expr) => {
|
|
$crate::signal_body_type_signature!($member)
|
|
};
|
|
|
|
($member:expr, $interface:expr) => {{
|
|
use $crate::MsgType;
|
|
let member = $member;
|
|
let interface = Some($interface.to_string());
|
|
|
|
// Looking for default path or path specified by environment variable.
|
|
let current_dir: std::path::PathBuf = std::env::current_dir().unwrap();
|
|
let xml_path = $crate::resolve_xml_path(None).expect(&format!(
|
|
"Failed to resolve XML path, current dir: {}",
|
|
current_dir.to_str().unwrap()
|
|
));
|
|
|
|
// Find the definition of the method in the XML specification.
|
|
let (file_path, interface_name) =
|
|
$crate::find_definition_in_dbus_xml!(xml_path, member, interface, MsgType::Signal);
|
|
|
|
let file = std::fs::File::open(file_path).expect("Failed to open file");
|
|
$crate::get_signal_body_type(file, &interface_name, member, None)
|
|
.expect("Failed to get method arguments type signature")
|
|
}};
|
|
|
|
(member: $member:expr, interface: $interface:expr) => {
|
|
$crate::signal_body_type_signature!($member, $interface)
|
|
};
|
|
|
|
($member:expr, $interface:expr, $argument:expr) => {{
|
|
use $crate::MsgType;
|
|
let member = $member;
|
|
let interface = Some($interface.to_string());
|
|
|
|
let argument = Some($argument);
|
|
|
|
// Looking for default path or path specified by environment variable.
|
|
let current_dir: std::path::PathBuf = std::env::current_dir().unwrap();
|
|
|
|
let xml_path = $crate::resolve_xml_path(None).expect(&format!(
|
|
"Failed to resolve XML path, current dir: {}",
|
|
current_dir.to_str().unwrap()
|
|
));
|
|
|
|
// Find the definition of the method in the XML specification.
|
|
let (file_path, interface_name) =
|
|
$crate::find_definition_in_dbus_xml!(xml_path, member, interface, MsgType::Signal);
|
|
|
|
let file = std::fs::File::open(file_path).expect("Failed to open file");
|
|
$crate::get_signal_body_type(file, &interface_name, member, argument)
|
|
.expect("Failed to get method argument(s) type signature")
|
|
}};
|
|
|
|
(member: $member:expr, interface: $interface:expr, argument: $argument:expr) => {
|
|
$crate::signal_body_type_signature!($member, $interface, $argument)
|
|
};
|
|
}
|
|
|
|
/// Retrieve the signature of a property's type.
|
|
///
|
|
/// Essentially a wrapper around [`zbus_lockstep::get_property_type`],
|
|
/// but this macro tries to do with less arguments.
|
|
///
|
|
/// This macro will take a property name and return the signature of the
|
|
/// property's type.
|
|
///
|
|
/// If multiple interfaces offer the same member, you will need to
|
|
/// specify the interface name as well.
|
|
///
|
|
/// This macro can be called with or without the interface name.
|
|
///
|
|
/// # Examples
|
|
///
|
|
/// ```rust
|
|
/// use std::str::FromStr;
|
|
/// use zbus_lockstep::property_type_signature;
|
|
/// use zbus::wire::Signature;
|
|
///
|
|
/// std::env::set_var("LOCKSTEP_XML_PATH", "../xml");
|
|
///
|
|
/// let sig = property_type_signature!("Features");
|
|
/// assert_eq!(&sig, &Signature::from_str("as").expect("Valid signature pattern"));
|
|
/// ```
|
|
/// The member name and/or interface name can be used tp identify the arguments:
|
|
///
|
|
/// ```rust
|
|
/// # use zbus_lockstep::{property_type_signature};
|
|
/// # std::env::set_var("LOCKSTEP_XML_PATH", "../xml");
|
|
/// let _sig = property_type_signature!(member: "Features", interface: "org.example.Node");
|
|
/// ```
|
|
#[macro_export]
|
|
macro_rules! property_type_signature {
|
|
($member:expr) => {{
|
|
use $crate::MsgType;
|
|
let member = $member;
|
|
|
|
// Looking for default path or path specified by environment variable.
|
|
let current_dir: std::path::PathBuf = std::env::current_dir().unwrap();
|
|
let xml_path = $crate::resolve_xml_path(None).expect(&format!(
|
|
"Failed to resolve XML path, current dir: {}",
|
|
current_dir.to_str().unwrap()
|
|
));
|
|
|
|
// Find the definition of the method in the XML specification.
|
|
let (file_path, interface_name) =
|
|
$crate::find_definition_in_dbus_xml!(xml_path, member, None, MsgType::Property);
|
|
|
|
let file = std::fs::File::open(file_path).expect("Failed to open file");
|
|
|
|
$crate::get_property_type(file, &interface_name, member)
|
|
.expect("Failed to get property type signature")
|
|
}};
|
|
|
|
(member: $member:expr) => {
|
|
$crate::property_type_signature!($member)
|
|
};
|
|
|
|
($member:expr, $interface:expr) => {{
|
|
use $crate::MsgType;
|
|
let member = $member;
|
|
let interface = Some($interface.to_string());
|
|
|
|
// Looking for default path or path specified by environment variable.
|
|
let current_dir: std::path::PathBuf = std::env::current_dir().unwrap();
|
|
let xml_path = $crate::resolve_xml_path(None).expect(&format!(
|
|
"Failed to resolve XML path, current dir: {}",
|
|
current_dir.to_str().unwrap()
|
|
));
|
|
|
|
// Find the definition of the method in the XML specification.
|
|
let (file_path, interface_name) =
|
|
$crate::find_definition_in_dbus_xml!(xml_path, member, interface, MsgType::Property);
|
|
|
|
let file = std::fs::File::open(file_path).expect("Failed to open file");
|
|
$crate::get_property_type(file, &interface_name, member)
|
|
.expect("Failed to get property type signature")
|
|
}};
|
|
|
|
(member: $member:expr, interface: $interface:expr) => {
|
|
$crate::property_type_signature!($member, $interface)
|
|
};
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod test {
|
|
use std::str::FromStr;
|
|
|
|
use zbus::wire::Signature;
|
|
|
|
use crate::signal_body_type_signature;
|
|
|
|
#[test]
|
|
fn test_signal_body_signature_macro() {
|
|
// path to XML files can be set by environment variable
|
|
// std::env::set_var("LOCKSTEP_XML_PATH", "../xml");
|
|
// But `resolve_xml_path` can find the `xml` in parent by itself.
|
|
|
|
let sig = crate::signal_body_type_signature!("AddNode");
|
|
assert_eq!(
|
|
&sig,
|
|
&zbus::wire::Signature::from_str("(so)").expect("Valid signature pattern")
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_signal_body_signature_macro_with_identifier() {
|
|
let sig = crate::signal_body_type_signature!(member: "AddNode");
|
|
assert_eq!(
|
|
sig,
|
|
Signature::from_str("(so)").expect("Valid signature pattern")
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_signal_body_signature_macro_with_interface() {
|
|
let sig = crate::signal_body_type_signature!("AddNode", "org.example.Node");
|
|
assert_eq!(
|
|
sig,
|
|
Signature::from_str("(so)").expect("Valid signature pattern")
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_signal_body_signature_macro_with_interface_and_identifiers() {
|
|
let sig =
|
|
crate::signal_body_type_signature!(member: "AddNode", interface: "org.example.Node");
|
|
assert_eq!(
|
|
sig,
|
|
Signature::from_str("(so)").expect("Valid signature pattern")
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_signal_body_signature_macro_with_argument_and_interface() {
|
|
let sig = crate::signal_body_type_signature!("Alert", "org.example.Node", "volume");
|
|
assert_eq!(
|
|
sig,
|
|
Signature::from_str("d").expect("Valid signature pattern")
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_signal_body_signature_macro_with_argument_and_identifiers_and_interface() {
|
|
let sig = crate::signal_body_type_signature!(
|
|
member: "Alert",
|
|
interface: "org.example.Node",
|
|
argument: "urgent"
|
|
);
|
|
assert_eq!(
|
|
sig,
|
|
Signature::from_str("b").expect("Valid signature pattern")
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_method_args_signature_macro() {
|
|
let sig = crate::method_args_signature!("RequestName");
|
|
assert_eq!(
|
|
sig,
|
|
Signature::from_str("(su)").expect("Valid signature pattern")
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_method_args_signature_macro_with_identifier() {
|
|
let sig = crate::method_args_signature!(member: "RequestName");
|
|
assert_eq!(
|
|
sig,
|
|
Signature::from_str("(su)").expect("Valid signature pattern")
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_method_args_signature_macro_with_interface() {
|
|
let sig = crate::method_args_signature!("RequestName", "org.example.Node");
|
|
assert_eq!(
|
|
sig,
|
|
Signature::from_str("(su)").expect("Valid signature pattern")
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_method_args_signature_macro_with_interface_and_identifiers() {
|
|
let sig =
|
|
crate::method_args_signature!(member: "RequestName", interface: "org.example.Node");
|
|
assert_eq!(
|
|
sig,
|
|
Signature::from_str("(su)").expect("Valid signature pattern")
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_method_args_signature_macro_with_argument_and_interface() {
|
|
let sig = crate::method_args_signature!("RequestName", "org.example.Node", "apple");
|
|
assert_eq!(
|
|
sig,
|
|
Signature::from_str("s").expect("Valid signature pattern")
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_method_args_signature_macro_with_argument_and_identifiers_and_interface() {
|
|
let sig = crate::method_args_signature!(
|
|
member: "RequestName",
|
|
interface: "org.example.Node",
|
|
argument: "orange"
|
|
);
|
|
assert_eq!(
|
|
sig,
|
|
Signature::from_str("u").expect("Valid signature pattern")
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_method_return_signature_macro() {
|
|
let sig = crate::method_return_signature!("RequestName");
|
|
assert_eq!(
|
|
sig,
|
|
Signature::from_str("u").expect("Valid signatuee pattern")
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_method_return_signature_macro_with_identifier() {
|
|
let sig = crate::method_return_signature!(member: "RequestName");
|
|
assert_eq!(
|
|
sig,
|
|
Signature::from_str("u").expect("Valid signature pattern")
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_method_return_signature_macro_with_interface() {
|
|
let sig = crate::method_return_signature!("RequestName", "org.example.Node");
|
|
assert_eq!(
|
|
sig,
|
|
Signature::from_str("u").expect("Valid signature pattern")
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_method_return_signature_macro_with_interface_and_identifiers() {
|
|
let sig =
|
|
crate::method_return_signature!(member: "RequestName", interface: "org.example.Node");
|
|
assert_eq!(
|
|
sig,
|
|
Signature::from_str("u").expect("Vlaid signature pattern")
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_method_return_signature_macro_with_argument_and_interface() {
|
|
let sig = crate::method_return_signature!("RequestName", "org.example.Node", "grape");
|
|
assert_eq!(
|
|
sig,
|
|
Signature::from_str("u").expect("Vlaid signature pattern")
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_method_return_signature_macro_with_argument_and_identifiers_and_interface() {
|
|
let sig = crate::method_return_signature!(
|
|
member: "RequestName",
|
|
interface: "org.example.Node",
|
|
argument: "grape"
|
|
);
|
|
assert_eq!(
|
|
sig,
|
|
Signature::from_str("u").expect("Vlaid signature pattern")
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_property_type_signature_macro() {
|
|
let sig = crate::property_type_signature!("Features");
|
|
assert_eq!(
|
|
sig,
|
|
Signature::from_str("as").expect("Vlaid signature pattern")
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_property_type_signature_macro_with_identifier() {
|
|
let sig = crate::property_type_signature!(member: "Features");
|
|
assert_eq!(
|
|
sig,
|
|
Signature::from_str("as").expect("Vlaid signature pattern")
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_property_type_signature_macro_with_interface() {
|
|
let sig = crate::property_type_signature!("Features", "org.example.Node");
|
|
assert_eq!(
|
|
sig,
|
|
Signature::from_str("as").expect("Vlaid signature pattern")
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_property_type_signature_macro_with_interface_and_identifiers() {
|
|
let sig =
|
|
crate::property_type_signature!(member: "Features", interface: "org.example.Node");
|
|
assert_eq!(
|
|
sig,
|
|
Signature::from_str("as").expect("Vlaid signature pattern")
|
|
);
|
|
}
|
|
}
|