forked from mirror/async-std
120 lines
3.2 KiB
Rust
120 lines
3.2 KiB
Rust
mod seek;
|
|
|
|
use seek::SeekFuture;
|
|
|
|
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.
|
|
|
|
This trait is a re-export of [`futures::io::AsyncSeek`] and is an async version of
|
|
[`std::io::Seek`].
|
|
|
|
The [provided methods] do not really exist in the trait itself, but they become
|
|
available when [`SeekExt`] the [prelude] is imported:
|
|
|
|
```
|
|
# #[allow(unused_imports)]
|
|
use async_std::prelude::*;
|
|
```
|
|
|
|
[`std::io::Seek`]: https://doc.rust-lang.org/std/io/trait.Seek.html
|
|
[`futures::io::AsyncSeek`]:
|
|
https://docs.rs/futures-preview/0.3.0-alpha.17/futures/io/trait.AsyncSeek.html
|
|
[provided methods]: #provided-methods
|
|
[`SeekExt`]: ../io/prelude/trait.SeekExt.html
|
|
[prelude]: ../prelude/index.html
|
|
"#]
|
|
pub trait Seek {
|
|
#[doc = r#"
|
|
Attempt to seek to an offset, in bytes, in a stream.
|
|
"#]
|
|
fn poll_seek(
|
|
self: Pin<&mut Self>,
|
|
cx: &mut Context<'_>,
|
|
pos: SeekFrom,
|
|
) -> Poll<io::Result<u64>>;
|
|
}
|
|
|
|
#[doc = r#"
|
|
Extension methods for [`Seek`].
|
|
|
|
[`Seek`]: ../trait.Seek.html
|
|
"#]
|
|
pub trait SeekExt: futures_io::AsyncSeek {
|
|
#[doc = r#"
|
|
Seeks to a new position in a byte stream.
|
|
|
|
Returns the new position in the byte stream.
|
|
|
|
A seek beyond the end of stream is allowed, but behavior is defined by the
|
|
implementation.
|
|
|
|
# Examples
|
|
|
|
```no_run
|
|
# fn main() -> std::io::Result<()> { async_std::task::block_on(async {
|
|
#
|
|
use async_std::fs::File;
|
|
use async_std::io::SeekFrom;
|
|
use async_std::prelude::*;
|
|
|
|
let mut file = File::open("a.txt").await?;
|
|
|
|
let file_len = file.seek(SeekFrom::End(0)).await?;
|
|
#
|
|
# Ok(()) }) }
|
|
```
|
|
"#]
|
|
fn seek(
|
|
&mut self,
|
|
pos: SeekFrom,
|
|
) -> impl Future<Output = io::Result<u64>> + '_ [SeekFuture<'_, Self>]
|
|
where
|
|
Self: Unpin,
|
|
{
|
|
SeekFuture { seeker: self, pos }
|
|
}
|
|
}
|
|
|
|
impl<T: Seek + Unpin + ?Sized> Seek for Box<T> {
|
|
fn poll_seek(
|
|
self: Pin<&mut Self>,
|
|
cx: &mut Context<'_>,
|
|
pos: SeekFrom,
|
|
) -> Poll<io::Result<u64>> {
|
|
unreachable!("this impl only appears in the rendered docs")
|
|
}
|
|
}
|
|
|
|
impl<T: Seek + Unpin + ?Sized> Seek for &mut T {
|
|
fn poll_seek(
|
|
self: Pin<&mut Self>,
|
|
cx: &mut Context<'_>,
|
|
pos: SeekFrom,
|
|
) -> Poll<io::Result<u64>> {
|
|
unreachable!("this impl only appears in the rendered docs")
|
|
}
|
|
}
|
|
|
|
impl<P> Seek for Pin<P>
|
|
where
|
|
P: DerefMut + Unpin,
|
|
<P as Deref>::Target: Seek,
|
|
{
|
|
fn poll_seek(
|
|
self: Pin<&mut Self>,
|
|
cx: &mut Context<'_>,
|
|
pos: SeekFrom,
|
|
) -> Poll<io::Result<u64>> {
|
|
unreachable!("this impl only appears in the rendered docs")
|
|
}
|
|
}
|
|
}
|