use std::{error::Error, fmt};
#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum ErrorKind {
Empty,
TooLong,
InvalidScheme,
SchemeMissing,
InvalidChar(char),
InvalidPercentEncoding,
InvalidAuthority,
AuthorityMissing,
InvalidHost,
InvalidIpv4,
InvalidIpv6,
InvalidPort,
PortOutOfRange,
InvalidPath,
}
impl fmt::Display for ErrorKind {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
ErrorKind::Empty => f.write_str("empty string"),
ErrorKind::TooLong => f.write_str("url is too long"),
ErrorKind::InvalidScheme => f.write_str("invalid scheme"),
ErrorKind::SchemeMissing => f.write_str("scheme missing"),
ErrorKind::InvalidChar(c) => write!(f, "invalid character {c:?}"),
ErrorKind::InvalidPercentEncoding => f.write_str("invalid percent-encoding"),
ErrorKind::InvalidAuthority => f.write_str("invalid authority"),
ErrorKind::AuthorityMissing => f.write_str("authority missing"),
ErrorKind::InvalidHost => f.write_str("invalid host"),
ErrorKind::InvalidIpv4 => f.write_str("invalid IPv4 address"),
ErrorKind::InvalidIpv6 => f.write_str("invalid IPv6 address"),
ErrorKind::InvalidPort => f.write_str("invalid port"),
ErrorKind::PortOutOfRange => f.write_str("port out of range"),
ErrorKind::InvalidPath => f.write_str("invalid path"),
}
}
}
#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
pub struct InvalidUrl {
kind: ErrorKind,
position: Option<usize>,
}
impl InvalidUrl {
pub(crate) const fn new(kind: ErrorKind) -> Self {
InvalidUrl {
kind,
position: None,
}
}
pub(crate) const fn at(kind: ErrorKind, position: usize) -> Self {
InvalidUrl {
kind,
position: Some(position),
}
}
pub(crate) fn offset(mut self, offset: usize) -> Self {
if let Some(pos) = self.position.as_mut() {
*pos += offset;
}
self
}
pub fn kind(&self) -> ErrorKind {
self.kind
}
pub fn position(&self) -> Option<usize> {
self.position
}
}
impl fmt::Display for InvalidUrl {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
if let Some(pos) = self.position {
write!(f, "{} at position {pos}", self.kind)
} else {
fmt::Display::fmt(&self.kind, f)
}
}
}
impl Error for InvalidUrl {}
#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
pub struct InvalidUrlParts(InvalidUrl);
impl InvalidUrlParts {
pub fn kind(&self) -> ErrorKind {
self.0.kind
}
pub fn into_inner(self) -> InvalidUrl {
self.0
}
}
impl From<InvalidUrl> for InvalidUrlParts {
fn from(err: InvalidUrl) -> Self {
InvalidUrlParts(err)
}
}
impl fmt::Display for InvalidUrlParts {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "invalid url parts: {}", self.0)
}
}
impl Error for InvalidUrlParts {
fn source(&self) -> Option<&(dyn Error + 'static)> {
Some(&self.0)
}
}