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 as_decoded_str(&self) -> Cow<'_, str>

Percent-decoded view of the full userinfo. Cow::Borrowed when no %XX escapes are present; UTF-8 errors fall back to U+FFFD.

Lossy for re-splitting: a %3A in the user part decodes to a literal :. Use UserInfo::username_decoded / UserInfo::password_decoded to decode the components separately.

pub fn username_decoded(&self) -> Cow<'_, str>

Percent-decoded user component (everything before the first raw :).

pub fn password_decoded(&self) -> Option<Cow<'_, str>>

Percent-decoded password component (everything after the first raw :), or None if no : is present.

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

Convenience: convert this userinfo into a Basic HTTP Basic-Auth credential. The components are percent-decoded first (so user%40host becomes user@host), then validated. See UserInfoRef::to_basic for the failure modes.

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

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 by percent-encoding each component into the RFC 3986 §3.2.1 userinfo wire form. The username escapes : (so the first literal : is unambiguously the user/password separator); the password keeps : literal. @, space, and every other non-userinfo byte become %XX, so the result re-parses cleanly through UserInfo::try_from and decodes back to the original credential via UserInfo::to_basic.

Round-trip invariant

Encoding always yields grammar-valid userinfo. The Basic → UserInfo → UserInfo::try_from round-trip holds for exactly the Basic values whose components are free of control bytes (0x00–0x1F / 0x7F): any control byte encodes to a %XX escape that strict parsing then refuses as a pct-decoded-control smuggling vector. Basic::try_from pre-rejects \r / \n / NUL, but the typed constructors (Basic::new, the with_/set_ setters, clone_with_*) do not validate, so any control byte can reach this obscure residual regardless of which entry point built the Basic.

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

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.