Struct tokio_dbus::ObjectPath

pub struct ObjectPath(/* private fields */);

A validated object path.

The following rules define a valid object path. Implementations must not send or accept messages with invalid object paths.

• The path may be of any length.
• The path must begin with an ASCII ‘/’ (integer 47) character, and must consist of elements separated by slash characters.
• Each element must only contain the ASCII characters “[A-Z][a-z][0-9]_”
• No element may be the empty string.
• Multiple ‘/’ characters cannot occur in sequence.
• A trailing ‘/’ character is not allowed unless the path is the root path (a single ‘/’ character).

Implementations

impl ObjectPath

pub const ROOT: &'static Self = _

The special "/" object path.

Examples

use tokio_dbus::ObjectPath;

assert_eq!(ObjectPath::ROOT, ObjectPath::new(b"/")?);

pub const fn new_const(path: &[u8]) -> &Self

Construct a new object path.

Panics

Panics if the argument is not a valid object.

See ObjectPath for more information.

pub fn new<P>(path: &P) -> Result<&Self, ObjectPathError>

where P: ?Sized + AsRef<[u8]>,

Construct a new validated object path.

Errors

Errors if the argument is not a valid object.

See ObjectPath for more information.

pub fn iter(&self) -> Iter<'_>

Construct an iterator over the object path.

Examples

use tokio_dbus::ObjectPath;

let mut it = ObjectPath::new_const(b"/").iter();
assert!(it.next().is_none());

let mut it = ObjectPath::new_const(b"/foo").iter();
assert_eq!(it.next(), Some("foo"));
assert!(it.next().is_none());

let mut it = ObjectPath::new_const(b"/foo/bar").iter();
assert_eq!(it.next_back(), Some("bar"));
assert_eq!(it.next(), Some("foo"));
assert!(it.next().is_none());

pub fn starts_with(&self, other: &ObjectPath) -> bool

Test if one part starts with another.

Examples

use tokio_dbus::ObjectPath;

const FOO: &ObjectPath = ObjectPath::new_const(b"/foo");
const FOO_BAR: &ObjectPath = ObjectPath::new_const(b"/foo/bar");

assert!(FOO_BAR.starts_with(FOO));

Trait Implementations

impl AsRef<[u8]> for ObjectPath

fn as_ref(&self) -> &[u8]

Converts this type into a shared reference of the (usually inferred) input type.

impl AsRef<ObjectPath> for ObjectPath

fn as_ref(&self) -> &ObjectPath

Converts this type into a shared reference of the (usually inferred) input type.

impl AsRef<ObjectPath> for ObjectPathBuf

fn as_ref(&self) -> &ObjectPath

Converts this type into a shared reference of the (usually inferred) input type.

impl Borrow<ObjectPath> for ObjectPathBuf

fn borrow(&self) -> &ObjectPath

Immutably borrows from an owned value.

impl Clone for Box<ObjectPath>

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ObjectPath

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Display for ObjectPath

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl From<&ObjectPath> for Box<ObjectPath>

fn from(object_path: &ObjectPath) -> Self

Converts to this type from the input type.

impl<'a> IntoIterator for &'a ObjectPath

The IntoIterator implementation for ObjectPath.

Examples

use tokio_dbus::ObjectPath;

const PATH: &ObjectPath = ObjectPath::new_const(b"/foo/bar");

let mut values = Vec::new();

for s in PATH {
    values.push(s);
}

assert_eq!(values, ["foo", "bar"]);

type Item = &'a str

The type of the elements being iterated over.

type IntoIter = Iter<'a>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl PartialEq for ObjectPath

fn eq(&self, other: &ObjectPath) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl ToOwned for ObjectPath

type Owned = ObjectPathBuf

The resulting type after obtaining ownership.

fn to_owned(&self) -> Self::Owned

Creates owned data from borrowed data, usually by cloning.

fn clone_into(&self, target: &mut Self::Owned)

Uses borrowed data to replace owned data, usually by cloning.

impl Arguments for ObjectPath

impl Eq for ObjectPath

impl Read for ObjectPath

impl Storable for &ObjectPath

Storable implementation for &ObjectPath.

Examples

use tokio_dbus::BodyBuf;
use tokio_dbus::ObjectPath;

let mut body = BodyBuf::new();

body.store(10u16)?;
body.store(ObjectPath::new("/se/tedro/DBusExample")?)?;

assert_eq!(body.signature(), "qo");

impl StructuralPartialEq for ObjectPath

impl Write for ObjectPath