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. A path names a point in the origin’s tree from its root; a leading slash never escapes that root. The same type names an exact broadcast and the prefix a route or announcement covers, so a broadcast’s own path is the prefix it announces. See Relative for ..-style references.

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: &Relative<'_>) -> PathOwned

Resolve a Relative against this path.

A non-empty reference replaces the last segment of the base, matching relative URL resolution. .. segments then pop another segment; 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.

Relative::new strips empty and redundant . segments, but preserves a lone . so it can reference the base’s parent.

Examples

use moq_net::{Path, path::Relative};

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

pub fn try_resolve(&self, rel: &Relative<'_>) -> Option<PathOwned>

Resolve a Relative, returning None if it escapes above the root.

Unlike Path::resolve, this distinguishes a valid reference to the empty root path from excess .. segments. Use it when an untrusted relative reference must not be clamped to the root.

pub fn relative(&self, base: impl AsPath) -> Option<RelativeOwned>

Express this path relative to base: the inverse of Path::resolve.

The result round-trips (base.resolve(&rel) == self) and never walks above the root, so Path::try_resolve accepts it too.

A relative reference replaces the last segment of the base, matching relative URL resolution, so a target nested under the base repeats the base’s own last segment.

The empty reference names the base itself, so that is what a self-reference returns.

Returns None for a target no reference can name: a path segment may literally be . or .., which resolution reads as navigation instead of as a name. Only the segments past the shared prefix matter, since the rest are never emitted.

Examples

use moq_net::Path;

// The base names a broadcast, so its last segment is replaced, not descended into.
let base = Path::new("a/b");
assert_eq!(Path::new("a/b/c").relative(&base).unwrap().as_str(), "b/c");
assert_eq!(Path::new("a/c").relative(&base).unwrap().as_str(), "c");
assert_eq!(Path::new("c").relative(&base).unwrap().as_str(), "../c");

// The lone `.` names the base's parent, which the empty reference cannot.
assert_eq!(Path::new("a").relative(&base).unwrap().as_str(), ".");

// The base itself.
assert_eq!(Path::new("a/b").relative(&base).unwrap().as_str(), "");

// A segment named `..` is a legal path component but an unnameable target.
assert!(Path::new("a/..").relative(&base).is_none());

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

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

fn clamp_to<R>(self, range: R) -> Self

where Self: Sized, R: ClampBounds<Self>,

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

Restrict a value to a certain range.

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.