vimwiki::vendor::uriparse::relative_reference

Enum RelativeReferenceError

#[non_exhaustive]pub enum RelativeReferenceError {
    AbsolutePathStartsWithTwoSlashes,
    Authority(AuthorityError),
    Fragment(FragmentError),
    Path(PathError),
    Query(QueryError),
    MissingPath,
    NotRelativeReference,
    SchemelessPathStartsWithColonSegment,
}

Expand description

An error representing an invalid relative reference.

Variants (Non-exhaustive)§

This enum is marked as non-exhaustive

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

§

AbsolutePathStartsWithTwoSlashes

Represents the case where there is no authority, but the first path segment starts with "//". This is not allowed because it would be interpreted as an authority component.

This can only occur when using creation functions that act on individual parts (e.g. RelativeReference::from_parts).

§

Authority(AuthorityError)

The authority component of the relative reference was invalid.

§

Fragment(FragmentError)

The fragment component of the relative reference was invalid.

§

Path(PathError)

The path component of the relative reference was invalid.

§

Query(QueryError)

The query component of the relative reference was invalid.

§

MissingPath

This error occurs when you do not specify a path component on the builder.

This can only occur when using RelativeReferenceBuilder.

§

NotRelativeReference

When parsing from some byte string source, if the source ends up being a URI, then it is obviously not a relative reference.

This can only occur when parsing from a byte string source.

§

SchemelessPathStartsWithColonSegment

Represents the case where the first path segment contains a ':'. This is not allowed because it would be interpreted as a scheme component.

This can only occur when using creation functions that act on individual parts (e.g. RelativeReference::from_parts).

Enum RelativeReferenceErrorCopy item path

Variants (Non-exhaustive)§

AbsolutePathStartsWithTwoSlashes

Authority(AuthorityError)

Fragment(FragmentError)

Path(PathError)

Query(QueryError)

MissingPath

NotRelativeReference

SchemelessPathStartsWithColonSegment

Trait Implementations§

impl Clone for RelativeReferenceError

fn clone(&self) -> RelativeReferenceError

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

impl Debug for RelativeReferenceError

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

impl Display for RelativeReferenceError

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

impl Error for RelativeReferenceError

