mirror of
https://github.com/async-rs/async-std.git
synced 2025-01-21 04:53:50 +00:00
Merge remote-tracking branch 'upstream/master' into 342-stream-throttle
This commit is contained in:
commit
ced5281b73
52 changed files with 961 additions and 1101 deletions
2
.github/workflows/ci.yml
vendored
2
.github/workflows/ci.yml
vendored
|
@ -41,7 +41,7 @@ jobs:
|
|||
uses: actions-rs/cargo@v1
|
||||
with:
|
||||
command: test
|
||||
args: --all --doc --features unstable
|
||||
args: --all --features unstable
|
||||
|
||||
check_fmt_and_docs:
|
||||
name: Checking fmt and docs
|
||||
|
|
|
@ -21,15 +21,15 @@ features = ["docs"]
|
|||
rustdoc-args = ["--cfg", "feature=\"docs\""]
|
||||
|
||||
[features]
|
||||
docs = ["broadcaster"]
|
||||
docs = ["unstable"]
|
||||
unstable = ["broadcaster"]
|
||||
|
||||
[dependencies]
|
||||
async-macros = "1.0.0"
|
||||
async-task = "1.0.0"
|
||||
cfg-if = "0.1.9"
|
||||
crossbeam-channel = "0.3.9"
|
||||
crossbeam-deque = "0.7.1"
|
||||
crossbeam-utils = "0.6.6"
|
||||
futures-core-preview = "=0.3.0-alpha.19"
|
||||
futures-io-preview = "=0.3.0-alpha.19"
|
||||
futures-timer = "1.0.2"
|
||||
|
|
|
@ -1,7 +1,5 @@
|
|||
use std::future::Future;
|
||||
|
||||
use cfg_if::cfg_if;
|
||||
|
||||
use crate::io;
|
||||
use crate::path::Path;
|
||||
use crate::task::blocking;
|
||||
|
@ -113,22 +111,13 @@ impl DirBuilder {
|
|||
}
|
||||
}
|
||||
|
||||
cfg_if! {
|
||||
if #[cfg(feature = "docs")] {
|
||||
use crate::os::unix::fs::DirBuilderExt;
|
||||
} else if #[cfg(unix)] {
|
||||
use std::os::unix::fs::DirBuilderExt;
|
||||
}
|
||||
}
|
||||
cfg_unix! {
|
||||
use crate::os::unix::fs::DirBuilderExt;
|
||||
|
||||
#[cfg_attr(feature = "docs", doc(cfg(unix)))]
|
||||
cfg_if! {
|
||||
if #[cfg(any(unix, feature = "docs"))] {
|
||||
impl DirBuilderExt for DirBuilder {
|
||||
fn mode(&mut self, mode: u32) -> &mut Self {
|
||||
self.mode = Some(mode);
|
||||
self
|
||||
}
|
||||
impl DirBuilderExt for DirBuilder {
|
||||
fn mode(&mut self, mode: u32) -> &mut Self {
|
||||
self.mode = Some(mode);
|
||||
self
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
@ -2,8 +2,6 @@ use std::ffi::OsString;
|
|||
use std::fmt;
|
||||
use std::sync::Arc;
|
||||
|
||||
use cfg_if::cfg_if;
|
||||
|
||||
use crate::fs::{FileType, Metadata};
|
||||
use crate::io;
|
||||
use crate::path::PathBuf;
|
||||
|
@ -160,21 +158,12 @@ impl fmt::Debug for DirEntry {
|
|||
}
|
||||
}
|
||||
|
||||
cfg_if! {
|
||||
if #[cfg(feature = "docs")] {
|
||||
use crate::os::unix::fs::DirEntryExt;
|
||||
} else if #[cfg(unix)] {
|
||||
use std::os::unix::fs::DirEntryExt;
|
||||
}
|
||||
}
|
||||
cfg_unix! {
|
||||
use crate::os::unix::fs::DirEntryExt;
|
||||
|
||||
#[cfg_attr(feature = "docs", doc(cfg(unix)))]
|
||||
cfg_if! {
|
||||
if #[cfg(any(unix, feature = "docs"))] {
|
||||
impl DirEntryExt for DirEntry {
|
||||
fn ino(&self) -> u64 {
|
||||
self.0.ino()
|
||||
}
|
||||
impl DirEntryExt for DirEntry {
|
||||
fn ino(&self) -> u64 {
|
||||
self.0.ino()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
@ -7,8 +7,6 @@ use std::pin::Pin;
|
|||
use std::sync::atomic::{AtomicBool, Ordering};
|
||||
use std::sync::{Arc, Mutex};
|
||||
|
||||
use cfg_if::cfg_if;
|
||||
|
||||
use crate::fs::{Metadata, Permissions};
|
||||
use crate::future;
|
||||
use crate::io::{self, Read, Seek, SeekFrom, Write};
|
||||
|
@ -401,67 +399,54 @@ impl From<std::fs::File> for File {
|
|||
}
|
||||
}
|
||||
|
||||
cfg_if! {
|
||||
if #[cfg(feature = "docs")] {
|
||||
use crate::os::unix::io::{AsRawFd, FromRawFd, IntoRawFd, RawFd};
|
||||
use crate::os::windows::io::{AsRawHandle, FromRawHandle, IntoRawHandle, RawHandle};
|
||||
} else if #[cfg(unix)] {
|
||||
use std::os::unix::io::{AsRawFd, FromRawFd, IntoRawFd, RawFd};
|
||||
} else if #[cfg(windows)] {
|
||||
use std::os::windows::io::{AsRawHandle, FromRawHandle, IntoRawHandle, RawHandle};
|
||||
cfg_unix! {
|
||||
use crate::os::unix::io::{AsRawFd, FromRawFd, IntoRawFd, RawFd};
|
||||
|
||||
impl AsRawFd for File {
|
||||
fn as_raw_fd(&self) -> RawFd {
|
||||
self.file.as_raw_fd()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg_attr(feature = "docs", doc(cfg(unix)))]
|
||||
cfg_if! {
|
||||
if #[cfg(any(unix, feature = "docs"))] {
|
||||
impl AsRawFd for File {
|
||||
fn as_raw_fd(&self) -> RawFd {
|
||||
self.file.as_raw_fd()
|
||||
}
|
||||
impl FromRawFd for File {
|
||||
unsafe fn from_raw_fd(fd: RawFd) -> File {
|
||||
std::fs::File::from_raw_fd(fd).into()
|
||||
}
|
||||
}
|
||||
|
||||
impl FromRawFd for File {
|
||||
unsafe fn from_raw_fd(fd: RawFd) -> File {
|
||||
std::fs::File::from_raw_fd(fd).into()
|
||||
}
|
||||
}
|
||||
|
||||
impl IntoRawFd for File {
|
||||
fn into_raw_fd(self) -> RawFd {
|
||||
let file = self.file.clone();
|
||||
drop(self);
|
||||
Arc::try_unwrap(file)
|
||||
.expect("cannot acquire ownership of the file handle after drop")
|
||||
.into_raw_fd()
|
||||
}
|
||||
impl IntoRawFd for File {
|
||||
fn into_raw_fd(self) -> RawFd {
|
||||
let file = self.file.clone();
|
||||
drop(self);
|
||||
Arc::try_unwrap(file)
|
||||
.expect("cannot acquire ownership of the file handle after drop")
|
||||
.into_raw_fd()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg_attr(feature = "docs", doc(cfg(windows)))]
|
||||
cfg_if! {
|
||||
if #[cfg(any(windows, feature = "docs"))] {
|
||||
impl AsRawHandle for File {
|
||||
fn as_raw_handle(&self) -> RawHandle {
|
||||
self.file.as_raw_handle()
|
||||
}
|
||||
}
|
||||
cfg_windows! {
|
||||
use crate::os::windows::io::{AsRawHandle, FromRawHandle, IntoRawHandle, RawHandle};
|
||||
|
||||
impl FromRawHandle for File {
|
||||
unsafe fn from_raw_handle(handle: RawHandle) -> File {
|
||||
std::fs::File::from_raw_handle(handle).into()
|
||||
}
|
||||
impl AsRawHandle for File {
|
||||
fn as_raw_handle(&self) -> RawHandle {
|
||||
self.file.as_raw_handle()
|
||||
}
|
||||
}
|
||||
|
||||
impl IntoRawHandle for File {
|
||||
fn into_raw_handle(self) -> RawHandle {
|
||||
let file = self.file.clone();
|
||||
drop(self);
|
||||
Arc::try_unwrap(file)
|
||||
.expect("cannot acquire ownership of the file handle after drop")
|
||||
.into_raw_handle()
|
||||
}
|
||||
impl FromRawHandle for File {
|
||||
unsafe fn from_raw_handle(handle: RawHandle) -> File {
|
||||
std::fs::File::from_raw_handle(handle).into()
|
||||
}
|
||||
}
|
||||
|
||||
impl IntoRawHandle for File {
|
||||
fn into_raw_handle(self) -> RawHandle {
|
||||
let file = self.file.clone();
|
||||
drop(self);
|
||||
Arc::try_unwrap(file)
|
||||
.expect("cannot acquire ownership of the file handle after drop")
|
||||
.into_raw_handle()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
@ -1,86 +1,84 @@
|
|||
use cfg_if::cfg_if;
|
||||
cfg_not_docs! {
|
||||
pub use std::fs::FileType;
|
||||
}
|
||||
|
||||
cfg_if! {
|
||||
if #[cfg(feature = "docs")] {
|
||||
/// The type of a file or directory.
|
||||
cfg_docs! {
|
||||
/// The type of a file or directory.
|
||||
///
|
||||
/// A file type is returned by [`Metadata::file_type`].
|
||||
///
|
||||
/// Note that file types are mutually exclusive, i.e. at most one of methods [`is_dir`],
|
||||
/// [`is_file`], and [`is_symlink`] can return `true`.
|
||||
///
|
||||
/// This type is a re-export of [`std::fs::FileType`].
|
||||
///
|
||||
/// [`Metadata::file_type`]: struct.Metadata.html#method.file_type
|
||||
/// [`is_dir`]: #method.is_dir
|
||||
/// [`is_file`]: #method.is_file
|
||||
/// [`is_symlink`]: #method.is_symlink
|
||||
/// [`std::fs::FileType`]: https://doc.rust-lang.org/std/fs/struct.FileType.html
|
||||
#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
|
||||
pub struct FileType {
|
||||
_private: (),
|
||||
}
|
||||
|
||||
impl FileType {
|
||||
/// Returns `true` if this file type represents a regular directory.
|
||||
///
|
||||
/// A file type is returned by [`Metadata::file_type`].
|
||||
/// If this file type represents a symbolic link, this method returns `false`.
|
||||
///
|
||||
/// Note that file types are mutually exclusive, i.e. at most one of methods [`is_dir`],
|
||||
/// [`is_file`], and [`is_symlink`] can return `true`.
|
||||
/// # Examples
|
||||
///
|
||||
/// This type is a re-export of [`std::fs::FileType`].
|
||||
/// ```no_run
|
||||
/// # fn main() -> std::io::Result<()> { async_std::task::block_on(async {
|
||||
/// #
|
||||
/// use async_std::fs;
|
||||
///
|
||||
/// [`Metadata::file_type`]: struct.Metadata.html#method.file_type
|
||||
/// [`is_dir`]: #method.is_dir
|
||||
/// [`is_file`]: #method.is_file
|
||||
/// [`is_symlink`]: #method.is_symlink
|
||||
/// [`std::fs::FileType`]: https://doc.rust-lang.org/std/fs/struct.FileType.html
|
||||
#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
|
||||
pub struct FileType {
|
||||
_private: (),
|
||||
/// let file_type = fs::metadata(".").await?.file_type();
|
||||
/// println!("{:?}", file_type.is_dir());
|
||||
/// #
|
||||
/// # Ok(()) }) }
|
||||
/// ```
|
||||
pub fn is_dir(&self) -> bool {
|
||||
unimplemented!()
|
||||
}
|
||||
|
||||
impl FileType {
|
||||
/// Returns `true` if this file type represents a regular directory.
|
||||
///
|
||||
/// If this file type represents a symbolic link, this method returns `false`.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```no_run
|
||||
/// # fn main() -> std::io::Result<()> { async_std::task::block_on(async {
|
||||
/// #
|
||||
/// use async_std::fs;
|
||||
///
|
||||
/// let file_type = fs::metadata(".").await?.file_type();
|
||||
/// println!("{:?}", file_type.is_dir());
|
||||
/// #
|
||||
/// # Ok(()) }) }
|
||||
/// ```
|
||||
pub fn is_dir(&self) -> bool {
|
||||
unimplemented!()
|
||||
}
|
||||
|
||||
/// Returns `true` if this file type represents a regular file.
|
||||
///
|
||||
/// If this file type represents a symbolic link, this method returns `false`.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```no_run
|
||||
/// # fn main() -> std::io::Result<()> { async_std::task::block_on(async {
|
||||
/// #
|
||||
/// use async_std::fs;
|
||||
///
|
||||
/// let file_type = fs::metadata("a.txt").await?.file_type();
|
||||
/// println!("{:?}", file_type.is_file());
|
||||
/// #
|
||||
/// # Ok(()) }) }
|
||||
/// ```
|
||||
pub fn is_file(&self) -> bool {
|
||||
unimplemented!()
|
||||
}
|
||||
|
||||
/// Returns `true` if this file type represents a symbolic link.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```no_run
|
||||
/// # fn main() -> std::io::Result<()> { async_std::task::block_on(async {
|
||||
/// #
|
||||
/// use async_std::fs;
|
||||
///
|
||||
/// let file_type = fs::metadata("a.txt").await?.file_type();
|
||||
/// println!("{:?}", file_type.is_symlink());
|
||||
/// #
|
||||
/// # Ok(()) }) }
|
||||
/// ```
|
||||
pub fn is_symlink(&self) -> bool {
|
||||
unimplemented!()
|
||||
}
|
||||
/// Returns `true` if this file type represents a regular file.
|
||||
///
|
||||
/// If this file type represents a symbolic link, this method returns `false`.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```no_run
|
||||
/// # fn main() -> std::io::Result<()> { async_std::task::block_on(async {
|
||||
/// #
|
||||
/// use async_std::fs;
|
||||
///
|
||||
/// let file_type = fs::metadata("a.txt").await?.file_type();
|
||||
/// println!("{:?}", file_type.is_file());
|
||||
/// #
|
||||
/// # Ok(()) }) }
|
||||
/// ```
|
||||
pub fn is_file(&self) -> bool {
|
||||
unimplemented!()
|
||||
}
|
||||
|
||||
/// Returns `true` if this file type represents a symbolic link.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```no_run
|
||||
/// # fn main() -> std::io::Result<()> { async_std::task::block_on(async {
|
||||
/// #
|
||||
/// use async_std::fs;
|
||||
///
|
||||
/// let file_type = fs::metadata("a.txt").await?.file_type();
|
||||
/// println!("{:?}", file_type.is_symlink());
|
||||
/// #
|
||||
/// # Ok(()) }) }
|
||||
/// ```
|
||||
pub fn is_symlink(&self) -> bool {
|
||||
unimplemented!()
|
||||
}
|
||||
} else {
|
||||
pub use std::fs::FileType;
|
||||
}
|
||||
}
|
||||
|
|
|
@ -1,5 +1,3 @@
|
|||
use cfg_if::cfg_if;
|
||||
|
||||
use crate::io;
|
||||
use crate::path::Path;
|
||||
use crate::task::blocking;
|
||||
|
@ -39,193 +37,193 @@ pub async fn metadata<P: AsRef<Path>>(path: P) -> io::Result<Metadata> {
|
|||
blocking::spawn(move || std::fs::metadata(path)).await
|
||||
}
|
||||
|
||||
cfg_if! {
|
||||
if #[cfg(feature = "docs")] {
|
||||
use std::time::SystemTime;
|
||||
cfg_not_docs! {
|
||||
pub use std::fs::Metadata;
|
||||
}
|
||||
|
||||
use crate::fs::{FileType, Permissions};
|
||||
cfg_docs! {
|
||||
use std::time::SystemTime;
|
||||
|
||||
/// Metadata for a file or directory.
|
||||
use crate::fs::{FileType, Permissions};
|
||||
|
||||
/// Metadata for a file or directory.
|
||||
///
|
||||
/// Metadata is returned by [`metadata`] and [`symlink_metadata`].
|
||||
///
|
||||
/// This type is a re-export of [`std::fs::Metadata`].
|
||||
///
|
||||
/// [`metadata`]: fn.metadata.html
|
||||
/// [`symlink_metadata`]: fn.symlink_metadata.html
|
||||
/// [`is_dir`]: #method.is_dir
|
||||
/// [`is_file`]: #method.is_file
|
||||
/// [`std::fs::Metadata`]: https://doc.rust-lang.org/std/fs/struct.Metadata.html
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct Metadata {
|
||||
_private: (),
|
||||
}
|
||||
|
||||
impl Metadata {
|
||||
/// Returns the file type from this metadata.
|
||||
///
|
||||
/// Metadata is returned by [`metadata`] and [`symlink_metadata`].
|
||||
/// # Examples
|
||||
///
|
||||
/// This type is a re-export of [`std::fs::Metadata`].
|
||||
/// ```no_run
|
||||
/// # fn main() -> std::io::Result<()> { async_std::task::block_on(async {
|
||||
/// #
|
||||
/// use async_std::fs;
|
||||
///
|
||||
/// [`metadata`]: fn.metadata.html
|
||||
/// [`symlink_metadata`]: fn.symlink_metadata.html
|
||||
/// [`is_dir`]: #method.is_dir
|
||||
/// [`is_file`]: #method.is_file
|
||||
/// [`std::fs::Metadata`]: https://doc.rust-lang.org/std/fs/struct.Metadata.html
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct Metadata {
|
||||
_private: (),
|
||||
/// let metadata = fs::metadata("a.txt").await?;
|
||||
/// println!("{:?}", metadata.file_type());
|
||||
/// #
|
||||
/// # Ok(()) }) }
|
||||
/// ```
|
||||
pub fn file_type(&self) -> FileType {
|
||||
unimplemented!()
|
||||
}
|
||||
|
||||
impl Metadata {
|
||||
/// Returns the file type from this metadata.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```no_run
|
||||
/// # fn main() -> std::io::Result<()> { async_std::task::block_on(async {
|
||||
/// #
|
||||
/// use async_std::fs;
|
||||
///
|
||||
/// let metadata = fs::metadata("a.txt").await?;
|
||||
/// println!("{:?}", metadata.file_type());
|
||||
/// #
|
||||
/// # Ok(()) }) }
|
||||
/// ```
|
||||
pub fn file_type(&self) -> FileType {
|
||||
unimplemented!()
|
||||
}
|
||||
|
||||
/// Returns `true` if this metadata is for a regular directory.
|
||||
///
|
||||
/// If this metadata is for a symbolic link, this method returns `false`.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```no_run
|
||||
/// # fn main() -> std::io::Result<()> { async_std::task::block_on(async {
|
||||
/// #
|
||||
/// use async_std::fs;
|
||||
///
|
||||
/// let metadata = fs::metadata(".").await?;
|
||||
/// println!("{:?}", metadata.is_dir());
|
||||
/// #
|
||||
/// # Ok(()) }) }
|
||||
/// ```
|
||||
pub fn is_dir(&self) -> bool {
|
||||
unimplemented!()
|
||||
}
|
||||
|
||||
/// Returns `true` if this metadata is for a regular file.
|
||||
///
|
||||
/// If this metadata is for a symbolic link, this method returns `false`.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```no_run
|
||||
/// # fn main() -> std::io::Result<()> { async_std::task::block_on(async {
|
||||
/// #
|
||||
/// use async_std::fs;
|
||||
///
|
||||
/// let metadata = fs::metadata("a.txt").await?;
|
||||
/// println!("{:?}", metadata.is_file());
|
||||
/// #
|
||||
/// # Ok(()) }) }
|
||||
/// ```
|
||||
pub fn is_file(&self) -> bool {
|
||||
unimplemented!()
|
||||
}
|
||||
|
||||
/// Returns the file size in bytes.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```no_run
|
||||
/// # fn main() -> std::io::Result<()> { async_std::task::block_on(async {
|
||||
/// #
|
||||
/// use async_std::fs;
|
||||
///
|
||||
/// let metadata = fs::metadata("a.txt").await?;
|
||||
/// println!("{}", metadata.len());
|
||||
/// #
|
||||
/// # Ok(()) }) }
|
||||
/// ```
|
||||
pub fn len(&self) -> u64 {
|
||||
unimplemented!()
|
||||
}
|
||||
|
||||
/// Returns the permissions from this metadata.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```no_run
|
||||
/// # fn main() -> std::io::Result<()> { async_std::task::block_on(async {
|
||||
/// #
|
||||
/// use async_std::fs;
|
||||
///
|
||||
/// let metadata = fs::metadata("a.txt").await?;
|
||||
/// println!("{:?}", metadata.permissions());
|
||||
/// #
|
||||
/// # Ok(()) }) }
|
||||
/// ```
|
||||
pub fn permissions(&self) -> Permissions {
|
||||
unimplemented!()
|
||||
}
|
||||
|
||||
/// Returns the last modification time.
|
||||
///
|
||||
/// # Errors
|
||||
///
|
||||
/// This data may not be available on all platforms, in which case an error will be
|
||||
/// returned.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```no_run
|
||||
/// # fn main() -> std::io::Result<()> { async_std::task::block_on(async {
|
||||
/// #
|
||||
/// use async_std::fs;
|
||||
///
|
||||
/// let metadata = fs::metadata("a.txt").await?;
|
||||
/// println!("{:?}", metadata.modified());
|
||||
/// #
|
||||
/// # Ok(()) }) }
|
||||
/// ```
|
||||
pub fn modified(&self) -> io::Result<SystemTime> {
|
||||
unimplemented!()
|
||||
}
|
||||
|
||||
/// Returns the last access time.
|
||||
///
|
||||
/// # Errors
|
||||
///
|
||||
/// This data may not be available on all platforms, in which case an error will be
|
||||
/// returned.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```no_run
|
||||
/// # fn main() -> std::io::Result<()> { async_std::task::block_on(async {
|
||||
/// #
|
||||
/// use async_std::fs;
|
||||
///
|
||||
/// let metadata = fs::metadata("a.txt").await?;
|
||||
/// println!("{:?}", metadata.accessed());
|
||||
/// #
|
||||
/// # Ok(()) }) }
|
||||
/// ```
|
||||
pub fn accessed(&self) -> io::Result<SystemTime> {
|
||||
unimplemented!()
|
||||
}
|
||||
|
||||
/// Returns the creation time.
|
||||
///
|
||||
/// # Errors
|
||||
///
|
||||
/// This data may not be available on all platforms, in which case an error will be
|
||||
/// returned.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```no_run
|
||||
/// # fn main() -> std::io::Result<()> { async_std::task::block_on(async {
|
||||
/// #
|
||||
/// use async_std::fs;
|
||||
///
|
||||
/// let metadata = fs::metadata("a.txt").await?;
|
||||
/// println!("{:?}", metadata.created());
|
||||
/// #
|
||||
/// # Ok(()) }) }
|
||||
/// ```
|
||||
pub fn created(&self) -> io::Result<SystemTime> {
|
||||
unimplemented!()
|
||||
}
|
||||
/// Returns `true` if this metadata is for a regular directory.
|
||||
///
|
||||
/// If this metadata is for a symbolic link, this method returns `false`.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```no_run
|
||||
/// # fn main() -> std::io::Result<()> { async_std::task::block_on(async {
|
||||
/// #
|
||||
/// use async_std::fs;
|
||||
///
|
||||
/// let metadata = fs::metadata(".").await?;
|
||||
/// println!("{:?}", metadata.is_dir());
|
||||
/// #
|
||||
/// # Ok(()) }) }
|
||||
/// ```
|
||||
pub fn is_dir(&self) -> bool {
|
||||
unimplemented!()
|
||||
}
|
||||
|
||||
/// Returns `true` if this metadata is for a regular file.
|
||||
///
|
||||
/// If this metadata is for a symbolic link, this method returns `false`.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```no_run
|
||||
/// # fn main() -> std::io::Result<()> { async_std::task::block_on(async {
|
||||
/// #
|
||||
/// use async_std::fs;
|
||||
///
|
||||
/// let metadata = fs::metadata("a.txt").await?;
|
||||
/// println!("{:?}", metadata.is_file());
|
||||
/// #
|
||||
/// # Ok(()) }) }
|
||||
/// ```
|
||||
pub fn is_file(&self) -> bool {
|
||||
unimplemented!()
|
||||
}
|
||||
|
||||
/// Returns the file size in bytes.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```no_run
|
||||
/// # fn main() -> std::io::Result<()> { async_std::task::block_on(async {
|
||||
/// #
|
||||
/// use async_std::fs;
|
||||
///
|
||||
/// let metadata = fs::metadata("a.txt").await?;
|
||||
/// println!("{}", metadata.len());
|
||||
/// #
|
||||
/// # Ok(()) }) }
|
||||
/// ```
|
||||
pub fn len(&self) -> u64 {
|
||||
unimplemented!()
|
||||
}
|
||||
|
||||
/// Returns the permissions from this metadata.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```no_run
|
||||
/// # fn main() -> std::io::Result<()> { async_std::task::block_on(async {
|
||||
/// #
|
||||
/// use async_std::fs;
|
||||
///
|
||||
/// let metadata = fs::metadata("a.txt").await?;
|
||||
/// println!("{:?}", metadata.permissions());
|
||||
/// #
|
||||
/// # Ok(()) }) }
|
||||
/// ```
|
||||
pub fn permissions(&self) -> Permissions {
|
||||
unimplemented!()
|
||||
}
|
||||
|
||||
/// Returns the last modification time.
|
||||
///
|
||||
/// # Errors
|
||||
///
|
||||
/// This data may not be available on all platforms, in which case an error will be
|
||||
/// returned.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```no_run
|
||||
/// # fn main() -> std::io::Result<()> { async_std::task::block_on(async {
|
||||
/// #
|
||||
/// use async_std::fs;
|
||||
///
|
||||
/// let metadata = fs::metadata("a.txt").await?;
|
||||
/// println!("{:?}", metadata.modified());
|
||||
/// #
|
||||
/// # Ok(()) }) }
|
||||
/// ```
|
||||
pub fn modified(&self) -> io::Result<SystemTime> {
|
||||
unimplemented!()
|
||||
}
|
||||
|
||||
/// Returns the last access time.
|
||||
///
|
||||
/// # Errors
|
||||
///
|
||||
/// This data may not be available on all platforms, in which case an error will be
|
||||
/// returned.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```no_run
|
||||
/// # fn main() -> std::io::Result<()> { async_std::task::block_on(async {
|
||||
/// #
|
||||
/// use async_std::fs;
|
||||
///
|
||||
/// let metadata = fs::metadata("a.txt").await?;
|
||||
/// println!("{:?}", metadata.accessed());
|
||||
/// #
|
||||
/// # Ok(()) }) }
|
||||
/// ```
|
||||
pub fn accessed(&self) -> io::Result<SystemTime> {
|
||||
unimplemented!()
|
||||
}
|
||||
|
||||
/// Returns the creation time.
|
||||
///
|
||||
/// # Errors
|
||||
///
|
||||
/// This data may not be available on all platforms, in which case an error will be
|
||||
/// returned.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```no_run
|
||||
/// # fn main() -> std::io::Result<()> { async_std::task::block_on(async {
|
||||
/// #
|
||||
/// use async_std::fs;
|
||||
///
|
||||
/// let metadata = fs::metadata("a.txt").await?;
|
||||
/// println!("{:?}", metadata.created());
|
||||
/// #
|
||||
/// # Ok(()) }) }
|
||||
/// ```
|
||||
pub fn created(&self) -> io::Result<SystemTime> {
|
||||
unimplemented!()
|
||||
}
|
||||
} else {
|
||||
pub use std::fs::Metadata;
|
||||
}
|
||||
}
|
||||
|
|
|
@ -1,7 +1,5 @@
|
|||
use std::future::Future;
|
||||
|
||||
use cfg_if::cfg_if;
|
||||
|
||||
use crate::fs::File;
|
||||
use crate::io;
|
||||
use crate::path::Path;
|
||||
|
@ -296,27 +294,18 @@ impl Default for OpenOptions {
|
|||
}
|
||||
}
|
||||
|
||||
cfg_if! {
|
||||
if #[cfg(feature = "docs")] {
|
||||
use crate::os::unix::fs::OpenOptionsExt;
|
||||
} else if #[cfg(unix)] {
|
||||
use std::os::unix::fs::OpenOptionsExt;
|
||||
}
|
||||
}
|
||||
cfg_unix! {
|
||||
use crate::os::unix::fs::OpenOptionsExt;
|
||||
|
||||
#[cfg_attr(feature = "docs", doc(cfg(unix)))]
|
||||
cfg_if! {
|
||||
if #[cfg(any(unix, feature = "docs"))] {
|
||||
impl OpenOptionsExt for OpenOptions {
|
||||
fn mode(&mut self, mode: u32) -> &mut Self {
|
||||
self.0.mode(mode);
|
||||
self
|
||||
}
|
||||
impl OpenOptionsExt for OpenOptions {
|
||||
fn mode(&mut self, mode: u32) -> &mut Self {
|
||||
self.0.mode(mode);
|
||||
self
|
||||
}
|
||||
|
||||
fn custom_flags(&mut self, flags: i32) -> &mut Self {
|
||||
self.0.custom_flags(flags);
|
||||
self
|
||||
}
|
||||
fn custom_flags(&mut self, flags: i32) -> &mut Self {
|
||||
self.0.custom_flags(flags);
|
||||
self
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
@ -1,58 +1,56 @@
|
|||
use cfg_if::cfg_if;
|
||||
cfg_not_docs! {
|
||||
pub use std::fs::Permissions;
|
||||
}
|
||||
|
||||
cfg_if! {
|
||||
if #[cfg(feature = "docs")] {
|
||||
/// A set of permissions on a file or directory.
|
||||
cfg_docs! {
|
||||
/// A set of permissions on a file or directory.
|
||||
///
|
||||
/// This type is a re-export of [`std::fs::Permissions`].
|
||||
///
|
||||
/// [`std::fs::Permissions`]: https://doc.rust-lang.org/std/fs/struct.Permissions.html
|
||||
#[derive(Clone, PartialEq, Eq, Debug)]
|
||||
pub struct Permissions {
|
||||
_private: (),
|
||||
}
|
||||
|
||||
impl Permissions {
|
||||
/// Returns the read-only flag.
|
||||
///
|
||||
/// This type is a re-export of [`std::fs::Permissions`].
|
||||
/// # Examples
|
||||
///
|
||||
/// [`std::fs::Permissions`]: https://doc.rust-lang.org/std/fs/struct.Permissions.html
|
||||
#[derive(Clone, PartialEq, Eq, Debug)]
|
||||
pub struct Permissions {
|
||||
_private: (),
|
||||
/// ```no_run
|
||||
/// # fn main() -> std::io::Result<()> { async_std::task::block_on(async {
|
||||
/// #
|
||||
/// use async_std::fs;
|
||||
///
|
||||
/// let perm = fs::metadata("a.txt").await?.permissions();
|
||||
/// println!("{:?}", perm.readonly());
|
||||
/// #
|
||||
/// # Ok(()) }) }
|
||||
/// ```
|
||||
pub fn readonly(&self) -> bool {
|
||||
unimplemented!()
|
||||
}
|
||||
|
||||
impl Permissions {
|
||||
/// Returns the read-only flag.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```no_run
|
||||
/// # fn main() -> std::io::Result<()> { async_std::task::block_on(async {
|
||||
/// #
|
||||
/// use async_std::fs;
|
||||
///
|
||||
/// let perm = fs::metadata("a.txt").await?.permissions();
|
||||
/// println!("{:?}", perm.readonly());
|
||||
/// #
|
||||
/// # Ok(()) }) }
|
||||
/// ```
|
||||
pub fn readonly(&self) -> bool {
|
||||
unimplemented!()
|
||||
}
|
||||
|
||||
/// Configures the read-only flag.
|
||||
///
|
||||
/// [`fs::set_permissions`]: fn.set_permissions.html
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```no_run
|
||||
/// # fn main() -> std::io::Result<()> { async_std::task::block_on(async {
|
||||
/// #
|
||||
/// use async_std::fs;
|
||||
///
|
||||
/// let mut perm = fs::metadata("a.txt").await?.permissions();
|
||||
/// perm.set_readonly(true);
|
||||
/// fs::set_permissions("a.txt", perm).await?;
|
||||
/// #
|
||||
/// # Ok(()) }) }
|
||||
/// ```
|
||||
pub fn set_readonly(&mut self, readonly: bool) {
|
||||
unimplemented!()
|
||||
}
|
||||
/// Configures the read-only flag.
|
||||
///
|
||||
/// [`fs::set_permissions`]: fn.set_permissions.html
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```no_run
|
||||
/// # fn main() -> std::io::Result<()> { async_std::task::block_on(async {
|
||||
/// #
|
||||
/// use async_std::fs;
|
||||
///
|
||||
/// let mut perm = fs::metadata("a.txt").await?.permissions();
|
||||
/// perm.set_readonly(true);
|
||||
/// fs::set_permissions("a.txt", perm).await?;
|
||||
/// #
|
||||
/// # Ok(()) }) }
|
||||
/// ```
|
||||
pub fn set_readonly(&mut self, readonly: bool) {
|
||||
unimplemented!()
|
||||
}
|
||||
} else {
|
||||
pub use std::fs::Permissions;
|
||||
}
|
||||
}
|
||||
|
|
|
@ -1,15 +1,9 @@
|
|||
use crate::utils::extension_trait;
|
||||
|
||||
cfg_if::cfg_if! {
|
||||
if #[cfg(feature = "docs")] {
|
||||
use std::pin::Pin;
|
||||
use std::ops::{Deref, DerefMut};
|
||||
|
||||
use crate::task::{Context, Poll};
|
||||
}
|
||||
}
|
||||
|
||||
extension_trait! {
|
||||
use std::pin::Pin;
|
||||
use std::ops::{Deref, DerefMut};
|
||||
|
||||
use crate::task::{Context, Poll};
|
||||
|
||||
#[doc = r#"
|
||||
A future represents an asynchronous computation.
|
||||
|
||||
|
|
|
@ -30,7 +30,7 @@ use crate::future::Future;
|
|||
/// }
|
||||
/// }
|
||||
/// ```
|
||||
#[cfg(any(feature = "unstable", feature = "docs"))]
|
||||
#[cfg(feature = "unstable")]
|
||||
#[cfg_attr(feature = "docs", doc(cfg(unstable)))]
|
||||
pub trait IntoFuture {
|
||||
/// The type of value produced on completion.
|
||||
|
|
|
@ -44,12 +44,6 @@
|
|||
#[doc(inline)]
|
||||
pub use async_macros::{join, try_join};
|
||||
|
||||
#[doc(inline)]
|
||||
#[cfg_attr(feature = "docs", doc(cfg(unstable)))]
|
||||
pub use async_macros::{select, try_select};
|
||||
|
||||
use cfg_if::cfg_if;
|
||||
|
||||
pub use future::Future;
|
||||
pub use pending::pending;
|
||||
pub use poll_fn::poll_fn;
|
||||
|
@ -62,10 +56,10 @@ mod poll_fn;
|
|||
mod ready;
|
||||
mod timeout;
|
||||
|
||||
cfg_if! {
|
||||
if #[cfg(any(feature = "unstable", feature = "docs"))] {
|
||||
mod into_future;
|
||||
cfg_unstable! {
|
||||
#[doc(inline)]
|
||||
pub use async_macros::{select, try_select};
|
||||
|
||||
pub use into_future::IntoFuture;
|
||||
}
|
||||
pub use into_future::IntoFuture;
|
||||
mod into_future;
|
||||
}
|
||||
|
|
|
@ -12,19 +12,12 @@ use read_until::ReadUntilFuture;
|
|||
use std::mem;
|
||||
use std::pin::Pin;
|
||||
|
||||
use cfg_if::cfg_if;
|
||||
|
||||
use crate::io;
|
||||
use crate::task::{Context, Poll};
|
||||
use crate::utils::extension_trait;
|
||||
|
||||
cfg_if! {
|
||||
if #[cfg(feature = "docs")] {
|
||||
use std::ops::{Deref, DerefMut};
|
||||
}
|
||||
}
|
||||
|
||||
extension_trait! {
|
||||
use std::ops::{Deref, DerefMut};
|
||||
|
||||
#[doc = r#"
|
||||
Allows reading from a buffered byte stream.
|
||||
|
||||
|
|
|
@ -13,23 +13,17 @@ use read_to_end::{read_to_end_internal, ReadToEndFuture};
|
|||
use read_to_string::ReadToStringFuture;
|
||||
use read_vectored::ReadVectoredFuture;
|
||||
|
||||
use cfg_if::cfg_if;
|
||||
use std::mem;
|
||||
|
||||
use crate::io::IoSliceMut;
|
||||
use crate::utils::extension_trait;
|
||||
|
||||
cfg_if! {
|
||||
if #[cfg(feature = "docs")] {
|
||||
use std::pin::Pin;
|
||||
use std::ops::{Deref, DerefMut};
|
||||
|
||||
use crate::io;
|
||||
use crate::task::{Context, Poll};
|
||||
}
|
||||
}
|
||||
|
||||
extension_trait! {
|
||||
use std::pin::Pin;
|
||||
use std::ops::{Deref, DerefMut};
|
||||
|
||||
use crate::io;
|
||||
use crate::task::{Context, Poll};
|
||||
|
||||
#[doc = r#"
|
||||
Allows reading from a byte stream.
|
||||
|
||||
|
|
|
@ -1,19 +1,16 @@
|
|||
use std::pin::Pin;
|
||||
mod seek;
|
||||
|
||||
use cfg_if::cfg_if;
|
||||
use seek::SeekFuture;
|
||||
|
||||
use crate::future::Future;
|
||||
use crate::io::{self, SeekFrom};
|
||||
use crate::task::{Context, Poll};
|
||||
use crate::utils::extension_trait;
|
||||
|
||||
cfg_if! {
|
||||
if #[cfg(feature = "docs")] {
|
||||
use std::ops::{Deref, DerefMut};
|
||||
}
|
||||
}
|
||||
use crate::io::SeekFrom;
|
||||
|
||||
extension_trait! {
|
||||
use std::ops::{Deref, DerefMut};
|
||||
use std::pin::Pin;
|
||||
|
||||
use crate::io;
|
||||
use crate::task::{Context, Poll};
|
||||
|
||||
#[doc = r#"
|
||||
Allows seeking through a byte stream.
|
||||
|
||||
|
@ -114,19 +111,3 @@ extension_trait! {
|
|||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[doc(hidden)]
|
||||
#[allow(missing_debug_implementations)]
|
||||
pub struct SeekFuture<'a, T: Unpin + ?Sized> {
|
||||
seeker: &'a mut T,
|
||||
pos: SeekFrom,
|
||||
}
|
||||
|
||||
impl<T: SeekExt + Unpin + ?Sized> Future for SeekFuture<'_, T> {
|
||||
type Output = io::Result<u64>;
|
||||
|
||||
fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
|
||||
let pos = self.pos;
|
||||
Pin::new(&mut *self.seeker).poll_seek(cx, pos)
|
||||
}
|
||||
}
|
21
src/io/seek/seek.rs
Normal file
21
src/io/seek/seek.rs
Normal file
|
@ -0,0 +1,21 @@
|
|||
use std::pin::Pin;
|
||||
|
||||
use crate::future::Future;
|
||||
use crate::io::{self, Seek, SeekFrom};
|
||||
use crate::task::{Context, Poll};
|
||||
|
||||
#[doc(hidden)]
|
||||
#[allow(missing_debug_implementations)]
|
||||
pub struct SeekFuture<'a, T: Unpin + ?Sized> {
|
||||
pub(crate) seeker: &'a mut T,
|
||||
pub(crate) pos: SeekFrom,
|
||||
}
|
||||
|
||||
impl<T: Seek + Unpin + ?Sized> Future for SeekFuture<'_, T> {
|
||||
type Output = io::Result<u64>;
|
||||
|
||||
fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
|
||||
let pos = self.pos;
|
||||
Pin::new(&mut *self.seeker).poll_seek(cx, pos)
|
||||
}
|
||||
}
|
|
@ -1,8 +1,6 @@
|
|||
use std::pin::Pin;
|
||||
use std::sync::Mutex;
|
||||
|
||||
use cfg_if::cfg_if;
|
||||
|
||||
use crate::future::Future;
|
||||
use crate::io::{self, Write};
|
||||
use crate::task::{blocking, Context, JoinHandle, Poll};
|
||||
|
@ -162,35 +160,22 @@ impl Write for Stderr {
|
|||
}
|
||||
}
|
||||
|
||||
cfg_if! {
|
||||
if #[cfg(feature = "docs")] {
|
||||
use crate::os::unix::io::{AsRawFd, RawFd};
|
||||
use crate::os::windows::io::{AsRawHandle, RawHandle};
|
||||
} else if #[cfg(unix)] {
|
||||
use std::os::unix::io::{AsRawFd, RawFd};
|
||||
} else if #[cfg(windows)] {
|
||||
use std::os::windows::io::{AsRawHandle, RawHandle};
|
||||
}
|
||||
}
|
||||
cfg_unix! {
|
||||
use crate::os::unix::io::{AsRawFd, RawFd};
|
||||
|
||||
#[cfg_attr(feature = "docs", doc(cfg(unix)))]
|
||||
cfg_if! {
|
||||
if #[cfg(any(unix, feature = "docs"))] {
|
||||
impl AsRawFd for Stderr {
|
||||
fn as_raw_fd(&self) -> RawFd {
|
||||
std::io::stderr().as_raw_fd()
|
||||
}
|
||||
impl AsRawFd for Stderr {
|
||||
fn as_raw_fd(&self) -> RawFd {
|
||||
std::io::stderr().as_raw_fd()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg_attr(feature = "docs", doc(cfg(unix)))]
|
||||
cfg_if! {
|
||||
if #[cfg(any(windows, feature = "docs"))] {
|
||||
impl AsRawHandle for Stderr {
|
||||
fn as_raw_handle(&self) -> RawHandle {
|
||||
std::io::stderr().as_raw_handle()
|
||||
}
|
||||
cfg_windows! {
|
||||
use crate::os::windows::io::{AsRawHandle, RawHandle};
|
||||
|
||||
impl AsRawHandle for Stderr {
|
||||
fn as_raw_handle(&self) -> RawHandle {
|
||||
std::io::stderr().as_raw_handle()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
@ -1,8 +1,6 @@
|
|||
use std::pin::Pin;
|
||||
use std::sync::Mutex;
|
||||
|
||||
use cfg_if::cfg_if;
|
||||
|
||||
use crate::future::{self, Future};
|
||||
use crate::io::{self, Read};
|
||||
use crate::task::{blocking, Context, JoinHandle, Poll};
|
||||
|
@ -186,35 +184,22 @@ impl Read for Stdin {
|
|||
}
|
||||
}
|
||||
|
||||
cfg_if! {
|
||||
if #[cfg(feature = "docs")] {
|
||||
use crate::os::unix::io::{AsRawFd, RawFd};
|
||||
use crate::os::windows::io::{AsRawHandle, RawHandle};
|
||||
} else if #[cfg(unix)] {
|
||||
use std::os::unix::io::{AsRawFd, RawFd};
|
||||
} else if #[cfg(windows)] {
|
||||
use std::os::windows::io::{AsRawHandle, RawHandle};
|
||||
}
|
||||
}
|
||||
cfg_unix! {
|
||||
use crate::os::unix::io::{AsRawFd, RawFd};
|
||||
|
||||
#[cfg_attr(feature = "docs", doc(cfg(unix)))]
|
||||
cfg_if! {
|
||||
if #[cfg(any(unix, feature = "docs"))] {
|
||||
impl AsRawFd for Stdin {
|
||||
fn as_raw_fd(&self) -> RawFd {
|
||||
std::io::stdin().as_raw_fd()
|
||||
}
|
||||
impl AsRawFd for Stdin {
|
||||
fn as_raw_fd(&self) -> RawFd {
|
||||
std::io::stdin().as_raw_fd()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg_attr(feature = "docs", doc(cfg(unix)))]
|
||||
cfg_if! {
|
||||
if #[cfg(any(windows, feature = "docs"))] {
|
||||
impl AsRawHandle for Stdin {
|
||||
fn as_raw_handle(&self) -> RawHandle {
|
||||
std::io::stdin().as_raw_handle()
|
||||
}
|
||||
cfg_windows! {
|
||||
use crate::os::windows::io::{AsRawHandle, RawHandle};
|
||||
|
||||
impl AsRawHandle for Stdin {
|
||||
fn as_raw_handle(&self) -> RawHandle {
|
||||
std::io::stdin().as_raw_handle()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
@ -1,8 +1,6 @@
|
|||
use std::pin::Pin;
|
||||
use std::sync::Mutex;
|
||||
|
||||
use cfg_if::cfg_if;
|
||||
|
||||
use crate::future::Future;
|
||||
use crate::io::{self, Write};
|
||||
use crate::task::{blocking, Context, JoinHandle, Poll};
|
||||
|
@ -162,35 +160,22 @@ impl Write for Stdout {
|
|||
}
|
||||
}
|
||||
|
||||
cfg_if! {
|
||||
if #[cfg(feature = "docs")] {
|
||||
use crate::os::unix::io::{AsRawFd, RawFd};
|
||||
use crate::os::windows::io::{AsRawHandle, RawHandle};
|
||||
} else if #[cfg(unix)] {
|
||||
use std::os::unix::io::{AsRawFd, RawFd};
|
||||
} else if #[cfg(windows)] {
|
||||
use std::os::windows::io::{AsRawHandle, RawHandle};
|
||||
}
|
||||
}
|
||||
cfg_unix! {
|
||||
use crate::os::unix::io::{AsRawFd, RawFd};
|
||||
|
||||
#[cfg_attr(feature = "docs", doc(cfg(unix)))]
|
||||
cfg_if! {
|
||||
if #[cfg(any(unix, feature = "docs"))] {
|
||||
impl AsRawFd for Stdout {
|
||||
fn as_raw_fd(&self) -> RawFd {
|
||||
std::io::stdout().as_raw_fd()
|
||||
}
|
||||
impl AsRawFd for Stdout {
|
||||
fn as_raw_fd(&self) -> RawFd {
|
||||
std::io::stdout().as_raw_fd()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg_attr(feature = "docs", doc(cfg(unix)))]
|
||||
cfg_if! {
|
||||
if #[cfg(any(windows, feature = "docs"))] {
|
||||
impl AsRawHandle for Stdout {
|
||||
fn as_raw_handle(&self) -> RawHandle {
|
||||
std::io::stdout().as_raw_handle()
|
||||
}
|
||||
cfg_windows! {
|
||||
use crate::os::windows::io::{AsRawHandle, RawHandle};
|
||||
|
||||
impl AsRawHandle for Stdout {
|
||||
fn as_raw_handle(&self) -> RawHandle {
|
||||
std::io::stdout().as_raw_handle()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
@ -10,22 +10,14 @@ use write_all::WriteAllFuture;
|
|||
use write_fmt::WriteFmtFuture;
|
||||
use write_vectored::WriteVectoredFuture;
|
||||
|
||||
use cfg_if::cfg_if;
|
||||
|
||||
use crate::io::IoSlice;
|
||||
use crate::utils::extension_trait;
|
||||
|
||||
use crate::io;
|
||||
|
||||
cfg_if! {
|
||||
if #[cfg(feature = "docs")] {
|
||||
use std::pin::Pin;
|
||||
use std::ops::{Deref, DerefMut};
|
||||
use crate::task::{Context, Poll};
|
||||
}
|
||||
}
|
||||
use crate::io::{self, IoSlice};
|
||||
|
||||
extension_trait! {
|
||||
use std::pin::Pin;
|
||||
use std::ops::{Deref, DerefMut};
|
||||
|
||||
use crate::task::{Context, Poll};
|
||||
|
||||
#[doc = r#"
|
||||
Allows writing to a byte stream.
|
||||
|
||||
|
|
34
src/lib.rs
34
src/lib.rs
|
@ -48,7 +48,8 @@
|
|||
#![doc(html_logo_url = "https://async.rs/images/logo--hero.svg")]
|
||||
#![recursion_limit = "1024"]
|
||||
|
||||
use cfg_if::cfg_if;
|
||||
#[macro_use]
|
||||
mod utils;
|
||||
|
||||
pub mod fs;
|
||||
pub mod future;
|
||||
|
@ -61,26 +62,19 @@ pub mod stream;
|
|||
pub mod sync;
|
||||
pub mod task;
|
||||
|
||||
cfg_if! {
|
||||
if #[cfg(any(feature = "unstable", feature = "docs"))] {
|
||||
#[cfg_attr(feature = "docs", doc(cfg(unstable)))]
|
||||
pub mod pin;
|
||||
#[cfg_attr(feature = "docs", doc(cfg(unstable)))]
|
||||
pub mod process;
|
||||
cfg_unstable! {
|
||||
pub mod pin;
|
||||
pub mod process;
|
||||
|
||||
mod unit;
|
||||
mod vec;
|
||||
mod result;
|
||||
mod option;
|
||||
mod string;
|
||||
mod collections;
|
||||
}
|
||||
mod unit;
|
||||
mod vec;
|
||||
mod result;
|
||||
mod option;
|
||||
mod string;
|
||||
mod collections;
|
||||
|
||||
#[doc(inline)]
|
||||
pub use std::{write, writeln};
|
||||
}
|
||||
|
||||
mod macros;
|
||||
pub(crate) mod utils;
|
||||
|
||||
#[cfg(any(feature = "unstable", feature = "docs"))]
|
||||
#[cfg_attr(feature = "docs", doc(cfg(unstable)))]
|
||||
#[doc(inline)]
|
||||
pub use std::{write, writeln};
|
||||
|
|
|
@ -43,7 +43,7 @@
|
|||
/// #
|
||||
/// # })
|
||||
/// ```
|
||||
#[cfg(any(feature = "unstable", feature = "docs"))]
|
||||
#[cfg(feature = "unstable")]
|
||||
#[cfg_attr(feature = "docs", doc(cfg(unstable)))]
|
||||
#[macro_export]
|
||||
macro_rules! print {
|
||||
|
@ -81,7 +81,7 @@ macro_rules! print {
|
|||
/// #
|
||||
/// # })
|
||||
/// ```
|
||||
#[cfg(any(feature = "unstable", feature = "docs"))]
|
||||
#[cfg(feature = "unstable")]
|
||||
#[cfg_attr(feature = "docs", doc(cfg(unstable)))]
|
||||
#[macro_export]
|
||||
macro_rules! println {
|
||||
|
@ -119,7 +119,7 @@ macro_rules! println {
|
|||
/// #
|
||||
/// # })
|
||||
/// ```
|
||||
#[cfg(any(feature = "unstable", feature = "docs"))]
|
||||
#[cfg(feature = "unstable")]
|
||||
#[cfg_attr(feature = "docs", doc(cfg(unstable)))]
|
||||
#[macro_export]
|
||||
macro_rules! eprint {
|
||||
|
@ -153,7 +153,7 @@ macro_rules! eprint {
|
|||
/// #
|
||||
/// # })
|
||||
/// ```
|
||||
#[cfg(any(feature = "unstable", feature = "docs"))]
|
||||
#[cfg(feature = "unstable")]
|
||||
#[cfg_attr(feature = "docs", doc(cfg(unstable)))]
|
||||
#[macro_export]
|
||||
macro_rules! eprintln {
|
||||
|
|
|
@ -3,24 +3,22 @@ use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
|
|||
use std::net::{SocketAddr, SocketAddrV4, SocketAddrV6};
|
||||
use std::pin::Pin;
|
||||
|
||||
use cfg_if::cfg_if;
|
||||
|
||||
use crate::future::Future;
|
||||
use crate::io;
|
||||
use crate::task::{blocking, Context, JoinHandle, Poll};
|
||||
|
||||
cfg_if! {
|
||||
if #[cfg(feature = "docs")] {
|
||||
#[doc(hidden)]
|
||||
pub struct ImplFuture<T>(std::marker::PhantomData<T>);
|
||||
cfg_not_docs! {
|
||||
macro_rules! ret {
|
||||
(impl Future<Output = $out:ty>, $fut:ty) => ($fut);
|
||||
}
|
||||
}
|
||||
|
||||
macro_rules! ret {
|
||||
(impl Future<Output = $out:ty>, $fut:ty) => (ImplFuture<$out>);
|
||||
}
|
||||
} else {
|
||||
macro_rules! ret {
|
||||
(impl Future<Output = $out:ty>, $fut:ty) => ($fut);
|
||||
}
|
||||
cfg_docs! {
|
||||
#[doc(hidden)]
|
||||
pub struct ImplFuture<T>(std::marker::PhantomData<T>);
|
||||
|
||||
macro_rules! ret {
|
||||
(impl Future<Output = $out:ty>, $fut:ty) => (ImplFuture<$out>);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -1,13 +1,10 @@
|
|||
use std::net::SocketAddr;
|
||||
use std::pin::Pin;
|
||||
|
||||
use cfg_if::cfg_if;
|
||||
|
||||
use super::TcpStream;
|
||||
use crate::future::{self, Future};
|
||||
use crate::io;
|
||||
use crate::net::driver::Watcher;
|
||||
use crate::net::ToSocketAddrs;
|
||||
use crate::net::{TcpStream, ToSocketAddrs};
|
||||
use crate::stream::Stream;
|
||||
use crate::task::{Context, Poll};
|
||||
|
||||
|
@ -213,59 +210,46 @@ impl From<std::net::TcpListener> for TcpListener {
|
|||
}
|
||||
}
|
||||
|
||||
cfg_if! {
|
||||
if #[cfg(feature = "docs")] {
|
||||
use crate::os::unix::io::{AsRawFd, FromRawFd, IntoRawFd, RawFd};
|
||||
// use crate::os::windows::io::{AsRawHandle, FromRawHandle, IntoRawHandle, RawHandle};
|
||||
} else if #[cfg(unix)] {
|
||||
use std::os::unix::io::{AsRawFd, FromRawFd, IntoRawFd, RawFd};
|
||||
} else if #[cfg(windows)] {
|
||||
// use std::os::windows::io::{AsRawHandle, FromRawHandle, IntoRawHandle, RawHandle};
|
||||
cfg_unix! {
|
||||
use crate::os::unix::io::{AsRawFd, FromRawFd, IntoRawFd, RawFd};
|
||||
|
||||
impl AsRawFd for TcpListener {
|
||||
fn as_raw_fd(&self) -> RawFd {
|
||||
self.watcher.get_ref().as_raw_fd()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg_attr(feature = "docs", doc(cfg(unix)))]
|
||||
cfg_if! {
|
||||
if #[cfg(any(unix, feature = "docs"))] {
|
||||
impl AsRawFd for TcpListener {
|
||||
fn as_raw_fd(&self) -> RawFd {
|
||||
self.watcher.get_ref().as_raw_fd()
|
||||
}
|
||||
impl FromRawFd for TcpListener {
|
||||
unsafe fn from_raw_fd(fd: RawFd) -> TcpListener {
|
||||
std::net::TcpListener::from_raw_fd(fd).into()
|
||||
}
|
||||
}
|
||||
|
||||
impl FromRawFd for TcpListener {
|
||||
unsafe fn from_raw_fd(fd: RawFd) -> TcpListener {
|
||||
std::net::TcpListener::from_raw_fd(fd).into()
|
||||
}
|
||||
}
|
||||
|
||||
impl IntoRawFd for TcpListener {
|
||||
fn into_raw_fd(self) -> RawFd {
|
||||
self.watcher.into_inner().into_raw_fd()
|
||||
}
|
||||
impl IntoRawFd for TcpListener {
|
||||
fn into_raw_fd(self) -> RawFd {
|
||||
self.watcher.into_inner().into_raw_fd()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg_attr(feature = "docs", doc(cfg(windows)))]
|
||||
cfg_if! {
|
||||
if #[cfg(any(windows, feature = "docs"))] {
|
||||
// impl AsRawSocket for TcpListener {
|
||||
// fn as_raw_socket(&self) -> RawSocket {
|
||||
// self.raw_socket
|
||||
// }
|
||||
// }
|
||||
//
|
||||
// impl FromRawSocket for TcpListener {
|
||||
// unsafe fn from_raw_socket(handle: RawSocket) -> TcpListener {
|
||||
// net::TcpListener::from_raw_socket(handle).try_into().unwrap()
|
||||
// }
|
||||
// }
|
||||
//
|
||||
// impl IntoRawSocket for TcpListener {
|
||||
// fn into_raw_socket(self) -> RawSocket {
|
||||
// self.raw_socket
|
||||
// }
|
||||
// }
|
||||
}
|
||||
cfg_windows! {
|
||||
// use crate::os::windows::io::{AsRawHandle, FromRawHandle, IntoRawHandle, RawHandle};
|
||||
//
|
||||
// impl AsRawSocket for TcpListener {
|
||||
// fn as_raw_socket(&self) -> RawSocket {
|
||||
// self.raw_socket
|
||||
// }
|
||||
// }
|
||||
//
|
||||
// impl FromRawSocket for TcpListener {
|
||||
// unsafe fn from_raw_socket(handle: RawSocket) -> TcpListener {
|
||||
// net::TcpListener::from_raw_socket(handle).try_into().unwrap()
|
||||
// }
|
||||
// }
|
||||
//
|
||||
// impl IntoRawSocket for TcpListener {
|
||||
// fn into_raw_socket(self) -> RawSocket {
|
||||
// self.raw_socket
|
||||
// }
|
||||
// }
|
||||
}
|
||||
|
|
|
@ -2,8 +2,6 @@ use std::io::{IoSlice, IoSliceMut, Read as _, Write as _};
|
|||
use std::net::SocketAddr;
|
||||
use std::pin::Pin;
|
||||
|
||||
use cfg_if::cfg_if;
|
||||
|
||||
use crate::future;
|
||||
use crate::io::{self, Read, Write};
|
||||
use crate::net::driver::Watcher;
|
||||
|
@ -367,59 +365,46 @@ impl From<std::net::TcpStream> for TcpStream {
|
|||
}
|
||||
}
|
||||
|
||||
cfg_if! {
|
||||
if #[cfg(feature = "docs")] {
|
||||
use crate::os::unix::io::{AsRawFd, FromRawFd, IntoRawFd, RawFd};
|
||||
// use crate::os::windows::io::{AsRawHandle, FromRawHandle, IntoRawHandle, RawHandle};
|
||||
} else if #[cfg(unix)] {
|
||||
use std::os::unix::io::{AsRawFd, FromRawFd, IntoRawFd, RawFd};
|
||||
} else if #[cfg(windows)] {
|
||||
// use std::os::windows::io::{AsRawHandle, FromRawHandle, IntoRawHandle, RawHandle};
|
||||
cfg_unix! {
|
||||
use crate::os::unix::io::{AsRawFd, FromRawFd, IntoRawFd, RawFd};
|
||||
|
||||
impl AsRawFd for TcpStream {
|
||||
fn as_raw_fd(&self) -> RawFd {
|
||||
self.watcher.get_ref().as_raw_fd()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg_attr(feature = "docs", doc(cfg(unix)))]
|
||||
cfg_if! {
|
||||
if #[cfg(any(unix, feature = "docs"))] {
|
||||
impl AsRawFd for TcpStream {
|
||||
fn as_raw_fd(&self) -> RawFd {
|
||||
self.watcher.get_ref().as_raw_fd()
|
||||
}
|
||||
impl FromRawFd for TcpStream {
|
||||
unsafe fn from_raw_fd(fd: RawFd) -> TcpStream {
|
||||
std::net::TcpStream::from_raw_fd(fd).into()
|
||||
}
|
||||
}
|
||||
|
||||
impl FromRawFd for TcpStream {
|
||||
unsafe fn from_raw_fd(fd: RawFd) -> TcpStream {
|
||||
std::net::TcpStream::from_raw_fd(fd).into()
|
||||
}
|
||||
}
|
||||
|
||||
impl IntoRawFd for TcpStream {
|
||||
fn into_raw_fd(self) -> RawFd {
|
||||
self.watcher.into_inner().into_raw_fd()
|
||||
}
|
||||
impl IntoRawFd for TcpStream {
|
||||
fn into_raw_fd(self) -> RawFd {
|
||||
self.watcher.into_inner().into_raw_fd()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg_attr(feature = "docs", doc(cfg(windows)))]
|
||||
cfg_if! {
|
||||
if #[cfg(any(windows, feature = "docs"))] {
|
||||
// impl AsRawSocket for TcpStream {
|
||||
// fn as_raw_socket(&self) -> RawSocket {
|
||||
// self.raw_socket
|
||||
// }
|
||||
// }
|
||||
//
|
||||
// impl FromRawSocket for TcpStream {
|
||||
// unsafe fn from_raw_socket(handle: RawSocket) -> TcpStream {
|
||||
// net::TcpStream::from_raw_socket(handle).try_into().unwrap()
|
||||
// }
|
||||
// }
|
||||
//
|
||||
// impl IntoRawSocket for TcpListener {
|
||||
// fn into_raw_socket(self) -> RawSocket {
|
||||
// self.raw_socket
|
||||
// }
|
||||
// }
|
||||
}
|
||||
cfg_windows! {
|
||||
// use crate::os::windows::io::{AsRawHandle, FromRawHandle, IntoRawHandle, RawHandle};
|
||||
//
|
||||
// impl AsRawSocket for TcpStream {
|
||||
// fn as_raw_socket(&self) -> RawSocket {
|
||||
// self.raw_socket
|
||||
// }
|
||||
// }
|
||||
//
|
||||
// impl FromRawSocket for TcpStream {
|
||||
// unsafe fn from_raw_socket(handle: RawSocket) -> TcpStream {
|
||||
// net::TcpStream::from_raw_socket(handle).try_into().unwrap()
|
||||
// }
|
||||
// }
|
||||
//
|
||||
// impl IntoRawSocket for TcpListener {
|
||||
// fn into_raw_socket(self) -> RawSocket {
|
||||
// self.raw_socket
|
||||
// }
|
||||
// }
|
||||
}
|
||||
|
|
|
@ -1,7 +1,5 @@
|
|||
use std::io;
|
||||
use std::net::SocketAddr;
|
||||
|
||||
use cfg_if::cfg_if;
|
||||
use std::net::{Ipv4Addr, Ipv6Addr};
|
||||
|
||||
use crate::future;
|
||||
|
@ -463,61 +461,46 @@ impl From<std::net::UdpSocket> for UdpSocket {
|
|||
}
|
||||
}
|
||||
|
||||
cfg_if! {
|
||||
if #[cfg(feature = "docs")] {
|
||||
use crate::os::unix::io::{AsRawFd, FromRawFd, IntoRawFd, RawFd};
|
||||
// use crate::os::windows::io::{AsRawHandle, FromRawHandle, IntoRawHandle, RawHandle};
|
||||
} else if #[cfg(unix)] {
|
||||
use std::os::unix::io::{AsRawFd, FromRawFd, IntoRawFd, RawFd};
|
||||
} else if #[cfg(windows)] {
|
||||
// use std::os::windows::io::{AsRawHandle, FromRawHandle, IntoRawHandle, RawHandle};
|
||||
cfg_unix! {
|
||||
use crate::os::unix::io::{AsRawFd, FromRawFd, IntoRawFd, RawFd};
|
||||
|
||||
impl AsRawFd for UdpSocket {
|
||||
fn as_raw_fd(&self) -> RawFd {
|
||||
self.watcher.get_ref().as_raw_fd()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg_attr(feature = "docs", doc(cfg(unix)))]
|
||||
cfg_if! {
|
||||
if #[cfg(any(unix, feature = "docs"))] {
|
||||
impl AsRawFd for UdpSocket {
|
||||
fn as_raw_fd(&self) -> RawFd {
|
||||
self.watcher.get_ref().as_raw_fd()
|
||||
}
|
||||
impl FromRawFd for UdpSocket {
|
||||
unsafe fn from_raw_fd(fd: RawFd) -> UdpSocket {
|
||||
std::net::UdpSocket::from_raw_fd(fd).into()
|
||||
}
|
||||
}
|
||||
|
||||
impl FromRawFd for UdpSocket {
|
||||
unsafe fn from_raw_fd(fd: RawFd) -> UdpSocket {
|
||||
std::net::UdpSocket::from_raw_fd(fd).into()
|
||||
}
|
||||
}
|
||||
|
||||
impl IntoRawFd for UdpSocket {
|
||||
fn into_raw_fd(self) -> RawFd {
|
||||
self.watcher.into_inner().into_raw_fd()
|
||||
}
|
||||
impl IntoRawFd for UdpSocket {
|
||||
fn into_raw_fd(self) -> RawFd {
|
||||
self.watcher.into_inner().into_raw_fd()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg_attr(feature = "docs", doc(cfg(windows)))]
|
||||
cfg_if! {
|
||||
if #[cfg(any(windows, feature = "docs"))] {
|
||||
// use std::os::windows::io::{AsRawSocket, FromRawSocket, IntoRawSocket, RawSocket};
|
||||
//
|
||||
// impl AsRawSocket for UdpSocket {
|
||||
// fn as_raw_socket(&self) -> RawSocket {
|
||||
// self.raw_socket
|
||||
// }
|
||||
// }
|
||||
//
|
||||
// impl FromRawSocket for UdpSocket {
|
||||
// unsafe fn from_raw_socket(handle: RawSocket) -> UdpSocket {
|
||||
// net::UdpSocket::from_raw_socket(handle).into()
|
||||
// }
|
||||
// }
|
||||
//
|
||||
// impl IntoRawSocket for UdpSocket {
|
||||
// fn into_raw_socket(self) -> RawSocket {
|
||||
// self.raw_socket
|
||||
// }
|
||||
// }
|
||||
}
|
||||
cfg_windows! {
|
||||
// use crate::os::windows::io::{AsRawHandle, FromRawHandle, IntoRawHandle, RawHandle};
|
||||
//
|
||||
// impl AsRawSocket for UdpSocket {
|
||||
// fn as_raw_socket(&self) -> RawSocket {
|
||||
// self.raw_socket
|
||||
// }
|
||||
// }
|
||||
//
|
||||
// impl FromRawSocket for UdpSocket {
|
||||
// unsafe fn from_raw_socket(handle: RawSocket) -> UdpSocket {
|
||||
// net::UdpSocket::from_raw_socket(handle).into()
|
||||
// }
|
||||
// }
|
||||
//
|
||||
// impl IntoRawSocket for UdpSocket {
|
||||
// fn into_raw_socket(self) -> RawSocket {
|
||||
// self.raw_socket
|
||||
// }
|
||||
// }
|
||||
}
|
||||
|
|
|
@ -1,9 +1,9 @@
|
|||
//! OS-specific extensions.
|
||||
|
||||
#[cfg(any(unix, feature = "docs"))]
|
||||
#[cfg_attr(feature = "docs", doc(cfg(unix)))]
|
||||
pub mod unix;
|
||||
cfg_unix! {
|
||||
pub mod unix;
|
||||
}
|
||||
|
||||
#[cfg(any(windows, feature = "docs"))]
|
||||
#[cfg_attr(feature = "docs", doc(cfg(windows)))]
|
||||
pub mod windows;
|
||||
cfg_windows! {
|
||||
pub mod windows;
|
||||
}
|
||||
|
|
|
@ -1,7 +1,5 @@
|
|||
//! Unix-specific filesystem extensions.
|
||||
|
||||
use cfg_if::cfg_if;
|
||||
|
||||
use crate::io;
|
||||
use crate::path::Path;
|
||||
use crate::task::blocking;
|
||||
|
@ -31,43 +29,43 @@ pub async fn symlink<P: AsRef<Path>, Q: AsRef<Path>>(src: P, dst: Q) -> io::Resu
|
|||
blocking::spawn(move || std::os::unix::fs::symlink(&src, &dst)).await
|
||||
}
|
||||
|
||||
cfg_if! {
|
||||
if #[cfg(feature = "docs")] {
|
||||
/// Unix-specific extensions to `DirBuilder`.
|
||||
pub trait DirBuilderExt {
|
||||
/// Sets the mode to create new directories with. This option defaults to
|
||||
/// `0o777`.
|
||||
fn mode(&mut self, mode: u32) -> &mut Self;
|
||||
}
|
||||
cfg_not_docs! {
|
||||
pub use std::os::unix::fs::{DirBuilderExt, DirEntryExt, OpenOptionsExt};
|
||||
}
|
||||
|
||||
/// Unix-specific extension methods for `DirEntry`.
|
||||
pub trait DirEntryExt {
|
||||
/// Returns the underlying `d_ino` field in the contained `dirent`
|
||||
/// structure.
|
||||
fn ino(&self) -> u64;
|
||||
}
|
||||
cfg_docs! {
|
||||
/// Unix-specific extensions to `DirBuilder`.
|
||||
pub trait DirBuilderExt {
|
||||
/// Sets the mode to create new directories with. This option defaults to
|
||||
/// `0o777`.
|
||||
fn mode(&mut self, mode: u32) -> &mut Self;
|
||||
}
|
||||
|
||||
/// Unix-specific extensions to `OpenOptions`.
|
||||
pub trait OpenOptionsExt {
|
||||
/// Sets the mode bits that a new file will be created with.
|
||||
///
|
||||
/// If a new file is created as part of a `File::open_opts` call then this
|
||||
/// specified `mode` will be used as the permission bits for the new file.
|
||||
/// If no `mode` is set, the default of `0o666` will be used.
|
||||
/// The operating system masks out bits with the systems `umask`, to produce
|
||||
/// the final permissions.
|
||||
fn mode(&mut self, mode: u32) -> &mut Self;
|
||||
/// Unix-specific extension methods for `DirEntry`.
|
||||
pub trait DirEntryExt {
|
||||
/// Returns the underlying `d_ino` field in the contained `dirent`
|
||||
/// structure.
|
||||
fn ino(&self) -> u64;
|
||||
}
|
||||
|
||||
/// Pass custom flags to the `flags` argument of `open`.
|
||||
///
|
||||
/// The bits that define the access mode are masked out with `O_ACCMODE`, to
|
||||
/// ensure they do not interfere with the access mode set by Rusts options.
|
||||
///
|
||||
/// Custom flags can only set flags, not remove flags set by Rusts options.
|
||||
/// This options overwrites any previously set custom flags.
|
||||
fn custom_flags(&mut self, flags: i32) -> &mut Self;
|
||||
}
|
||||
} else {
|
||||
pub use std::os::unix::fs::{DirBuilderExt, OpenOptionsExt};
|
||||
/// Unix-specific extensions to `OpenOptions`.
|
||||
pub trait OpenOptionsExt {
|
||||
/// Sets the mode bits that a new file will be created with.
|
||||
///
|
||||
/// If a new file is created as part of a `File::open_opts` call then this
|
||||
/// specified `mode` will be used as the permission bits for the new file.
|
||||
/// If no `mode` is set, the default of `0o666` will be used.
|
||||
/// The operating system masks out bits with the systems `umask`, to produce
|
||||
/// the final permissions.
|
||||
fn mode(&mut self, mode: u32) -> &mut Self;
|
||||
|
||||
/// Pass custom flags to the `flags` argument of `open`.
|
||||
///
|
||||
/// The bits that define the access mode are masked out with `O_ACCMODE`, to
|
||||
/// ensure they do not interfere with the access mode set by Rusts options.
|
||||
///
|
||||
/// Custom flags can only set flags, not remove flags set by Rusts options.
|
||||
/// This options overwrites any previously set custom flags.
|
||||
fn custom_flags(&mut self, flags: i32) -> &mut Self;
|
||||
}
|
||||
}
|
||||
|
|
|
@ -1,56 +1,54 @@
|
|||
//! Unix-specific I/O extensions.
|
||||
|
||||
use cfg_if::cfg_if;
|
||||
cfg_not_docs! {
|
||||
pub use std::os::unix::io::{AsRawFd, FromRawFd, IntoRawFd, RawFd};
|
||||
}
|
||||
|
||||
cfg_if! {
|
||||
if #[cfg(feature = "docs")] {
|
||||
/// Raw file descriptors.
|
||||
pub type RawFd = std::os::raw::c_int;
|
||||
cfg_docs! {
|
||||
/// Raw file descriptors.
|
||||
pub type RawFd = std::os::raw::c_int;
|
||||
|
||||
/// A trait to extract the raw unix file descriptor from an underlying
|
||||
/// object.
|
||||
/// A trait to extract the raw unix file descriptor from an underlying
|
||||
/// object.
|
||||
///
|
||||
/// This is only available on unix platforms and must be imported in order
|
||||
/// to call the method. Windows platforms have a corresponding `AsRawHandle`
|
||||
/// and `AsRawSocket` set of traits.
|
||||
pub trait AsRawFd {
|
||||
/// Extracts the raw file descriptor.
|
||||
///
|
||||
/// This is only available on unix platforms and must be imported in order
|
||||
/// to call the method. Windows platforms have a corresponding `AsRawHandle`
|
||||
/// and `AsRawSocket` set of traits.
|
||||
pub trait AsRawFd {
|
||||
/// Extracts the raw file descriptor.
|
||||
///
|
||||
/// This method does **not** pass ownership of the raw file descriptor
|
||||
/// to the caller. The descriptor is only guaranteed to be valid while
|
||||
/// the original object has not yet been destroyed.
|
||||
fn as_raw_fd(&self) -> RawFd;
|
||||
}
|
||||
/// This method does **not** pass ownership of the raw file descriptor
|
||||
/// to the caller. The descriptor is only guaranteed to be valid while
|
||||
/// the original object has not yet been destroyed.
|
||||
fn as_raw_fd(&self) -> RawFd;
|
||||
}
|
||||
|
||||
/// A trait to express the ability to construct an object from a raw file
|
||||
/// A trait to express the ability to construct an object from a raw file
|
||||
/// descriptor.
|
||||
pub trait FromRawFd {
|
||||
/// Constructs a new instance of `Self` from the given raw file
|
||||
/// descriptor.
|
||||
pub trait FromRawFd {
|
||||
/// Constructs a new instance of `Self` from the given raw file
|
||||
/// descriptor.
|
||||
///
|
||||
/// This function **consumes ownership** of the specified file
|
||||
/// descriptor. The returned object will take responsibility for closing
|
||||
/// it when the object goes out of scope.
|
||||
///
|
||||
/// This function is also unsafe as the primitives currently returned
|
||||
/// have the contract that they are the sole owner of the file
|
||||
/// descriptor they are wrapping. Usage of this function could
|
||||
/// accidentally allow violating this contract which can cause memory
|
||||
/// unsafety in code that relies on it being true.
|
||||
unsafe fn from_raw_fd(fd: RawFd) -> Self;
|
||||
}
|
||||
///
|
||||
/// This function **consumes ownership** of the specified file
|
||||
/// descriptor. The returned object will take responsibility for closing
|
||||
/// it when the object goes out of scope.
|
||||
///
|
||||
/// This function is also unsafe as the primitives currently returned
|
||||
/// have the contract that they are the sole owner of the file
|
||||
/// descriptor they are wrapping. Usage of this function could
|
||||
/// accidentally allow violating this contract which can cause memory
|
||||
/// unsafety in code that relies on it being true.
|
||||
unsafe fn from_raw_fd(fd: RawFd) -> Self;
|
||||
}
|
||||
|
||||
/// A trait to express the ability to consume an object and acquire ownership of
|
||||
/// its raw file descriptor.
|
||||
pub trait IntoRawFd {
|
||||
/// Consumes this object, returning the raw underlying file descriptor.
|
||||
///
|
||||
/// This function **transfers ownership** of the underlying file descriptor
|
||||
/// to the caller. Callers are then the unique owners of the file descriptor
|
||||
/// and must close the descriptor once it's no longer needed.
|
||||
fn into_raw_fd(self) -> RawFd;
|
||||
}
|
||||
} else {
|
||||
pub use std::os::unix::io::{AsRawFd, FromRawFd, IntoRawFd, RawFd};
|
||||
/// A trait to express the ability to consume an object and acquire ownership of
|
||||
/// its raw file descriptor.
|
||||
pub trait IntoRawFd {
|
||||
/// Consumes this object, returning the raw underlying file descriptor.
|
||||
///
|
||||
/// This function **transfers ownership** of the underlying file descriptor
|
||||
/// to the caller. Callers are then the unique owners of the file descriptor
|
||||
/// and must close the descriptor once it's no longer needed.
|
||||
fn into_raw_fd(self) -> RawFd;
|
||||
}
|
||||
}
|
||||
|
|
|
@ -1,7 +1,5 @@
|
|||
//! Unix-specific networking extensions.
|
||||
|
||||
use cfg_if::cfg_if;
|
||||
|
||||
pub use datagram::UnixDatagram;
|
||||
pub use listener::{Incoming, UnixListener};
|
||||
pub use stream::UnixStream;
|
||||
|
@ -10,90 +8,90 @@ mod datagram;
|
|||
mod listener;
|
||||
mod stream;
|
||||
|
||||
cfg_if! {
|
||||
if #[cfg(feature = "docs")] {
|
||||
use std::fmt;
|
||||
cfg_not_docs! {
|
||||
pub use std::os::unix::net::SocketAddr;
|
||||
}
|
||||
|
||||
use crate::path::Path;
|
||||
cfg_docs! {
|
||||
use std::fmt;
|
||||
|
||||
/// An address associated with a Unix socket.
|
||||
use crate::path::Path;
|
||||
|
||||
/// An address associated with a Unix socket.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// use async_std::os::unix::net::UnixListener;
|
||||
///
|
||||
/// let socket = UnixListener::bind("/tmp/socket").await?;
|
||||
/// let addr = socket.local_addr()?;
|
||||
/// ```
|
||||
#[derive(Clone)]
|
||||
pub struct SocketAddr {
|
||||
_private: (),
|
||||
}
|
||||
|
||||
impl SocketAddr {
|
||||
/// Returns `true` if the address is unnamed.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// A named address:
|
||||
///
|
||||
/// ```no_run
|
||||
/// use async_std::os::unix::net::UnixListener;
|
||||
///
|
||||
/// let socket = UnixListener::bind("/tmp/socket").await?;
|
||||
/// let addr = socket.local_addr()?;
|
||||
/// assert_eq!(addr.is_unnamed(), false);
|
||||
/// ```
|
||||
#[derive(Clone)]
|
||||
pub struct SocketAddr {
|
||||
_private: (),
|
||||
///
|
||||
/// An unnamed address:
|
||||
///
|
||||
/// ```no_run
|
||||
/// use async_std::os::unix::net::UnixDatagram;
|
||||
///
|
||||
/// let socket = UnixDatagram::unbound().await?;
|
||||
/// let addr = socket.local_addr()?;
|
||||
/// assert_eq!(addr.is_unnamed(), true);
|
||||
/// ```
|
||||
pub fn is_unnamed(&self) -> bool {
|
||||
unreachable!("this impl only appears in the rendered docs")
|
||||
}
|
||||
|
||||
impl SocketAddr {
|
||||
/// Returns `true` if the address is unnamed.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// A named address:
|
||||
///
|
||||
/// ```no_run
|
||||
/// use async_std::os::unix::net::UnixListener;
|
||||
///
|
||||
/// let socket = UnixListener::bind("/tmp/socket").await?;
|
||||
/// let addr = socket.local_addr()?;
|
||||
/// assert_eq!(addr.is_unnamed(), false);
|
||||
/// ```
|
||||
///
|
||||
/// An unnamed address:
|
||||
///
|
||||
/// ```no_run
|
||||
/// use async_std::os::unix::net::UnixDatagram;
|
||||
///
|
||||
/// let socket = UnixDatagram::unbound().await?;
|
||||
/// let addr = socket.local_addr()?;
|
||||
/// assert_eq!(addr.is_unnamed(), true);
|
||||
/// ```
|
||||
pub fn is_unnamed(&self) -> bool {
|
||||
unreachable!("this impl only appears in the rendered docs")
|
||||
}
|
||||
|
||||
/// Returns the contents of this address if it is a `pathname` address.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// With a pathname:
|
||||
///
|
||||
/// ```no_run
|
||||
/// use async_std::os::unix::net::UnixListener;
|
||||
/// use async_std::path::Path;
|
||||
///
|
||||
/// let socket = UnixListener::bind("/tmp/socket").await?;
|
||||
/// let addr = socket.local_addr()?;
|
||||
/// assert_eq!(addr.as_pathname(), Some(Path::new("/tmp/socket")));
|
||||
/// ```
|
||||
///
|
||||
/// Without a pathname:
|
||||
///
|
||||
/// ```
|
||||
/// use async_std::os::unix::net::UnixDatagram;
|
||||
///
|
||||
/// let socket = UnixDatagram::unbound()?;
|
||||
/// let addr = socket.local_addr()?;
|
||||
/// assert_eq!(addr.as_pathname(), None);
|
||||
/// ```
|
||||
pub fn as_pathname(&self) -> Option<&Path> {
|
||||
unreachable!("this impl only appears in the rendered docs")
|
||||
}
|
||||
/// Returns the contents of this address if it is a `pathname` address.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// With a pathname:
|
||||
///
|
||||
/// ```no_run
|
||||
/// use async_std::os::unix::net::UnixListener;
|
||||
/// use async_std::path::Path;
|
||||
///
|
||||
/// let socket = UnixListener::bind("/tmp/socket").await?;
|
||||
/// let addr = socket.local_addr()?;
|
||||
/// assert_eq!(addr.as_pathname(), Some(Path::new("/tmp/socket")));
|
||||
/// ```
|
||||
///
|
||||
/// Without a pathname:
|
||||
///
|
||||
/// ```
|
||||
/// use async_std::os::unix::net::UnixDatagram;
|
||||
///
|
||||
/// let socket = UnixDatagram::unbound()?;
|
||||
/// let addr = socket.local_addr()?;
|
||||
/// assert_eq!(addr.as_pathname(), None);
|
||||
/// ```
|
||||
pub fn as_pathname(&self) -> Option<&Path> {
|
||||
unreachable!("this impl only appears in the rendered docs")
|
||||
}
|
||||
}
|
||||
|
||||
impl fmt::Debug for SocketAddr {
|
||||
fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
unreachable!("this impl only appears in the rendered docs")
|
||||
}
|
||||
impl fmt::Debug for SocketAddr {
|
||||
fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
unreachable!("this impl only appears in the rendered docs")
|
||||
}
|
||||
} else {
|
||||
pub use std::os::unix::net::SocketAddr;
|
||||
}
|
||||
}
|
||||
|
|
|
@ -1,50 +1,48 @@
|
|||
//! Windows-specific I/O extensions.
|
||||
|
||||
use cfg_if::cfg_if;
|
||||
cfg_not_docs! {
|
||||
pub use std::os::windows::io::{
|
||||
AsRawHandle, FromRawHandle, IntoRawHandle, RawHandle, RawSocket,
|
||||
};
|
||||
}
|
||||
|
||||
cfg_if! {
|
||||
if #[cfg(feature = "docs")] {
|
||||
/// Raw HANDLEs.
|
||||
pub type RawHandle = *mut std::os::raw::c_void;
|
||||
cfg_docs! {
|
||||
/// Raw HANDLEs.
|
||||
pub type RawHandle = *mut std::os::raw::c_void;
|
||||
|
||||
/// Raw SOCKETs.
|
||||
pub type RawSocket = u64;
|
||||
/// Raw SOCKETs.
|
||||
pub type RawSocket = u64;
|
||||
|
||||
/// Extracts raw handles.
|
||||
pub trait AsRawHandle {
|
||||
/// Extracts the raw handle, without taking any ownership.
|
||||
fn as_raw_handle(&self) -> RawHandle;
|
||||
}
|
||||
/// Extracts raw handles.
|
||||
pub trait AsRawHandle {
|
||||
/// Extracts the raw handle, without taking any ownership.
|
||||
fn as_raw_handle(&self) -> RawHandle;
|
||||
}
|
||||
|
||||
/// Construct I/O objects from raw handles.
|
||||
pub trait FromRawHandle {
|
||||
/// Constructs a new I/O object from the specified raw handle.
|
||||
///
|
||||
/// This function will **consume ownership** of the handle given,
|
||||
/// passing responsibility for closing the handle to the returned
|
||||
/// object.
|
||||
///
|
||||
/// This function is also unsafe as the primitives currently returned
|
||||
/// have the contract that they are the sole owner of the file
|
||||
/// descriptor they are wrapping. Usage of this function could
|
||||
/// accidentally allow violating this contract which can cause memory
|
||||
/// unsafety in code that relies on it being true.
|
||||
unsafe fn from_raw_handle(handle: RawHandle) -> Self;
|
||||
}
|
||||
/// Construct I/O objects from raw handles.
|
||||
pub trait FromRawHandle {
|
||||
/// Constructs a new I/O object from the specified raw handle.
|
||||
///
|
||||
/// This function will **consume ownership** of the handle given,
|
||||
/// passing responsibility for closing the handle to the returned
|
||||
/// object.
|
||||
///
|
||||
/// This function is also unsafe as the primitives currently returned
|
||||
/// have the contract that they are the sole owner of the file
|
||||
/// descriptor they are wrapping. Usage of this function could
|
||||
/// accidentally allow violating this contract which can cause memory
|
||||
/// unsafety in code that relies on it being true.
|
||||
unsafe fn from_raw_handle(handle: RawHandle) -> Self;
|
||||
}
|
||||
|
||||
/// A trait to express the ability to consume an object and acquire ownership of
|
||||
/// its raw `HANDLE`.
|
||||
pub trait IntoRawHandle {
|
||||
/// Consumes this object, returning the raw underlying handle.
|
||||
///
|
||||
/// This function **transfers ownership** of the underlying handle to the
|
||||
/// caller. Callers are then the unique owners of the handle and must close
|
||||
/// it once it's no longer needed.
|
||||
fn into_raw_handle(self) -> RawHandle;
|
||||
}
|
||||
} else {
|
||||
pub use std::os::windows::io::{
|
||||
AsRawHandle, FromRawHandle, IntoRawHandle, RawHandle, RawSocket,
|
||||
};
|
||||
/// A trait to express the ability to consume an object and acquire ownership of
|
||||
/// its raw `HANDLE`.
|
||||
pub trait IntoRawHandle {
|
||||
/// Consumes this object, returning the raw underlying handle.
|
||||
///
|
||||
/// This function **transfers ownership** of the underlying handle to the
|
||||
/// caller. Callers are then the unique owners of the handle and must close
|
||||
/// it once it's no longer needed.
|
||||
fn into_raw_handle(self) -> RawHandle;
|
||||
}
|
||||
}
|
||||
|
|
|
@ -11,8 +11,6 @@
|
|||
//! use async_std::prelude::*;
|
||||
//! ```
|
||||
|
||||
use cfg_if::cfg_if;
|
||||
|
||||
#[doc(no_inline)]
|
||||
pub use crate::future::Future;
|
||||
#[doc(no_inline)]
|
||||
|
@ -41,12 +39,9 @@ pub use crate::io::write::WriteExt as _;
|
|||
#[doc(hidden)]
|
||||
pub use crate::stream::stream::StreamExt as _;
|
||||
|
||||
cfg_if! {
|
||||
if #[cfg(any(feature = "unstable", feature = "docs"))] {
|
||||
#[doc(no_inline)]
|
||||
pub use crate::stream::DoubleEndedStream;
|
||||
|
||||
#[doc(no_inline)]
|
||||
pub use crate::stream::ExactSizeStream;
|
||||
}
|
||||
cfg_unstable! {
|
||||
#[doc(no_inline)]
|
||||
pub use crate::stream::DoubleEndedStream;
|
||||
#[doc(no_inline)]
|
||||
pub use crate::stream::ExactSizeStream;
|
||||
}
|
||||
|
|
|
@ -10,8 +10,8 @@ use std::task::{Context, Poll};
|
|||
/// `Item`s from the back, as well as the front.
|
||||
///
|
||||
/// [`Stream`]: trait.Stream.html
|
||||
#[cfg(feature = "unstable")]
|
||||
#[cfg_attr(feature = "docs", doc(cfg(unstable)))]
|
||||
#[cfg(any(feature = "unstable", feature = "docs"))]
|
||||
pub trait DoubleEndedStream: Stream {
|
||||
/// Removes and returns an element from the end of the stream.
|
||||
///
|
||||
|
|
|
@ -76,8 +76,8 @@ pub use crate::stream::Stream;
|
|||
/// # });
|
||||
/// # }
|
||||
/// ```
|
||||
#[cfg(feature = "unstable")]
|
||||
#[cfg_attr(feature = "docs", doc(cfg(unstable)))]
|
||||
#[cfg(any(feature = "unstable", feature = "docs"))]
|
||||
pub trait ExactSizeStream: Stream {
|
||||
/// Returns the exact number of times the stream will iterate.
|
||||
///
|
||||
|
|
|
@ -27,6 +27,7 @@ use crate::stream::IntoStream;
|
|||
/// #
|
||||
/// # }) }
|
||||
/// ```
|
||||
#[cfg(feature = "unstable")]
|
||||
#[cfg_attr(feature = "docs", doc(cfg(unstable)))]
|
||||
pub trait Extend<A> {
|
||||
/// Extends a collection with the contents of a stream.
|
||||
|
|
|
@ -106,8 +106,8 @@ use std::pin::Pin;
|
|||
///```
|
||||
///
|
||||
/// [`IntoStream`]: trait.IntoStream.html
|
||||
#[cfg(feature = "unstable")]
|
||||
#[cfg_attr(feature = "docs", doc(cfg(unstable)))]
|
||||
#[cfg(any(feature = "unstable", feature = "docs"))]
|
||||
pub trait FromStream<T> {
|
||||
/// Creates a value from a stream.
|
||||
///
|
||||
|
|
|
@ -14,7 +14,7 @@ use crate::stream::Stream;
|
|||
/// [`None`]: https://doc.rust-lang.org/std/option/enum.Option.html#variant.None
|
||||
/// [`Stream::fuse`]: trait.Stream.html#method.fuse
|
||||
/// [`Fuse`]: struct.Fuse.html
|
||||
#[cfg(any(feature = "unstable", feature = "docs"))]
|
||||
#[cfg(feature = "unstable")]
|
||||
#[cfg_attr(feature = "docs", doc(cfg(unstable)))]
|
||||
pub trait FusedStream: Stream {}
|
||||
|
||||
|
|
|
@ -43,9 +43,8 @@ use futures_timer::Delay;
|
|||
/// #
|
||||
/// # Ok(()) }) }
|
||||
/// ```
|
||||
#[cfg(any(feature = "unstable", feature = "docs"))]
|
||||
#[cfg(feature = "unstable")]
|
||||
#[cfg_attr(feature = "docs", doc(cfg(unstable)))]
|
||||
#[doc(inline)]
|
||||
pub fn interval(dur: Duration) -> Interval {
|
||||
Interval {
|
||||
delay: Delay::new(dur),
|
||||
|
@ -55,9 +54,9 @@ pub fn interval(dur: Duration) -> Interval {
|
|||
|
||||
/// A stream representing notifications at fixed interval
|
||||
///
|
||||
#[derive(Debug)]
|
||||
#[cfg(feature = "unstable")]
|
||||
#[cfg_attr(feature = "docs", doc(cfg(unstable)))]
|
||||
#[doc(inline)]
|
||||
#[derive(Debug)]
|
||||
pub struct Interval {
|
||||
delay: Delay,
|
||||
interval: Duration,
|
||||
|
|
|
@ -13,8 +13,8 @@ use crate::stream::Stream;
|
|||
/// See also: [`FromStream`].
|
||||
///
|
||||
/// [`FromStream`]: trait.FromStream.html
|
||||
#[cfg(feature = "unstable")]
|
||||
#[cfg_attr(feature = "docs", doc(cfg(unstable)))]
|
||||
#[cfg(any(feature = "unstable", feature = "docs"))]
|
||||
pub trait IntoStream {
|
||||
/// The type of the elements being iterated over.
|
||||
type Item;
|
||||
|
|
|
@ -21,8 +21,6 @@
|
|||
//! # })
|
||||
//! ```
|
||||
|
||||
use cfg_if::cfg_if;
|
||||
|
||||
pub use empty::{empty, Empty};
|
||||
pub use from_fn::{from_fn, FromFn};
|
||||
pub use once::{once, Once};
|
||||
|
@ -40,28 +38,25 @@ mod once;
|
|||
mod repeat;
|
||||
mod repeat_with;
|
||||
|
||||
cfg_if! {
|
||||
if #[cfg(any(feature = "unstable", feature = "docs"))] {
|
||||
mod double_ended_stream;
|
||||
mod exact_size_stream;
|
||||
mod extend;
|
||||
mod from_stream;
|
||||
mod fused_stream;
|
||||
mod interval;
|
||||
mod into_stream;
|
||||
mod product;
|
||||
mod sum;
|
||||
cfg_unstable! {
|
||||
mod double_ended_stream;
|
||||
mod exact_size_stream;
|
||||
mod extend;
|
||||
mod from_stream;
|
||||
mod fused_stream;
|
||||
mod interval;
|
||||
mod into_stream;
|
||||
mod product;
|
||||
mod sum;
|
||||
|
||||
pub use double_ended_stream::DoubleEndedStream;
|
||||
pub use exact_size_stream::ExactSizeStream;
|
||||
pub use extend::Extend;
|
||||
pub use from_stream::FromStream;
|
||||
pub use fused_stream::FusedStream;
|
||||
pub use interval::{interval, Interval};
|
||||
pub use into_stream::IntoStream;
|
||||
pub use product::Product;
|
||||
pub use sum::Sum;
|
||||
|
||||
pub use stream::Merge;
|
||||
}
|
||||
pub use double_ended_stream::DoubleEndedStream;
|
||||
pub use exact_size_stream::ExactSizeStream;
|
||||
pub use extend::Extend;
|
||||
pub use from_stream::FromStream;
|
||||
pub use fused_stream::FusedStream;
|
||||
pub use interval::{interval, Interval};
|
||||
pub use into_stream::IntoStream;
|
||||
pub use product::Product;
|
||||
pub use stream::Merge;
|
||||
pub use sum::Sum;
|
||||
}
|
||||
|
|
|
@ -11,8 +11,8 @@ use crate::stream::Stream;
|
|||
/// [`product`]: trait.Product.html#tymethod.product
|
||||
/// [`FromStream`]: trait.FromStream.html
|
||||
/// [`Stream::product`]: trait.Stream.html#method.product
|
||||
#[cfg(feature = "unstable")]
|
||||
#[cfg_attr(feature = "docs", doc(cfg(unstable)))]
|
||||
#[cfg(any(feature = "unstable", feature = "docs"))]
|
||||
pub trait Product<A = Self>: Sized {
|
||||
/// Method which takes a stream and generates `Self` from the elements by
|
||||
/// multiplying the items.
|
||||
|
|
|
@ -8,7 +8,7 @@ use futures_core::Stream;
|
|||
/// This stream is returned by [`Stream::merge`].
|
||||
///
|
||||
/// [`Stream::merge`]: trait.Stream.html#method.merge
|
||||
#[cfg(any(feature = "unstable", feature = "docs"))]
|
||||
#[cfg(feature = "unstable")]
|
||||
#[cfg_attr(feature = "docs", doc(cfg(unstable)))]
|
||||
#[derive(Debug)]
|
||||
pub struct Merge<L, R> {
|
||||
|
|
|
@ -94,32 +94,22 @@ use std::cmp::Ordering;
|
|||
use std::marker::PhantomData;
|
||||
use std::time::Duration;
|
||||
|
||||
use cfg_if::cfg_if;
|
||||
cfg_unstable! {
|
||||
use std::pin::Pin;
|
||||
|
||||
use crate::utils::extension_trait;
|
||||
use crate::future::Future;
|
||||
use crate::stream::FromStream;
|
||||
|
||||
cfg_if! {
|
||||
if #[cfg(feature = "docs")] {
|
||||
use std::ops::{Deref, DerefMut};
|
||||
pub use merge::Merge;
|
||||
|
||||
use crate::task::{Context, Poll};
|
||||
}
|
||||
}
|
||||
|
||||
cfg_if! {
|
||||
if #[cfg(any(feature = "unstable", feature = "docs"))] {
|
||||
mod merge;
|
||||
|
||||
use std::pin::Pin;
|
||||
|
||||
use crate::future::Future;
|
||||
use crate::stream::FromStream;
|
||||
|
||||
pub use merge::Merge;
|
||||
}
|
||||
mod merge;
|
||||
}
|
||||
|
||||
extension_trait! {
|
||||
use std::ops::{Deref, DerefMut};
|
||||
|
||||
use crate::task::{Context, Poll};
|
||||
|
||||
#[doc = r#"
|
||||
An asynchronous stream of values.
|
||||
|
||||
|
@ -1286,7 +1276,7 @@ extension_trait! {
|
|||
|
||||
[`stream`]: trait.Stream.html#tymethod.next
|
||||
"#]
|
||||
#[cfg(any(feature = "unstable", feature = "docs"))]
|
||||
#[cfg(feature = "unstable")]
|
||||
#[cfg_attr(feature = "docs", doc(cfg(unstable)))]
|
||||
#[must_use = "if you really need to exhaust the iterator, consider `.for_each(drop)` instead (TODO)"]
|
||||
fn collect<'a, B>(
|
||||
|
@ -1325,7 +1315,7 @@ extension_trait! {
|
|||
# });
|
||||
```
|
||||
"#]
|
||||
#[cfg(any(feature = "unstable", feature = "docs"))]
|
||||
#[cfg(feature = "unstable")]
|
||||
#[cfg_attr(feature = "docs", doc(cfg(unstable)))]
|
||||
fn merge<U>(self, other: U) -> Merge<Self, U>
|
||||
where
|
||||
|
|
|
@ -11,8 +11,8 @@ use crate::stream::Stream;
|
|||
/// [`sum`]: trait.Sum.html#tymethod.sum
|
||||
/// [`FromStream`]: trait.FromStream.html
|
||||
/// [`Stream::sum`]: trait.Stream.html#method.sum
|
||||
#[cfg(feature = "unstable")]
|
||||
#[cfg_attr(feature = "docs", doc(cfg(unstable)))]
|
||||
#[cfg(any(feature = "unstable", feature = "docs"))]
|
||||
pub trait Sum<A = Self>: Sized {
|
||||
/// Method which takes a stream and generates `Self` from the elements by
|
||||
/// "summing up" the items.
|
||||
|
|
|
@ -32,6 +32,7 @@ use crate::sync::Mutex;
|
|||
/// # });
|
||||
/// # }
|
||||
/// ```
|
||||
#[cfg(feature = "unstable")]
|
||||
#[cfg_attr(feature = "docs", doc(cfg(unstable)))]
|
||||
#[derive(Debug)]
|
||||
pub struct Barrier {
|
||||
|
@ -61,6 +62,7 @@ struct BarrierState {
|
|||
/// let barrier = Barrier::new(1);
|
||||
/// let barrier_wait_result = barrier.wait();
|
||||
/// ```
|
||||
#[cfg(feature = "unstable")]
|
||||
#[cfg_attr(feature = "docs", doc(cfg(unstable)))]
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct BarrierWaitResult(bool);
|
||||
|
|
|
@ -32,14 +32,13 @@
|
|||
#[doc(inline)]
|
||||
pub use std::sync::{Arc, Weak};
|
||||
|
||||
#[cfg(any(feature = "unstable", feature = "docs"))]
|
||||
pub use barrier::{Barrier, BarrierWaitResult};
|
||||
|
||||
pub use mutex::{Mutex, MutexGuard};
|
||||
pub use rwlock::{RwLock, RwLockReadGuard, RwLockWriteGuard};
|
||||
|
||||
#[cfg(any(feature = "unstable", feature = "docs"))]
|
||||
#[cfg_attr(feature = "docs", doc(cfg(unstable)))]
|
||||
mod barrier;
|
||||
mod mutex;
|
||||
mod rwlock;
|
||||
|
||||
cfg_unstable! {
|
||||
pub use barrier::{Barrier, BarrierWaitResult};
|
||||
mod barrier;
|
||||
}
|
||||
|
|
|
@ -1,10 +1,12 @@
|
|||
use std::cell::UnsafeCell;
|
||||
use std::cell::{Cell, UnsafeCell};
|
||||
use std::mem::{self, ManuallyDrop};
|
||||
use std::panic::{self, AssertUnwindSafe, UnwindSafe};
|
||||
use std::pin::Pin;
|
||||
use std::sync::Arc;
|
||||
use std::task::{RawWaker, RawWakerVTable};
|
||||
use std::thread::{self, Thread};
|
||||
use std::thread;
|
||||
|
||||
use crossbeam_utils::sync::Parker;
|
||||
|
||||
use super::task;
|
||||
use super::task_local;
|
||||
|
@ -119,13 +121,21 @@ where
|
|||
F: Future<Output = T>,
|
||||
{
|
||||
thread_local! {
|
||||
static ARC_THREAD: Arc<Thread> = Arc::new(thread::current());
|
||||
// May hold a pre-allocated parker that can be reused for efficiency.
|
||||
//
|
||||
// Note that each invocation of `block` needs its own parker. In particular, if `block`
|
||||
// recursively calls itself, we must make sure that each recursive call uses a distinct
|
||||
// parker instance.
|
||||
static CACHE: Cell<Option<Arc<Parker>>> = Cell::new(None);
|
||||
}
|
||||
|
||||
pin_utils::pin_mut!(f);
|
||||
|
||||
ARC_THREAD.with(|arc_thread: &Arc<Thread>| {
|
||||
let ptr = (&**arc_thread as *const Thread) as *const ();
|
||||
CACHE.with(|cache| {
|
||||
// Reuse a cached parker or create a new one for this invocation of `block`.
|
||||
let arc_parker: Arc<Parker> = cache.take().unwrap_or_else(|| Arc::new(Parker::new()));
|
||||
|
||||
let ptr = (&*arc_parker as *const Parker) as *const ();
|
||||
let vt = vtable();
|
||||
|
||||
let waker = unsafe { ManuallyDrop::new(Waker::from_raw(RawWaker::new(ptr, vt))) };
|
||||
|
@ -133,32 +143,34 @@ where
|
|||
|
||||
loop {
|
||||
if let Poll::Ready(t) = f.as_mut().poll(cx) {
|
||||
// Save the parker for the next invocation of `block`.
|
||||
cache.set(Some(arc_parker));
|
||||
return t;
|
||||
}
|
||||
thread::park();
|
||||
arc_parker.park();
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
fn vtable() -> &'static RawWakerVTable {
|
||||
unsafe fn clone_raw(ptr: *const ()) -> RawWaker {
|
||||
let arc = ManuallyDrop::new(Arc::from_raw(ptr as *const Thread));
|
||||
let arc = ManuallyDrop::new(Arc::from_raw(ptr as *const Parker));
|
||||
mem::forget(arc.clone());
|
||||
RawWaker::new(ptr, vtable())
|
||||
}
|
||||
|
||||
unsafe fn wake_raw(ptr: *const ()) {
|
||||
let arc = Arc::from_raw(ptr as *const Thread);
|
||||
arc.unpark();
|
||||
let arc = Arc::from_raw(ptr as *const Parker);
|
||||
arc.unparker().unpark();
|
||||
}
|
||||
|
||||
unsafe fn wake_by_ref_raw(ptr: *const ()) {
|
||||
let arc = ManuallyDrop::new(Arc::from_raw(ptr as *const Thread));
|
||||
arc.unpark();
|
||||
let arc = ManuallyDrop::new(Arc::from_raw(ptr as *const Parker));
|
||||
arc.unparker().unpark();
|
||||
}
|
||||
|
||||
unsafe fn drop_raw(ptr: *const ()) {
|
||||
drop(Arc::from_raw(ptr as *const Thread))
|
||||
drop(Arc::from_raw(ptr as *const Parker))
|
||||
}
|
||||
|
||||
&RawWakerVTable::new(clone_raw, wake_raw, wake_by_ref_raw, drop_raw)
|
||||
|
|
|
@ -143,11 +143,9 @@ mod worker;
|
|||
|
||||
pub(crate) mod blocking;
|
||||
|
||||
cfg_if::cfg_if! {
|
||||
if #[cfg(any(feature = "unstable", feature = "docs"))] {
|
||||
mod yield_now;
|
||||
pub use yield_now::yield_now;
|
||||
}
|
||||
cfg_unstable! {
|
||||
mod yield_now;
|
||||
pub use yield_now::yield_now;
|
||||
}
|
||||
|
||||
/// Spawns a blocking task.
|
||||
|
@ -178,7 +176,7 @@ cfg_if::cfg_if! {
|
|||
/// ```
|
||||
// Once this function stabilizes we should merge `blocking::spawn` into this so
|
||||
// all code in our crate uses `task::blocking` too.
|
||||
#[cfg(any(feature = "unstable", feature = "docs"))]
|
||||
#[cfg(feature = "unstable")]
|
||||
#[cfg_attr(feature = "docs", doc(cfg(unstable)))]
|
||||
#[inline]
|
||||
pub fn spawn_blocking<F, R>(f: F) -> task::JoinHandle<R>
|
||||
|
|
|
@ -26,7 +26,7 @@ use std::pin::Pin;
|
|||
/// #
|
||||
/// # }) }
|
||||
/// ```
|
||||
#[cfg(any(feature = "unstable", feature = "docs"))]
|
||||
#[cfg(feature = "unstable")]
|
||||
#[cfg_attr(feature = "docs", doc(cfg(unstable)))]
|
||||
#[inline]
|
||||
pub async fn yield_now() {
|
||||
|
|
69
src/utils.rs
69
src/utils.rs
|
@ -20,6 +20,64 @@ pub fn abort_on_panic<T>(f: impl FnOnce() -> T) -> T {
|
|||
t
|
||||
}
|
||||
|
||||
/// Declares unstable items.
|
||||
#[doc(hidden)]
|
||||
macro_rules! cfg_unstable {
|
||||
($($item:item)*) => {
|
||||
$(
|
||||
#[cfg(feature = "unstable")]
|
||||
#[cfg_attr(feature = "docs", doc(cfg(unstable)))]
|
||||
$item
|
||||
)*
|
||||
}
|
||||
}
|
||||
|
||||
/// Declares Unix-specific items.
|
||||
#[doc(hidden)]
|
||||
macro_rules! cfg_unix {
|
||||
($($item:item)*) => {
|
||||
$(
|
||||
#[cfg(any(unix, feature = "docs"))]
|
||||
#[cfg_attr(feature = "docs", doc(cfg(unix)))]
|
||||
$item
|
||||
)*
|
||||
}
|
||||
}
|
||||
|
||||
/// Declares Windows-specific items.
|
||||
#[doc(hidden)]
|
||||
macro_rules! cfg_windows {
|
||||
($($item:item)*) => {
|
||||
$(
|
||||
#[cfg(any(windows, feature = "docs"))]
|
||||
#[cfg_attr(feature = "docs", doc(cfg(windows)))]
|
||||
$item
|
||||
)*
|
||||
}
|
||||
}
|
||||
|
||||
/// Declares items when the "docs" feature is enabled.
|
||||
#[doc(hidden)]
|
||||
macro_rules! cfg_docs {
|
||||
($($item:item)*) => {
|
||||
$(
|
||||
#[cfg(feature = "docs")]
|
||||
$item
|
||||
)*
|
||||
}
|
||||
}
|
||||
|
||||
/// Declares items when the "docs" feature is disabled.
|
||||
#[doc(hidden)]
|
||||
macro_rules! cfg_not_docs {
|
||||
($($item:item)*) => {
|
||||
$(
|
||||
#[cfg(not(feature = "docs"))]
|
||||
$item
|
||||
)*
|
||||
}
|
||||
}
|
||||
|
||||
/// Defines an extension trait for a base trait.
|
||||
///
|
||||
/// In generated docs, the base trait will contain methods from the extension trait. In actual
|
||||
|
@ -29,7 +87,6 @@ pub fn abort_on_panic<T>(f: impl FnOnce() -> T) -> T {
|
|||
/// Inside invocations of this macro, we write a definitions that looks similar to the final
|
||||
/// rendered docs, and the macro then generates all the boilerplate for us.
|
||||
#[doc(hidden)]
|
||||
#[macro_export]
|
||||
macro_rules! extension_trait {
|
||||
(
|
||||
// Interesting patterns:
|
||||
|
@ -113,6 +170,12 @@ macro_rules! extension_trait {
|
|||
// Handle the end of the token list.
|
||||
(@doc ($($head:tt)*)) => { $($head)* };
|
||||
(@ext ($($head:tt)*)) => { $($head)* };
|
||||
}
|
||||
|
||||
pub use crate::extension_trait;
|
||||
// Parse imports at the beginning of the macro.
|
||||
($import:item $($tail:tt)*) => {
|
||||
#[cfg(feature = "docs")]
|
||||
$import
|
||||
|
||||
extension_trait!($($tail)*);
|
||||
};
|
||||
}
|
||||
|
|
|
@ -48,13 +48,13 @@ fn test_buffered_writer() {
|
|||
}
|
||||
|
||||
#[test]
|
||||
fn test_buffered_writer_inner_into_inner_does_not_flush() {
|
||||
fn test_buffered_writer_inner_into_inner_flushes() {
|
||||
task::block_on(async {
|
||||
let mut w = BufWriter::with_capacity(3, Vec::new());
|
||||
w.write(&[0, 1]).await.unwrap();
|
||||
assert_eq!(*w.get_ref(), []);
|
||||
let w = w.into_inner().await.unwrap();
|
||||
assert_eq!(w, []);
|
||||
assert_eq!(w, [0, 1]);
|
||||
})
|
||||
}
|
||||
|
||||
|
|
Loading…
Reference in a new issue