You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
193 lines
3.9 KiB
193 lines
3.9 KiB
//! Wrapping `errno` error types
|
|
use super::*;
|
|
use std::os::raw::c_int;
|
|
use std::{
|
|
fmt, error
|
|
};
|
|
|
|
macro_rules! opaque {
|
|
($obj:expr => $msg:literal $(, $args:expr)*) => {
|
|
{
|
|
#[derive(Debug)]
|
|
struct Opaque<'a, T: ?Sized + ::std::fmt::Debug>(::std::fmt::FormatArgs<'a>, T);
|
|
impl<'a, T: ?Sized + ::std::fmt::Debug> ::std::fmt::Display for Opaque<T>
|
|
{
|
|
#[inline]
|
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result
|
|
{
|
|
use ::std::fmt::Write;
|
|
write!(f, "{}: {:?}", self.0, &self.1)
|
|
}
|
|
}
|
|
impl<'a, T: ?Sized + ::std::fmt::Debug> error::Error for Opaque<'a, T>{}
|
|
|
|
Opaque(::std::format_args!($msg, $(, $args)*), $obj)
|
|
}
|
|
};
|
|
}
|
|
pub(crate) use opaque;
|
|
|
|
/// Construct an ad-hoc error wrapping the last OS error.
|
|
macro_rules! os_error {
|
|
($fmt:literal $(, $args:expr)*) => {
|
|
{
|
|
#[derive(Debug)]
|
|
struct AdHoc<'a>(::std::fmt::Arguments<'a>);
|
|
impl<'a> ::std::fmt::Display for AdHoc<'a>
|
|
{
|
|
#[inline]
|
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result
|
|
{
|
|
write!(f, "{}", self.0)
|
|
}
|
|
}
|
|
$crate::err::WrappedOSError::last_os_error(AdHoc(::std::format_args!($fmt $(, $args)*)))
|
|
}
|
|
};
|
|
($(#[$outer:meta])* $vis:vis struct $name:ident => $fmt:literal $(; $($rest:tt)*)?) => {
|
|
|
|
$(#[$outer])*
|
|
#[derive(Debug)]
|
|
#[repr(transparent)]
|
|
$vis struct $name($crate::err::WrappedOSError<&'static str>);
|
|
|
|
impl ::std::fmt::Display for $name
|
|
{
|
|
#[inline]
|
|
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> fmt::Result
|
|
{
|
|
f.write_str($fmt)
|
|
}
|
|
}
|
|
impl ::std::error::Error for $name {
|
|
#[inline]
|
|
fn source(&self) -> Option<&(dyn ::std::error::Error + 'static)>
|
|
{
|
|
self.0.source()
|
|
}
|
|
}
|
|
|
|
#[allow(unused)]
|
|
impl $name {
|
|
#[inline(always)]
|
|
fn new() -> Self
|
|
{
|
|
Self($crate::err::WrappedOSError::last_os_error($fmt))
|
|
}
|
|
#[inline(always)]
|
|
fn into_inner(self) -> $crate::err::WrappedOSError<&'static str>
|
|
{
|
|
self.0
|
|
}
|
|
}
|
|
impl ::std::ops::Deref for $name {
|
|
type Target = $crate::err::WrappedOSError<&'static str>;
|
|
#[inline]
|
|
fn deref(&self) -> &Self::Target
|
|
{
|
|
&self.0
|
|
}
|
|
}
|
|
impl ::std::ops::DerefMut for $name {
|
|
#[inline]
|
|
fn deref_mut(&mut self) -> &mut Self::Target
|
|
{
|
|
&mut self.0
|
|
}
|
|
}
|
|
|
|
$(
|
|
$crate::os_error! {
|
|
$($rest)*
|
|
}
|
|
)?
|
|
};
|
|
() => {};
|
|
}
|
|
pub(crate) use os_error;
|
|
|
|
const _: () = {
|
|
os_error!(struct Test => "Test error");
|
|
const fn t<E: ?Sized + error::Error>() {}
|
|
fn r<E: ?Sized + error::Error>(_: &E) {}
|
|
fn test() {
|
|
r(&os_error!("Some error message"));
|
|
}
|
|
t::<Test>()
|
|
};
|
|
|
|
/// Wraps a piece of context over an OS error
|
|
pub struct WrappedOSError<E: ?Sized>(io::Error, E);
|
|
|
|
impl<E: fmt::Debug> WrappedOSError<E>
|
|
{
|
|
pub(crate) fn last_os_error(ctx: E) -> Self
|
|
{
|
|
Self(io::Error::last_os_error(), ctx)
|
|
}
|
|
|
|
pub(crate) fn from_os_error(raw: c_int, ctx: E) -> Self
|
|
{
|
|
Self(io::Error::from_raw_os_error(raw), ctx)
|
|
}
|
|
}
|
|
|
|
impl<E: ?Sized> WrappedOSError<E>
|
|
{
|
|
#[inline]
|
|
pub fn error(&self) -> &io::Error
|
|
{
|
|
&self.0
|
|
}
|
|
#[inline]
|
|
pub fn raw_error(&self) -> c_int
|
|
{
|
|
self.0.raw_os_error().unwrap()
|
|
}
|
|
#[inline]
|
|
pub fn context(&self) -> &E
|
|
{
|
|
&self.1
|
|
}
|
|
}
|
|
|
|
impl<E> From<WrappedOSError<E>> for io::Error
|
|
{
|
|
#[inline]
|
|
fn from(from: WrappedOSError<E>) -> Self
|
|
{
|
|
from.0
|
|
}
|
|
}
|
|
|
|
|
|
impl<E: ?Sized> error::Error for WrappedOSError<E>
|
|
where WrappedOSError<E>: fmt::Display + fmt::Debug
|
|
{
|
|
#[inline]
|
|
fn source(&self) -> Option<&(dyn error::Error + 'static)> {
|
|
Some(&self.0)
|
|
}
|
|
}
|
|
|
|
impl<E: ?Sized> fmt::Display for WrappedOSError<E>
|
|
where E: fmt::Debug
|
|
{
|
|
#[inline]
|
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result
|
|
{
|
|
write!(f, "{:?}", &self.1)
|
|
}
|
|
}
|
|
impl<E: ?Sized> fmt::Debug for WrappedOSError<E>
|
|
where E: fmt::Display
|
|
{
|
|
#[inline]
|
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result
|
|
{
|
|
write!(f, "{}", &self.1)
|
|
}
|
|
}
|
|
|
|
|