Struct Path

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

A broadcast path that provides safe prefix matching operations.

This type wraps a String but provides path-aware operations that respect delimiter boundaries, preventing issues like “foo” matching “foobar”.

Paths are automatically trimmed of leading and trailing slashes on creation, making all slashes implicit at boundaries. All paths are RELATIVE; you cannot join with a leading slash to make an absolute path.

Examples

use moq_lite::{Path, PathRef};

// Creation automatically trims slashes
let path1 = Path::new("/foo/bar/");
let path2 = Path::new("foo/bar");
assert_eq!(path1, path2);

// Methods accept both &str and &Path via PathRef
let base = Path::new("api/v1");
assert!(base.has_prefix("api"));
assert!(base.has_prefix(&Path::new("api/v1")));

let joined = base.join("users");
assert_eq!(joined.as_str(), "api/v1/users");

Implementations

impl Path

pub fn new<'a>(path: impl Into<PathRef<'a>>) -> Self

Create a new Path from a string or PathRef.

Leading and trailing slashes are automatically trimmed. Multiple consecutive internal slashes are collapsed to single slashes. If a PathRef is provided, sanitization is skipped since PathRef is already normalized.

pub fn has_prefix<'a>(&self, prefix: impl Into<PathRef<'a>>) -> bool

Check if this path has the given prefix, respecting path boundaries.

Unlike String::starts_with, this ensures that “foo” does not match “foobar”. The prefix must either:

• Be exactly equal to this path
• Be followed by a ‘/’ delimiter in the original path
• Be empty (matches everything)

Examples

use moq_lite::Path;

let path = Path::new("foo/bar");
assert!(path.has_prefix("foo"));
assert!(path.has_prefix(&Path::new("foo")));
assert!(path.has_prefix("foo/"));
assert!(!path.has_prefix("fo"));

let path = Path::new("foobar");
assert!(!path.has_prefix("foo"));

pub fn strip_prefix<'a>( &self, prefix: impl Into<PathRef<'a>>, ) -> Option<PathRef<'_>>

Strip the given prefix from this path, returning the suffix.

Returns None if the prefix doesn’t match according to has_prefix rules.

Examples

use moq_lite::Path;

let path = Path::new("foo/bar/baz");
let suffix = path.strip_prefix("foo").unwrap();
assert_eq!(suffix.as_str(), "bar/baz");

let prefix = Path::new("foo/");
let suffix = path.strip_prefix(&prefix).unwrap();
assert_eq!(suffix.as_str(), "bar/baz");

pub fn as_str(&self) -> &str

Get the path as a string slice.

pub fn is_empty(&self) -> bool

Check if the path is empty.

pub fn len(&self) -> usize

Get the length of the path in bytes.

pub fn join<'a>(&self, other: impl Into<PathRef<'a>>) -> Path

Join this path with another path component.

Examples

use moq_lite::Path;

let base = Path::new("foo");
let joined = base.join("bar");
assert_eq!(joined.as_str(), "foo/bar");

let joined = base.join(&Path::new("bar"));
assert_eq!(joined.as_str(), "foo/bar");

Trait Implementations

impl AsRef<str> for Path

fn as_ref(&self) -> &str

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

impl Clone for Path

fn clone(&self) -> Path

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Path

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

Formats the value using the given formatter.

impl Decode for Path

fn decode<R: Buf>(r: &mut R) -> Result<Self, DecodeError>

impl Default for Path

fn default() -> Path

Returns the “default value” for a type.

impl Display for Path

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

Formats the value using the given formatter.

impl Encode for Path

fn encode<W: BufMut>(&self, w: &mut W)

impl From<&Path> for Path

fn from(p: &Path) -> Self

Converts to this type from the input type.

impl<'a> From<&'a Path> for PathRef<'a>

fn from(p: &'a Path) -> Self

Converts to this type from the input type.

impl From<&String> for Path

fn from(s: &String) -> Self

Converts to this type from the input type.

impl From<&str> for Path

fn from(s: &str) -> Self

Converts to this type from the input type.

impl From<PathRef<'_>> for Path

fn from(p: PathRef<'_>) -> Self

Converts to this type from the input type.

impl From<String> for Path

fn from(s: String) -> Self

Converts to this type from the input type.

impl Hash for Path

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, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Path

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl Eq for Path

impl StructuralPartialEq for Path