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.

Owned paths (PathOwned) share one reference-counted allocation: cloning, converting a shared path with Path::to_owned, and suffix operations like Path::strip_prefix do not copy the underlying bytes.

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 const MAX_PARTS: usize = 32

Maximum number of slash-separated parts in a path.

Matches the IETF moq-transport limit of 32 fields in a namespace tuple. moq-lite enforces the same bound: encoding or decoding a deeper path fails, and publishing one to an origin is rejected.

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

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>>

The remainder after removing prefix, or None if it isn’t a prefix.

Only whole segments match: a/bc is not prefixed by a/b. An empty prefix returns the whole path.

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

Iterate over the slash-separated parts of the path.

The empty path has no parts.

Examples

use moq_net::Path;

let path = Path::new("foo/bar/baz");
assert_eq!(path.parts().collect::<Vec<_>>(), ["foo", "bar", "baz"]);
assert_eq!(Path::empty().parts().count(), 0);

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

The normalized path as a string, with no leading or trailing slash.

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

The empty path, which prefixes every other path.

pub fn is_empty(&self) -> bool

Returns true if this is the empty path.

pub fn len(&self) -> usize

The length in bytes, not segments.

pub fn to_owned(&self) -> PathOwned

Clone into a 'static path, sharing the existing buffer when there is one.

pub fn into_owned(self) -> PathOwned

Consume into a 'static path, reusing the existing buffer when there is one.

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

A copy of this path bound to self’s lifetime, without copying the underlying bytes.

pub fn join(&self, other: impl AsPath) -> PathOwned

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");

pub fn resolve(&self, rel: &PathRelative<'_>) -> PathOwned

Resolve a PathRelative against this path.

.. segments in rel pop the last segment of the base; other segments are appended. Excess .. is a no-op once the base is empty (subsequent named segments still append). An empty rel returns this path as an owned copy.

PathRelative::new strips . and empty segments, so they are not handled here.

Examples

use moq_net::{Path, PathRelative};

let base = Path::new("a/b/c");
assert_eq!(base.resolve(&PathRelative::new("../d")).as_str(), "a/b/d");
assert_eq!(base.resolve(&PathRelative::new("d")).as_str(), "a/b/c/d");
assert_eq!(base.resolve(&PathRelative::new("../../../../x")).as_str(), "x");

Trait Implementations

impl<'a> AsPath for &'a Path<'a>

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

Borrow self as a Path, normalizing slashes only when needed.

impl AsPath for Path<'_>

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

Borrow self as a Path, normalizing slashes only when needed.

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 Debug for Path<'_>

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

Formats the value using the given formatter.

impl Default for Path<'_>

fn default() -> Self

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 Eq for Path<'_>

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

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

Converts to this type from the input type.

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

fn from(s: &'a str) -> 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 FromIterator<Path<'static>> for PathPrefixes

fn from_iter<I: IntoIterator<Item = PathOwned>>(iter: I) -> Self

Creates a value from an iterator.

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 Ord for Path<'_>

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

This method returns an Ordering between self and other.

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

where Self: Sized,

Compares and returns the maximum of two values.

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

where Self: Sized,

Compares and returns the minimum of two values.

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

where Self: Sized,

Restrict a value to a certain interval.

impl<'b> PartialEq<Path<'b>> for Path<'_>

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

Equality operator ==.

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

Inequality operator !=.

impl PartialOrd for Path<'_>

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

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

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

Tests less than (for self and other) and is used by the < operator.

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

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

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

Tests greater than (for self and other) and is used by the > operator.

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

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

impl Serialize for Path<'_>

fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error>

Serialize this value into the given Serde serializer.