Struct UserInfo 

pub struct UserInfo { /* private fields */ }

Available on crate feature net only.

Raw RFC 3986 userinfo bytes. Cheap to clone.

Logging safety

The Debug impl redacts the password portion (anything after the first :) as "***", matching Basic’s logging behaviour. This is the safe default for tracing spans and log lines, where a raw Debug-print of a Uri would otherwise leak credentials into observability sinks. The user portion is rendered raw; pct-encoded bytes are not decoded for the Debug view.

Implementations

impl UserInfo

pub const fn from_static(s: &'static str) -> UserInfo

Construct from a compile-time string. Zero-allocation.

Panics at compile time if s contains a byte outside the RFC 3986 §3.2.1 userinfo grammar (unreserved / pct-encoded / sub-delims / ":"). This matches the URI parser’s strict-mode validation: byte sets stay single-sourced, and typed construction can never produce a UserInfo that the parser would reject.

Naming: from_static matches the Uri::from_static / Domain::from_static precedent across the rest of the crate.

pub fn as_bytes(&self) -> &[u8]

Raw on-the-wire bytes (possibly pct-encoded — not decoded here).

pub fn as_str(&self) -> &str

&str view of the raw bytes. Parser-validated UTF-8.

pub fn view(&self) -> UserInfoRef<'_>

Borrowed view. Named view (not as_ref) so it doesn’t shadow the std AsRef trait — see the type-level docs.

pub fn split_user_password(&self) -> (&[u8], Option<&[u8]>)

Split on the first :. Returns (user_bytes, password_bytes) where the password is None if no : is present.

Bytes are raw — not percent-decoded. Use crate::uri::util::percent_encoding to decode if needed.

pub fn to_basic(&self) -> Result<Basic, Box<dyn Error + Send + Sync>>

Convenience: convert this userinfo into a Basic HTTP Basic-Auth credential. Fails if the user portion is empty (Basic requires a non-empty username) or if either part is not valid UTF-8.

Trait Implementations

impl Clone for UserInfo

fn clone(&self) -> UserInfo

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for UserInfo

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

Formats the value using the given formatter.

impl Display for UserInfo

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

Formats the value using the given formatter.

impl<'a> From<&'a UserInfo> for UserInfoRef<'a>

fn from(u: &'a UserInfo) -> UserInfoRef<'a>

Converts to this type from the input type.

impl From<Basic> for UserInfo

Construct a UserInfo from a Basic credential.

Spec divergence

Basic only rejects raw \r / \n / NUL bytes in its validation, while UserInfo’s own TryFrom enforces the full RFC 3986 §3.2.1 userinfo grammar (rejects raw @, space, gen-delims, malformed pct, pct-decoded control bytes). So this From impl can produce a UserInfo containing bytes that UserInfo::try_from would reject — Basic::new("user@host", "pw")? round-tripped through this conversion will emit user@host:pw and serialize into a URI authority that the parser then refuses to re-read.

This is deliberate (the conversion is infallible by trait signature), and the planned follow-up is to drop UserInfo in favour of a relaxed Basic altogether (see the type-level docs for the migration plan). For now, callers that need the round-trip guarantee should validate through UserInfo::try_from first.

fn from(basic: Basic) -> UserInfo

Converts to this type from the input type.

impl FromStr for UserInfo

type Err = Box<dyn Error + Send + Sync>

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<UserInfo, <UserInfo as FromStr>::Err>

Parses a string s to return a value of this type.

impl Hash for UserInfo

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 Ord for UserInfo

fn cmp(&self, other: &UserInfo) -> 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 PartialEq for UserInfo

fn eq(&self, other: &UserInfo) -> 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 PartialOrd for UserInfo

fn partial_cmp(&self, other: &UserInfo) -> 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 TryFrom<&UserInfo> for Basic

fn try_from( value: &UserInfo, ) -> Result<Basic, <Basic as TryFrom<&UserInfo>>::Error>

Parse a UserInfo into HTTP Basic-Auth credentials. Same semantics as UserInfo::to_basic — kept as a TryFrom impl for the standard Basic::try_from(&userinfo)? idiom.

type Error = Box<dyn Error + Send + Sync>

The type returned in the event of a conversion error.

impl TryFrom<&str> for UserInfo

fn try_from(s: &str) -> Result<UserInfo, <UserInfo as TryFrom<&str>>::Error>

Validate s against the RFC 3986 §3.2.1 userinfo grammar — same byte set the URI parser uses in strict mode. Rejects:

• Control bytes anywhere.
• Raw @ (must be percent-encoded as %40).
• Raw space, brackets, gen-delims, and other non-userinfo bytes.
• Malformed pct-escapes (%X truncated, %XY non-hex).
• Pct-decoded control bytes (smuggling vector).

Without this guard, Uri::set_authority(authority_with_loose_userinfo) could embed bytes the parser would otherwise reject — producing URIs that round-trip into malformed wire form.

type Error = Box<dyn Error + Send + Sync>

The type returned in the event of a conversion error.

impl TryFrom<String> for UserInfo

type Error = Box<dyn Error + Send + Sync>

The type returned in the event of a conversion error.

fn try_from(s: String) -> Result<UserInfo, <UserInfo as TryFrom<String>>::Error>

Performs the conversion.

impl TryFrom<UserInfo> for Basic

fn try_from( value: UserInfo, ) -> Result<Basic, <Basic as TryFrom<UserInfo>>::Error>

Owned-input form of TryFrom<&UserInfo>. Routes through the borrowed impl since Basic::try_from doesn’t need to own the bytes.

type Error = Box<dyn Error + Send + Sync>

The type returned in the event of a conversion error.

impl Eq for UserInfo

impl StructuralPartialEq for UserInfo