//! 通用 I/O 原语的 WASI 特定扩展

#![deny(unsafe_op_in_unsafe_fn)]
#![unstable(feature = "wasi_ext", issue = "71213")]

use crate::fs;
use crate::io;
use crate::net;
use crate::sys;
use crate::sys_common::{AsInner, FromInner, IntoInner};

/// 原始文件描述符。
pub type RawFd = u32;

/// trait，用于从基础 object 提取原始 WASI 文件描述符。
///
pub trait AsRawFd {
    /// 提取原始文件描述符。
    ///
    /// 此方法不会将原始文件描述符的所有权传递给调用方。
    /// 仅当原始 object 尚未销毁时，才保证描述符是有效的。
    ///
    fn as_raw_fd(&self) -> RawFd;
}

/// trait 表示从原始文件描述符构造 object 的能力。
///
pub trait FromRawFd {
    /// 根据给定的原始文件描述符构造 `Self` 的新实例。
    ///
    /// 此函数 **消耗指定文件描述符的所有权**。
    /// 当 object 离开作用域时，返回的 object 将负责关闭它。
    ///
    /// 此函数也是不安全的，因为当前返回的原语具有它们是包装的文件描述符的唯一所有者的约定。
    ///
    /// 使用此函数可能会意外地违反该协定，这可能导致依赖于该协定为真的代码中的内存不安全。
    ///
    ///
    ///
    ///
    unsafe fn from_raw_fd(fd: RawFd) -> Self;
}

/// trait 表示使用 object 并获取其原始文件描述符所有权的能力。
///
pub trait IntoRawFd {
    /// 使用此 object，返回原始基础文件描述符。
    ///
    /// 此函数将基础文件描述符的所有权 ** 转让给调用者。
    /// 这样，调用者便是文件描述符的唯一所有者，一旦不再需要描述符，就必须关闭该描述符。
    ///
    fn into_raw_fd(self) -> RawFd;
}

#[stable(feature = "raw_fd_reflexive_traits", since = "1.48.0")]
impl AsRawFd for RawFd {
    #[inline]
    fn as_raw_fd(&self) -> RawFd {
        *self
    }
}
#[stable(feature = "raw_fd_reflexive_traits", since = "1.48.0")]
impl IntoRawFd for RawFd {
    #[inline]
    fn into_raw_fd(self) -> RawFd {
        self
    }
}
#[stable(feature = "raw_fd_reflexive_traits", since = "1.48.0")]
impl FromRawFd for RawFd {
    #[inline]
    unsafe fn from_raw_fd(fd: RawFd) -> RawFd {
        fd
    }
}

impl AsRawFd for net::TcpStream {
    #[inline]
    fn as_raw_fd(&self) -> RawFd {
        self.as_inner().fd().as_raw()
    }
}

impl FromRawFd for net::TcpStream {
    #[inline]
    unsafe fn from_raw_fd(fd: RawFd) -> net::TcpStream {
        net::TcpStream::from_inner(sys::net::TcpStream::from_inner(fd))
    }
}

impl IntoRawFd for net::TcpStream {
    #[inline]
    fn into_raw_fd(self) -> RawFd {
        self.into_inner().into_fd().into_raw()
    }
}

impl AsRawFd for net::TcpListener {
    #[inline]
    fn as_raw_fd(&self) -> RawFd {
        self.as_inner().fd().as_raw()
    }
}

impl FromRawFd for net::TcpListener {
    #[inline]
    unsafe fn from_raw_fd(fd: RawFd) -> net::TcpListener {
        net::TcpListener::from_inner(sys::net::TcpListener::from_inner(fd))
    }
}

impl IntoRawFd for net::TcpListener {
    #[inline]
    fn into_raw_fd(self) -> RawFd {
        self.into_inner().into_fd().into_raw()
    }
}

impl AsRawFd for net::UdpSocket {
    #[inline]
    fn as_raw_fd(&self) -> RawFd {
        self.as_inner().fd().as_raw()
    }
}

impl FromRawFd for net::UdpSocket {
    #[inline]
    unsafe fn from_raw_fd(fd: RawFd) -> net::UdpSocket {
        net::UdpSocket::from_inner(sys::net::UdpSocket::from_inner(fd))
    }
}

impl IntoRawFd for net::UdpSocket {
    #[inline]
    fn into_raw_fd(self) -> RawFd {
        self.into_inner().into_fd().into_raw()
    }
}

impl AsRawFd for fs::File {
    #[inline]
    fn as_raw_fd(&self) -> RawFd {
        self.as_inner().fd().as_raw()
    }
}

impl FromRawFd for fs::File {
    #[inline]
    unsafe fn from_raw_fd(fd: RawFd) -> fs::File {
        fs::File::from_inner(sys::fs::File::from_inner(fd))
    }
}

impl IntoRawFd for fs::File {
    #[inline]
    fn into_raw_fd(self) -> RawFd {
        self.into_inner().into_fd().into_raw()
    }
}

impl AsRawFd for io::Stdin {
    #[inline]
    fn as_raw_fd(&self) -> RawFd {
        libc::STDIN_FILENO as RawFd
    }
}

impl AsRawFd for io::Stdout {
    #[inline]
    fn as_raw_fd(&self) -> RawFd {
        libc::STDOUT_FILENO as RawFd
    }
}

impl AsRawFd for io::Stderr {
    #[inline]
    fn as_raw_fd(&self) -> RawFd {
        libc::STDERR_FILENO as RawFd
    }
}

impl<'a> AsRawFd for io::StdinLock<'a> {
    #[inline]
    fn as_raw_fd(&self) -> RawFd {
        libc::STDIN_FILENO as RawFd
    }
}

impl<'a> AsRawFd for io::StdoutLock<'a> {
    #[inline]
    fn as_raw_fd(&self) -> RawFd {
        libc::STDOUT_FILENO as RawFd
    }
}

impl<'a> AsRawFd for io::StderrLock<'a> {
    #[inline]
    fn as_raw_fd(&self) -> RawFd {
        libc::STDERR_FILENO as RawFd
    }
}