Struct async_rustbus::rustbus_core::path::ObjectPath

pub struct ObjectPath { /* fields omitted */ }

A slice of a Dbus object path akin to a str or std::path::Path.

Contains some methods for manipulating Dbus object paths, similiar to std::path::Path with some minor differences.

Implementations

impl ObjectPath

pub fn from_path<P: AsRef<Path> + ?Sized>(
    p: &P
) -> Result<&ObjectPath, InvalidObjectPath>

Validate and make a ObjectPath from a normal path.

See module root for the rules of a valid ObjectPath.

Examples

use async_rustbus::rustbus_core::path::ObjectPath;
let path = ObjectPath::from_str("/example/path").unwrap();
ObjectPath::from_str("invalid/because/not/absolute").unwrap_err();
ObjectPath::from_str("/invalid/because//double/sep").unwrap_err();

pub fn from_str(s: &str) -> Result<&ObjectPath, InvalidObjectPath>

pub fn as_bytes(&self) -> &[u8]

Get the bytes that make up an ObjectPath.

pub fn as_str(&self) -> &str

Get the ObjectPath as a &str.

Unlike ordinary std::path::Path, ObjectPaths are always valid Rust strs making this possible.

pub fn strip_prefix<P: AsRef<Path> + ?Sized>(
    &self,
    p: &P
) -> Result<&ObjectPath, StripPrefixError>

Strip the prefix of the ObjectPath.

Unlike Path::strip_prefix this method will always leave the path will always remain absolute.

Examples

use async_rustbus::rustbus_core::path::ObjectPath;
let original  = ObjectPath::from_str("/example/path/to_strip").unwrap();
let target = ObjectPath::from_str("/path/to_strip").unwrap();
/* These two lines are equivelent because paths must always remain absolute,
   so the root '/' is readded in the second example.
   Note the second line is not a valid ObjectPath */
let stripped0 = original.strip_prefix("/example").unwrap();
let stripped1 = original.strip_prefix("/example/").unwrap();
assert_eq!(stripped0, target);
assert_eq!(stripped1, target);

original.strip_prefix("/example/other").unwrap_err();
original.strip_prefix("/example/pa").unwrap_err();

// Because the only thing stripped is the root sep this does nothing as it gets readded.
let stripped2 = original.strip_prefix("/").unwrap();
assert_eq!(stripped2, original);
let stripped3 = original.strip_prefix(original).unwrap();
assert_eq!(stripped3, ObjectPath::root_path());

pub fn parent(&self) -> Option<&ObjectPath>

Get the parent of the ObjectPath by removing the last element. If the ObjectPath is a root path then None is returned.

pub fn file_name(&self) -> Option<&str>

Retrieves the last element of the ObjectPath. If the ObjectPath is a root path then None is returned.

pub fn root_path() -> &'static Self

Return a ObjectPath consisting of a single / seperator.

pub fn components(&self) -> impl Iterator<Item = &str>

Returns an Iterator over the elements of an ObjectPath.

pub fn to_object_path_buf(&self) -> ObjectPathBuf

Trait Implementations

impl AsRef<ObjectPath> for ObjectPath

fn as_ref(&self) -> &ObjectPath

Performs the conversion.

impl AsRef<ObjectPath> for ObjectPathBuf

fn as_ref(&self) -> &ObjectPath

Performs the conversion.

impl AsRef<OsStr> for ObjectPath

fn as_ref(&self) -> &OsStr

Performs the conversion.

impl AsRef<Path> for ObjectPath

fn as_ref(&self) -> &Path

Performs the conversion.

impl AsRef<str> for ObjectPath

fn as_ref(&self) -> &str

Performs the conversion.

impl Borrow<ObjectPath> for ObjectPathBuf

fn borrow(&self) -> &ObjectPath

Immutably borrows from an owned value.

impl Borrow<Path> for ObjectPath

fn borrow(&self) -> &Path

Immutably borrows from an owned value.

impl Debug for ObjectPath

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

Formats the value using the given formatter.

impl Deref for ObjectPath

type Target = Path

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl Display for ObjectPath

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

Formats the value using the given formatter.

impl From<&'_ ObjectPath> for ObjectPathBuf

fn from(path: &ObjectPath) -> Self

Performs the conversion.

impl<'a> From<&'a ObjectPath> for &'a str

fn from(path: &'a ObjectPath) -> Self

Performs the conversion.

impl Hash for ObjectPath

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given Hasher.

impl Marshal for &ObjectPath

fn marshal(&self, ctx: &mut MarshalContext<'_, '_>) -> Result<(), Error>

fn marshal_as_variant(
    &self,
    ctx: &mut MarshalContext<'_, '_>
) -> Result<(), Error>

impl Ord for ObjectPath

fn cmp(&self, other: &ObjectPath) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

Restrict a value to a certain interval.

impl PartialEq<ObjectPath> 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: &ObjectPath) -> bool

This method tests for !=.

impl PartialEq<ObjectPath> for ObjectPathBuf

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 !=.

impl PartialOrd<ObjectPath> for ObjectPath

fn partial_cmp(&self, other: &ObjectPath) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

This method tests less than (for self and other) and is used by the < operator.

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

This method tests less than or equal to (for self and other) and is used by the <= operator.

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

This method tests greater than (for self and other) and is used by the > operator.

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

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl Signature for &ObjectPath

fn signature() -> Type

fn alignment() -> usize

fn sig_str(s_buf: &mut SignatureBuffer)

Appends the signature of the type to the SignatureBuffer.

unsafe fn valid_slice(_bo: ByteOrder) -> bool

If this returns true, it indicates that for implementing type T, Rust’s [T] is identical to DBus’s array format and can be copied into a message after aligning the first element.

fn has_sig(sig: &str) -> bool

Check if this type fulfills this signature. This may expect to only be called with valid signatures. But it might be called with the wrong signature. This means for example you must check the length before indexing.

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)

🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

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

impl<'a> TryFrom<&'a Path> for &'a ObjectPath

type Error = InvalidObjectPath

The type returned in the event of a conversion error.

fn try_from(p: &'a Path) -> Result<Self, Self::Error>

Performs the conversion.

impl<'a> TryFrom<&'a str> for &'a ObjectPath

type Error = InvalidObjectPath

The type returned in the event of a conversion error.

fn try_from(s: &'a str) -> Result<Self, Self::Error>

Performs the conversion.

impl<'buf, 'fds> Unmarshal<'buf, 'fds> for &'buf ObjectPath

fn unmarshal(ctx: &mut UnmarshalContext<'fds, 'buf>) -> UnmarshalResult<Self>

impl Eq for ObjectPath

impl StructuralEq for ObjectPath

impl StructuralPartialEq for ObjectPath