Struct Path 

pub struct Path<'a>(/* 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_net::{Path};

// 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
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<'a> Path<'a>

pub fn new(s: &'a str) -> Path<'a>

Create a new Path from a string slice.

Leading and trailing slashes are automatically trimmed. Multiple consecutive internal slashes are collapsed to single slashes.

pub fn has_prefix(&self, prefix: impl AsPath) -> 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_net::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 AsPath) -> Option<Path<'a>>

pub fn next_part(&'a self) -> Option<(&'a str, Path<'a>)>

Strip the directory component of the path, if any, and return the rest of the path.

pub fn as_str(&self) -> &str

pub fn empty() -> Path<'static>

pub fn is_empty(&self) -> bool

pub fn len(&self) -> usize

pub fn to_owned(&self) -> Path<'static>

pub fn into_owned(self) -> Path<'static>

pub fn borrow(&'a self) -> Path<'a>

pub fn join(&self, other: impl AsPath) -> Path<'static>

Join this path with another path component.

Examples

use moq_net::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<'a> AsPath for &'a Path<'a>

fn as_path(&self) -> Path<'a>

impl AsPath for Path<'_>

fn as_path(&self) -> Path<'_>

impl AsRef<str> for Path<'_>

fn as_ref(&self) -> &str

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

impl<'a> Clone for Path<'a>

fn clone(&self) -> Path<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Path<'a>

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

Formats the value using the given formatter.

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<(), Error>

Formats the value using the given formatter.

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

fn from(s: &'a String) -> Path<'a>

Converts to this type from the input type.

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

fn from(s: &'a str) -> Path<'a>

Converts to this type from the input type.

impl From<String> for Path<'_>

fn from(s: String) -> Path<'_>

Converts to this type from the input type.

impl FromIterator<Path<'static>> for PathPrefixes

fn from_iter<I>(iter: I) -> PathPrefixes

where I: IntoIterator<Item = Path<'static>>,

Creates a value from an iterator.

impl<'a> Hash for Path<'a>

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

where __H: Hasher,

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<'a> PartialEq for Path<'a>

fn eq(&self, other: &Path<'a>) -> 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<'a> Eq for Path<'a>

impl<'a> StructuralPartialEq for Path<'a>