fn source(&self) -> Option<&(dyn Error + 'static)>

fn description(&self) -> &str

fn cause(&self) -> Option<&dyn Error>

fn provide<'a>(&'a self, request: &mut Request<'a>)

impl From<AuthorityError> for RelativeReferenceError

fn from(value: AuthorityError) -> RelativeReferenceError

impl From<FragmentError> for RelativeReferenceError

fn from(value: FragmentError) -> RelativeReferenceError

impl From<Infallible> for RelativeReferenceError

fn from(_: Infallible) -> RelativeReferenceError

impl From<PathError> for RelativeReferenceError

fn from(value: PathError) -> RelativeReferenceError

impl From<QueryError> for RelativeReferenceError

fn from(value: QueryError) -> RelativeReferenceError

impl Hash for RelativeReferenceError

fn hash<__H>(&self, state: &mut __H)where __H: Hasher,

fn hash_slice<H>(data: &[Self], state: &mut H)where H: Hasher, Self: Sized,

impl PartialEq for RelativeReferenceError

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

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

impl TryFrom<URIReferenceError> for RelativeReferenceError

type Error = ()

fn try_from( value: URIReferenceError, ) -> Result<RelativeReferenceError, <RelativeReferenceError as TryFrom<URIReferenceError>>::Error>

impl Copy for RelativeReferenceError

impl Eq for RelativeReferenceError

impl StructuralPartialEq for RelativeReferenceError

Auto Trait Implementations§

impl Freeze for RelativeReferenceError

impl RefUnwindSafe for RelativeReferenceError

impl Send for RelativeReferenceError

impl Sync for RelativeReferenceError

impl Unpin for RelativeReferenceError

impl UnwindSafe for RelativeReferenceError

Blanket Implementations§

impl<T> Any for Twhere T: 'static + ?Sized,

fn type_id(&self) -> TypeId

impl<T> Borrow<T> for Twhere T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for Twhere T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

impl<T> CloneToUninit for Twhere T: Clone,

unsafe fn clone_to_uninit(&self, dest: *mut u8)

impl<T> Conv for T

fn conv<T>(self) -> Twhere Self: Into<T>,

impl<T> Conv for T

fn conv<T>(self) -> Twhere Self: Into<T>,

impl<T> FmtForward for T

fn fmt_binary(self) -> FmtBinary<Self>where Self: Binary,

fn fmt_display(self) -> FmtDisplay<Self>where Self: Display,

fn fmt_lower_exp(self) -> FmtLowerExp<Self>where Self: LowerExp,

fn fmt_lower_hex(self) -> FmtLowerHex<Self>where Self: LowerHex,

fn fmt_octal(self) -> FmtOctal<Self>where Self: Octal,

fn fmt_pointer(self) -> FmtPointer<Self>where Self: Pointer,

fn fmt_upper_exp(self) -> FmtUpperExp<Self>where Self: UpperExp,

fn fmt_upper_hex(self) -> FmtUpperHex<Self>where Self: UpperHex,

impl<T> From<T> for T

fn from(t: T) -> T

impl<T, U> Into<U> for Twhere U: From<T>,

fn into(self) -> U

impl<T> Pipe for Twhere T: ?Sized,

fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> Rwhere Self: Sized,

Enum RelativeReferenceError

fn hash<H>(&self, state: &mut H)
where __H: Hasher,

fn hash_slice<H>(data: &[Self], state: &mut H)
where H: Hasher, Self: Sized,

impl<T> Any for T
where T: 'static + ?Sized,

impl<T> Borrow<T> for T
where T: ?Sized,

impl<T> BorrowMut<T> for T
where T: ?Sized,

impl<T> CloneToUninit for T
where T: Clone,

fn conv<T>(self) -> T
where Self: Into<T>,

fn conv<T>(self) -> T
where Self: Into<T>,

fn fmt_binary(self) -> FmtBinary<Self>
where Self: Binary,

fn fmt_display(self) -> FmtDisplay<Self>
where Self: Display,

fn fmt_lower_exp(self) -> FmtLowerExp<Self>
where Self: LowerExp,

fn fmt_lower_hex(self) -> FmtLowerHex<Self>
where Self: LowerHex,

fn fmt_octal(self) -> FmtOctal<Self>
where Self: Octal,

fn fmt_pointer(self) -> FmtPointer<Self>
where Self: Pointer,

fn fmt_upper_exp(self) -> FmtUpperExp<Self>
where Self: UpperExp,

fn fmt_upper_hex(self) -> FmtUpperHex<Self>
where Self: UpperHex,

impl<T, U> Into<U> for T
where U: From<T>,

impl<T> Pipe for T
where T: ?Sized,

fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> R
where Self: Sized,

fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R
where R: 'a,

fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> R
where R: 'a,

fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R
where Self: Borrow<B>, B: 'a + ?Sized, R: 'a,

fn pipe_borrow_mut<'a, B, R>( &'a mut self, func: impl FnOnce(&'a mut B) -> R, ) -> R
where Self: BorrowMut<B>, B: 'a + ?Sized, R: 'a,

fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
where Self: AsRef<U>, U: 'a + ?Sized, R: 'a,

fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R
where Self: AsMut<U>, U: 'a + ?Sized, R: 'a,

fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R
where Self: Deref<Target = T>, T: 'a + ?Sized, R: 'a,

fn pipe_deref_mut<'a, T, R>( &'a mut self, func: impl FnOnce(&'a mut T) -> R, ) -> R
where Self: DerefMut<Target = T> + Deref, T: 'a + ?Sized, R: 'a,

fn pipe_as_ref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R
where Self: AsRef<T>, T: 'a, R: 'a,

fn pipe_as_mut<'a, T, R>(&'a mut self, func: impl FnOnce(&'a mut T) -> R) -> R
where Self: AsMut<T>, T: 'a, R: 'a,

fn pipe_borrow<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R
where Self: Borrow<T>, T: 'a, R: 'a,

fn pipe_borrow_mut<'a, T, R>( &'a mut self, func: impl FnOnce(&'a mut T) -> R, ) -> R
where Self: BorrowMut<T>, T: 'a, R: 'a,

fn pipe_deref<'a, R>(&'a self, func: impl FnOnce(&'a Self::Target) -> R) -> R
where Self: Deref, R: 'a,

fn pipe_deref_mut<'a, R>( &'a mut self, func: impl FnOnce(&'a mut Self::Target) -> R, ) -> R
where Self: DerefMut, R: 'a,

fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R
where R: 'a,

fn pipe_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> R
where R: 'a,

fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self
where Self: Borrow<B>, B: ?Sized,

fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self
where Self: BorrowMut<B>, B: ?Sized,

fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self
where Self: AsRef<R>, R: ?Sized,

fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self
where Self: AsMut<R>, R: ?Sized,

fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self
where Self: Deref<Target = T>, T: ?Sized,

fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self
where Self: DerefMut<Target = T> + Deref, T: ?Sized,

fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self
where Self: Borrow<B>, B: ?Sized,

fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self
where Self: BorrowMut<B>, B: ?Sized,

fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self
where Self: AsRef<R>, R: ?Sized,

fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self
where Self: AsMut<R>, R: ?Sized,

fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self
where Self: Deref<Target = T>, T: ?Sized,

fn tap_deref_mut_dbg<T>(self, func: impl FnOnce(&mut T)) -> Self
where Self: DerefMut<Target = T> + Deref, T: ?Sized,

fn tap<F, R>(self, func: F) -> Self
where F: FnOnce(&Self) -> R,

fn tap_dbg<F, R>(self, func: F) -> Self
where F: FnOnce(&Self) -> R,

fn tap_mut<F, R>(self, func: F) -> Self
where F: FnOnce(&mut Self) -> R,

fn tap_mut_dbg<F, R>(self, func: F) -> Self
where F: FnOnce(&mut Self) -> R,

impl<T, U> TapAsRef<U> for T
where U: ?Sized,

fn tap_ref<F, R>(self, func: F) -> Self
where Self: AsRef<T>, F: FnOnce(&T) -> R,

fn tap_ref_dbg<F, R>(self, func: F) -> Self
where Self: AsRef<T>, F: FnOnce(&T) -> R,

fn tap_ref_mut<F, R>(self, func: F) -> Self
where Self: AsMut<T>, F: FnOnce(&mut T) -> R,

fn tap_ref_mut_dbg<F, R>(self, func: F) -> Self
where Self: AsMut<T>, F: FnOnce(&mut T) -> R,

impl<T, U> TapBorrow<U> for T
where U: ?Sized,

fn tap_borrow<F, R>(self, func: F) -> Self
where Self: Borrow<T>, F: FnOnce(&T) -> R,

fn tap_borrow_dbg<F, R>(self, func: F) -> Self
where Self: Borrow<T>, F: FnOnce(&T) -> R,

fn tap_borrow_mut<F, R>(self, func: F) -> Self
where Self: BorrowMut<T>, F: FnOnce(&mut T) -> R,

fn tap_borrow_mut_dbg<F, R>(self, func: F) -> Self
where Self: BorrowMut<T>, F: FnOnce(&mut T) -> R,

fn tap_deref<F, R>(self, func: F) -> Self
where Self: Deref, F: FnOnce(&Self::Target) -> R,

fn tap_deref_dbg<F, R>(self, func: F) -> Self
where Self: Deref, F: FnOnce(&Self::Target) -> R,

fn tap_deref_mut<F, R>(self, func: F) -> Self
where Self: DerefMut, F: FnOnce(&mut Self::Target) -> R,

fn tap_deref_mut_dbg<F, R>(self, func: F) -> Self
where Self: DerefMut, F: FnOnce(&mut Self::Target) -> R,

impl<T> ToOwned for T
where T: Clone,