Enum SegmentedPathName 

pub enum SegmentedPathName<'a> {
    Single(SafePathSegment<'a>),
    Prefixed(SafePathSegment<'a>, SafePathSegment<'a>),
}

One or two validated path segments for a fetch URL built from a package name.

Covers both a bare identifier and a <prefix>/<name>-shaped one — the split shape shared by npm’s @scope/pkg and Composer’s vendor/package registry-fetch URLs.

Each ecosystem keeps its own parsing (npm strips a leading @ before splitting; Composer splits on the first / with no scope marker), so this type carries only the already-split, already-validated result — never the splitting logic itself.

Examples

use deps_core::path_segment::{SafePathSegment, SegmentedPathName};

let bare = SegmentedPathName::Single(SafePathSegment::new("left-pad").unwrap());
let prefixed = SegmentedPathName::Prefixed(
    SafePathSegment::new("monolog").unwrap(),
    SafePathSegment::new("monolog").unwrap(),
);
assert!(matches!(bare, SegmentedPathName::Single(_)));
assert!(matches!(prefixed, SegmentedPathName::Prefixed(_, _)));

Variants

Single(SafePathSegment<'a>)

A single, unprefixed path segment (Composer’s fallback bare form, npm’s unscoped name).

Prefixed(SafePathSegment<'a>, SafePathSegment<'a>)

A <prefix>/<name> pair, each independently validated (npm’s @scope/pkg, Composer’s vendor/package).

Trait Implementations

impl<'a> Clone for SegmentedPathName<'a>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Copy for SegmentedPathName<'a>

impl<'a> Debug for SegmentedPathName<'a>

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

Formats the value using the given formatter.

impl<'a> Eq for SegmentedPathName<'a>

impl<'a> Hash for SegmentedPathName<'a>

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

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

Equality operator ==.

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

Inequality operator !=.

impl<'a> StructuralPartialEq for SegmentedPathName<'a>