mod authority;
mod buffer;
mod fragment;
mod host;
mod path;
mod port;
mod query;
mod scheme;
mod segment;
mod userinfo;
use crate::{IriRef, IriRefBuf};
use std::borrow::Borrow;
use std::cmp::{Ord, Ordering, PartialOrd};
use std::convert::TryFrom;
use std::error::Error as StdError;
use std::fmt;
use std::hash::{Hash, Hasher};
use std::ops::Deref;
pub use self::authority::*;
pub use self::buffer::*;
pub use self::fragment::*;
pub use self::host::*;
pub use self::path::*;
pub use self::port::*;
pub use self::query::*;
pub use self::scheme::*;
pub use self::segment::*;
pub use self::userinfo::*;
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum Error {
InvalidEncoding,
InvalidPercentEncoding,
MissingScheme,
InvalidScheme,
InvalidAuthority,
InvalidUserInfo,
InvalidHost,
InvalidPort,
InvalidSegment,
InvalidPath,
InvalidQuery,
InvalidFragment,
}
impl fmt::Display for Error {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(match self {
Error::InvalidEncoding => "Invalid encoding",
Error::InvalidPercentEncoding => "Invalid percent encoding",
Error::MissingScheme => "Missing scheme",
Error::InvalidScheme => "Invalid scheme",
Error::InvalidAuthority => "Invalid authority",
Error::InvalidUserInfo => "Invalid user info",
Error::InvalidHost => "Invalid host",
Error::InvalidPort => "Invalid port",
Error::InvalidSegment => "Invalid segment",
Error::InvalidPath => "Invalid path",
Error::InvalidQuery => "Invalid query",
Error::InvalidFragment => "Invalid fragment",
})
}
}
impl StdError for Error {}
#[derive(Clone, Copy)]
pub struct Iri<'a>(IriRef<'a>);
impl<'a> Iri<'a> {
#[inline]
pub fn new<S: AsRef<[u8]> + ?Sized>(buffer: &'a S) -> Result<Iri<'a>, Error> {
let iri_ref = IriRef::new(buffer)?;
if iri_ref.scheme().is_some() {
Ok(Iri(iri_ref))
} else {
Err(Error::MissingScheme)
}
}
#[allow(clippy::should_implement_trait)]
pub fn from_str(s: &'a str) -> Result<Self, Error> {
Self::new(s)
}
pub fn to_owned(self) -> IriBuf {
IriBuf(self.0.to_owned())
}
#[inline]
pub const fn from_iri_ref(iri_ref: IriRef<'a>) -> Iri<'a> {
Iri(iri_ref)
}
#[inline]
pub fn as_iri_ref(&self) -> IriRef<'a> {
self.0
}
#[inline]
pub fn scheme(&self) -> Scheme {
self.0.scheme().unwrap()
}
}
impl<'a> Deref for Iri<'a> {
type Target = IriRef<'a>;
#[inline]
fn deref(&self) -> &IriRef<'a> {
&self.0
}
}
impl<'a> fmt::Display for Iri<'a> {
#[inline]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
self.as_iri_ref().fmt(f)
}
}
impl<'a> fmt::Debug for Iri<'a> {
#[inline]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
self.as_iri_ref().fmt(f)
}
}
impl<'a> PartialEq for Iri<'a> {
#[inline]
fn eq(&self, other: &Iri) -> bool {
self.as_iri_ref() == other.as_iri_ref()
}
}
impl<'a> Eq for Iri<'a> {}
impl<'a> PartialEq<IriRef<'a>> for Iri<'a> {
#[inline]
fn eq(&self, other: &IriRef<'a>) -> bool {
self.as_iri_ref() == *other
}
}
impl<'a> PartialEq<IriRefBuf> for Iri<'a> {
#[inline]
fn eq(&self, other: &IriRefBuf) -> bool {
self.as_iri_ref() == other.as_iri_ref()
}
}
impl<'a> PartialEq<IriBuf> for Iri<'a> {
#[inline]
fn eq(&self, other: &IriBuf) -> bool {
self.as_iri_ref() == other.as_iri_ref()
}
}
impl<'a> PartialEq<&'a str> for Iri<'a> {
#[inline]
fn eq(&self, other: &&'a str) -> bool {
self.as_iri_ref().eq(other)
}
}
impl<'a> PartialOrd for Iri<'a> {
#[inline]
fn partial_cmp(&self, other: &Iri<'a>) -> Option<Ordering> {
self.as_iri_ref().partial_cmp(&other.as_iri_ref())
}
}
impl<'a> Ord for Iri<'a> {
#[inline]
fn cmp(&self, other: &Iri<'a>) -> Ordering {
self.as_iri_ref().cmp(&other.as_iri_ref())
}
}
impl<'a> PartialOrd<IriRef<'a>> for Iri<'a> {
#[inline]
fn partial_cmp(&self, other: &IriRef<'a>) -> Option<Ordering> {
self.as_iri_ref().partial_cmp(other)
}
}
impl<'a> PartialOrd<IriRefBuf> for Iri<'a> {
#[inline]
fn partial_cmp(&self, other: &IriRefBuf) -> Option<Ordering> {
self.as_iri_ref().partial_cmp(&other.as_iri_ref())
}
}
impl<'a> PartialOrd<IriBuf> for Iri<'a> {
#[inline]
fn partial_cmp(&self, other: &IriBuf) -> Option<Ordering> {
self.as_iri_ref().partial_cmp(&other.as_iri_ref())
}
}
impl<'a> From<&'a IriBuf> for Iri<'a> {
#[inline]
fn from(buffer: &'a IriBuf) -> Iri<'a> {
buffer.as_iri()
}
}
impl<'a> TryFrom<IriRef<'a>> for Iri<'a> {
type Error = IriRef<'a>;
#[inline]
fn try_from(iri_ref: IriRef<'a>) -> Result<Iri<'a>, IriRef<'a>> {
if iri_ref.p.scheme_len.is_some() {
Ok(Iri(iri_ref))
} else {
Err(iri_ref)
}
}
}
impl<'a> TryFrom<&'a IriRefBuf> for Iri<'a> {
type Error = Error;
#[inline]
fn try_from(buffer: &'a IriRefBuf) -> Result<Iri<'a>, Error> {
if buffer.p.scheme_len.is_some() {
Ok(Iri(buffer.as_iri_ref()))
} else {
Err(Error::InvalidScheme)
}
}
}
impl<'a> Hash for Iri<'a> {
#[inline]
fn hash<H: Hasher>(&self, hasher: &mut H) {
self.as_iri_ref().hash(hasher)
}
}
#[cfg(feature = "hashbrown")]
impl<'a> hashbrown::Equivalent<IriRefBuf> for Iri<'a> {
fn equivalent(&self, key: &IriRefBuf) -> bool {
*self == *key
}
}
#[cfg(feature = "hashbrown")]
impl<'a> hashbrown::Equivalent<IriBuf> for Iri<'a> {
fn equivalent(&self, key: &IriBuf) -> bool {
*self == *key
}
}
#[cfg(feature = "hashbrown")]
impl<'a, 'b> hashbrown::Equivalent<IriRef<'b>> for Iri<'a> {
fn equivalent(&self, key: &IriRef<'b>) -> bool {
*self == *key
}
}
impl<'a> AsIri for Iri<'a> {
#[inline]
fn as_iri(&self) -> Iri {
*self
}
}
impl<'a> AsIriRef for Iri<'a> {
#[inline]
fn as_iri_ref(&self) -> IriRef {
self.as_iri_ref()
}
}
pub trait AsIriRef {
fn as_iri_ref(&self) -> IriRef;
}
pub trait AsIri {
fn as_iri(&self) -> Iri;
}
impl<'a, T: AsIri> AsIri for &'a T {
#[inline]
fn as_iri(&self) -> Iri {
(*self).as_iri()
}
}
impl<'a, T: AsIriRef> AsIriRef for &'a T {
#[inline]
fn as_iri_ref(&self) -> IriRef {
(*self).as_iri_ref()
}
}
impl<'a> AsRef<str> for Iri<'a> {
#[inline(always)]
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl<'a> AsRef<[u8]> for Iri<'a> {
#[inline(always)]
fn as_ref(&self) -> &[u8] {
self.as_bytes()
}
}
impl<'a> Borrow<str> for Iri<'a> {
#[inline(always)]
fn borrow(&self) -> &str {
self.as_str()
}
}
impl<'a> Borrow<[u8]> for Iri<'a> {
#[inline(always)]
fn borrow(&self) -> &[u8] {
self.as_bytes()
}
}