Dataset Viewer
Auto-converted to Parquet Duplicate
repo
stringclasses
7 values
lang
stringclasses
2 values
aspect
stringclasses
7 values
file
stringlengths
5
48
content
stringlengths
283
144k
tokio
rust
async_runtime
stream_fused.rs
use futures_core::FusedStream; use tokio_stream::{Stream, StreamExt, StreamNotifyClose}; use std::pin::Pin; use std::task::{Context, Poll}; struct EndOnce { ended: bool, } impl Stream for EndOnce { type Item = (); fn poll_next(mut self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Option<Self::Item>> ...
tokio
rust
async_runtime
stream_peekable.rs
use tokio_stream::{self as stream, Stream, StreamExt}; use tokio_test::{assert_pending, assert_ready, task}; use std::pin::Pin; use std::task::{Context, Poll}; #[tokio::test] async fn size_hint_without_peek() { let mut s = stream::iter(vec![1, 2, 3]).peekable(); assert_eq!(s.size_hint(), (3, Some(3))); s....
tokio
rust
async_runtime
stream_chain.rs
use tokio_stream::{self as stream, Stream, StreamExt}; use tokio_test::{assert_pending, assert_ready, task}; mod support { pub(crate) mod mpsc; } use support::mpsc; use tokio_stream::adapters::Chain; #[tokio::test] async fn basic_usage() { let one = stream::iter(vec![1, 2, 3]); let two = stream::iter(vec...
tokio
rust
async_runtime
join_set_stream.rs
#![cfg(feature = "rt")] use futures::{Stream, StreamExt}; use std::collections::HashSet; use tokio::task::JoinSet; use tokio_stream::wrappers::JoinSetStream; #[tokio::test] async fn size_hint_stream() { let set: JoinSet<_> = (0..2).map(|i| async move { i }).collect(); let mut stream = JoinSetStream::new(set);...
tokio
rust
async_runtime
stream_panic.rs
#![warn(rust_2018_idioms)] #![cfg(all(feature = "time", not(target_os = "wasi")))] // Wasi does not support panic recovery #![cfg(panic = "unwind")] use parking_lot::Mutex; use std::error::Error; use std::panic; use std::sync::Arc; use tokio::time::Duration; use tokio_stream::{self as stream, StreamExt}; fn test_pani...
tokio
rust
async_runtime
stream_chunks_timeout.rs
#![warn(rust_2018_idioms)] use futures::FutureExt; use std::error::Error; use tokio::time; use tokio::time::Duration; use tokio_stream::{self as stream, StreamExt}; use tokio_test::assert_pending; use tokio_test::task; #[tokio::test(start_paused = true)] async fn stream_chunks_remainder() -> Result<(), Box<dyn Error>...
tokio
rust
async_runtime
stream_merge.rs
use tokio_stream::{self as stream, Stream, StreamExt}; use tokio_test::task; use tokio_test::{assert_pending, assert_ready}; mod support { pub(crate) mod mpsc; } use support::mpsc; #[tokio::test] async fn merge_sync_streams() { let mut s = stream::iter(vec![0, 2, 4, 6]).merge(stream::iter(vec![1, 3, 5])); ...
tokio
rust
async_runtime
stream_accessors.rs
use std::pin::Pin; use tokio_stream::{self as stream, Iter, StreamExt}; fn base() -> Iter<std::vec::IntoIter<i32>> { stream::iter(vec![1, 2, 3]) } #[tokio::test] async fn map_accessors() { let mut map = base().map(|x| x * 2); let _: &Iter<_> = map.get_ref(); let _: &mut Iter<_> = map.get_mut(); ...
tokio
rust
async_runtime
stream_fuse.rs
use futures_core::FusedStream; use tokio_stream::{Stream, StreamExt}; use std::pin::Pin; use std::task::{Context, Poll}; // a stream which alternates between Some and None struct Alternate { state: i32, } impl Stream for Alternate { type Item = i32; fn poll_next(mut self: Pin<&mut Self>, _cx: &mut Conte...
tokio
rust
async_runtime
stream_timeout.rs
#![cfg(all(feature = "time", feature = "sync", feature = "io-util"))] use tokio::time::{self, sleep, Duration}; use tokio_stream::StreamExt; use tokio_test::*; use futures::stream; async fn maybe_sleep(idx: i32) -> i32 { if idx % 2 == 0 { sleep(ms(200)).await; } idx } fn ms(n: u64) -> Duration {...
tokio
rust
async_runtime
chunks_timeout.rs
#![warn(rust_2018_idioms)] #![cfg(all(feature = "time", feature = "sync", feature = "io-util"))] use tokio::time; use tokio_stream::{self as stream, StreamExt}; use tokio_test::assert_pending; use tokio_test::task; use futures::FutureExt; use std::time::Duration; #[tokio::test(start_paused = true)] async fn usage() ...
tokio
rust
async_runtime
mpsc_unbounded_stream.rs
use futures::{Stream, StreamExt}; use futures_core::FusedStream; use tokio::sync::mpsc; use tokio_stream::wrappers::UnboundedReceiverStream; #[tokio::test] async fn size_hint_stream_open() { let (tx, rx) = mpsc::unbounded_channel(); tx.send(1).unwrap(); tx.send(2).unwrap(); let mut stream = Unbounded...
tokio
rust
async_runtime
stream_stream_map.rs
use futures::stream::iter; use tokio_stream::{self as stream, pending, Stream, StreamExt, StreamMap}; use tokio_test::{assert_ok, assert_pending, assert_ready, task}; use std::future::{poll_fn, Future}; use std::pin::{pin, Pin}; use std::task::Poll; mod support { pub(crate) mod mpsc; } use support::mpsc; macro_...
tokio
rust
async_runtime
stream_iter.rs
use std::iter; use tokio_stream::{self as stream, Stream}; use tokio_test::{assert_pending, assert_ready, task}; #[tokio::test] async fn coop() { let mut stream = task::spawn(stream::iter(iter::repeat(1))); for _ in 0..10_000 { if stream.poll_next().is_pending() { tokio::task::yield_now()....
tokio
rust
async_runtime
watch.rs
#![cfg(feature = "sync")] use tokio::sync::watch; use tokio_stream::wrappers::WatchStream; use tokio_stream::StreamExt; use tokio_test::assert_pending; use tokio_test::task::spawn; #[tokio::test] async fn watch_stream_message_not_twice() { let (tx, rx) = watch::channel("hello"); let mut counter = 0; let ...
tokio
rust
async_runtime
async_send_sync.rs
#![allow(clippy::diverging_sub_expression)] use std::rc::Rc; #[allow(dead_code)] type BoxStream<T> = std::pin::Pin<Box<dyn tokio_stream::Stream<Item = T>>>; #[allow(dead_code)] fn require_send<T: Send>(_t: &T) {} #[allow(dead_code)] fn require_sync<T: Sync>(_t: &T) {} #[allow(dead_code)] fn require_unpin<T: Unpin>(_...
tokio
rust
async_runtime
time_throttle.rs
#![warn(rust_2018_idioms)] #![cfg(all(feature = "time", feature = "sync", feature = "io-util"))] use futures_core::FusedStream; use tokio::time; use tokio_stream::{Stream, StreamExt}; use tokio_test::*; use std::time::Duration; #[test] fn throttle_can_be_created_outside_runtime() { let _stream = futures::stream:...
tokio
rust
async_runtime
stream_map_while.rs
use tokio_stream::StreamExt; #[tokio::test] async fn map_while_yields_until_closure_returns_none() { let mut stream = tokio_stream::iter(1..=10).map_while(|x| if x < 4 { Some(x + 3) } else { None }); assert_eq!(stream.next().await, Some(4)); assert_eq!(stream.next().await, Some(5)); assert_eq!(...
tokio
rust
async_runtime
mpsc_bounded_stream.rs
use futures::{task::noop_waker_ref, Stream, StreamExt}; use futures_core::FusedStream; use std::pin::Pin; use std::task::{Context, Poll}; use tokio::sync::mpsc; use tokio_stream::wrappers::ReceiverStream; #[tokio::test] async fn size_hint_stream_open() { let (tx, rx) = mpsc::channel(4); tx.send(1).await.unwra...
tokio
rust
async_runtime
stream_collect.rs
use std::collections::{BTreeMap, BTreeSet, BinaryHeap, HashMap, HashSet, LinkedList, VecDeque}; use tokio_stream::{self as stream, StreamExt}; use tokio_test::{assert_pending, assert_ready, assert_ready_err, assert_ready_ok, task}; mod support { pub(crate) mod mpsc; } use support::mpsc; #[allow(clippy::let_unit...
tokio
rust
async_runtime
mpsc.rs
use async_stream::stream; use tokio::sync::mpsc::{self, UnboundedSender}; use tokio_stream::Stream; pub fn unbounded_channel_stream<T: Unpin>() -> (UnboundedSender<T>, impl Stream<Item = T>) { let (tx, mut rx) = mpsc::unbounded_channel(); let stream = stream! { while let Some(item) = rx.recv().await {...
tokio
rust
async_runtime
fuzz_stream_map.rs
#![no_main] use libfuzzer_sys::fuzz_target; use std::pin::Pin; use tokio_stream::{self as stream, Stream, StreamMap}; use tokio_test::{assert_pending, assert_ready, task}; macro_rules! assert_ready_none { ($($t:tt)*) => { match assert_ready!($($t)*) { None => {} Some(v) => panic!(...
tokio
rust
async_runtime
pending.rs
use crate::Stream; use core::marker::PhantomData; use core::pin::Pin; use core::task::{Context, Poll}; /// Stream for the [`pending`](fn@pending) function. #[derive(Debug)] #[must_use = "streams do nothing unless polled"] pub struct Pending<T>(PhantomData<T>); impl<T> Unpin for Pending<T> {} unsafe impl<T> Send for ...
tokio
rust
async_runtime
empty.rs
use crate::Stream; use futures_core::FusedStream; use core::marker::PhantomData; use core::pin::Pin; use core::task::{Context, Poll}; /// Stream for the [`empty`](fn@empty) function. #[derive(Debug)] #[must_use = "streams do nothing unless polled"] pub struct Empty<T>(PhantomData<T>); impl<T> Unpin for Empty<T> {} u...
tokio
rust
async_runtime
lib.rs
#![allow( clippy::cognitive_complexity, clippy::large_enum_variant, clippy::needless_doctest_main )] #![warn( missing_debug_implementations, missing_docs, rust_2018_idioms, unreachable_pub )] #![cfg_attr(docsrs, feature(doc_cfg))] #![doc(test( no_crate_inject, attr(deny(warnings, rus...
tokio
rust
async_runtime
iter.rs
use crate::Stream; use core::pin::Pin; use core::task::{Context, Poll}; /// Stream for the [`iter`](fn@iter) function. #[derive(Debug)] #[must_use = "streams do nothing unless polled"] pub struct Iter<I> { iter: I, #[cfg(not(feature = "rt"))] yield_amt: usize, } impl<I> Unpin for Iter<I> {} /// Converts...
tokio
rust
async_runtime
stream_close.rs
use crate::Stream; use futures_core::FusedStream; use pin_project_lite::pin_project; use std::pin::Pin; use std::task::{Context, Poll}; pin_project! { /// A `Stream` that wraps the values in an `Option`. /// /// Whenever the wrapped stream yields an item, this stream yields that item /// wrapped in `So...
tokio
rust
async_runtime
stream_ext.rs
use core::future::Future; use futures_core::Stream; mod all; use all::AllFuture; mod any; use any::AnyFuture; mod chain; pub use chain::Chain; pub(crate) mod collect; use collect::{Collect, FromStream}; mod filter; pub use filter::Filter; mod filter_map; pub use filter_map::FilterMap; mod fold; use fold::FoldFut...
tokio
rust
async_runtime
macros.rs
macro_rules! cfg_fs { ($($item:item)*) => { $( #[cfg(feature = "fs")] #[cfg_attr(docsrs, doc(cfg(feature = "fs")))] $item )* } } macro_rules! cfg_io_util { ($($item:item)*) => { $( #[cfg(feature = "io-util")] #[cfg_attr(doc...
tokio
rust
async_runtime
once.rs
use crate::Stream; use futures_core::FusedStream; use core::pin::Pin; use core::task::{Context, Poll}; /// Stream for the [`once`](fn@once) function. #[derive(Debug)] #[must_use = "streams do nothing unless polled"] pub struct Once<T> { value: Option<T>, } impl<I> Unpin for Once<I> {} /// Creates a stream that ...
tokio
rust
async_runtime
wrappers.rs
/// Error types for the wrappers. pub mod errors { cfg_sync! { pub use crate::wrappers::broadcast::BroadcastStreamRecvError; } } mod mpsc_bounded; pub use mpsc_bounded::ReceiverStream; mod mpsc_unbounded; pub use mpsc_unbounded::UnboundedReceiverStream; cfg_rt! { mod task; pub use task::JoinS...
tokio
rust
async_runtime
stream_map.rs
use crate::Stream; use std::borrow::Borrow; use std::future::poll_fn; use std::hash::Hash; use std::pin::Pin; use std::task::{ready, Context, Poll}; /// Combine many streams into one, indexing each source stream with a unique /// key. /// /// `StreamMap` is similar to [`StreamExt::merge`] in that it combines source /...
tokio
rust
async_runtime
mpsc_bounded.rs
use crate::Stream; use futures_core::FusedStream; use std::pin::Pin; use std::task::{Context, Poll}; use tokio::sync::mpsc::Receiver; /// A wrapper around [`tokio::sync::mpsc::Receiver`] that implements [`Stream`]. /// /// # Example /// /// ``` /// use tokio::sync::mpsc; /// use tokio_stream::wrappers::ReceiverStream;...
tokio
rust
async_runtime
signal_windows.rs
use crate::Stream; use std::pin::Pin; use std::task::{Context, Poll}; use tokio::signal::windows::{CtrlBreak, CtrlC}; /// A wrapper around [`CtrlC`] that implements [`Stream`]. /// /// [`CtrlC`]: struct@tokio::signal::windows::CtrlC /// [`Stream`]: trait@crate::Stream /// /// # Example /// /// ```no_run /// use tokio:...
tokio
rust
async_runtime
mpsc_unbounded.rs
use crate::Stream; use futures_core::FusedStream; use std::pin::Pin; use std::task::{Context, Poll}; use tokio::sync::mpsc::UnboundedReceiver; /// A wrapper around [`tokio::sync::mpsc::UnboundedReceiver`] that implements [`Stream`]. /// /// # Example /// /// ``` /// use tokio::sync::mpsc; /// use tokio_stream::wrapper...
tokio
rust
async_runtime
interval.rs
use crate::Stream; use futures_core::stream::FusedStream; use std::pin::Pin; use std::task::{Context, Poll}; use tokio::time::{Instant, Interval}; /// A wrapper around [`Interval`] that implements [`Stream`]. /// /// # Example /// /// ``` /// use tokio::time::{Duration, Instant, interval}; /// use tokio_stream::wrappe...
tokio
rust
async_runtime
tcp_listener.rs
use crate::Stream; use std::io; use std::pin::Pin; use std::task::{Context, Poll}; use tokio::net::{TcpListener, TcpStream}; /// A wrapper around [`TcpListener`] that implements [`Stream`]. /// /// # Example /// /// Accept connections from both IPv4 and IPv6 listeners in the same loop: /// /// ```no_run /// # #[cfg(no...
tokio
rust
async_runtime
task.rs
use crate::Stream; use futures_core::FusedStream; use std::pin::Pin; use std::task::{Context, Poll}; use tokio::task::{JoinError, JoinSet}; /// A wrapper around [`tokio::task::JoinSet`] that implements [`Stream`]. /// /// # Example /// /// ``` /// use tokio::task::JoinSet; /// use tokio_stream::wrappers::JoinSetStream...
tokio
rust
async_runtime
unix_listener.rs
use crate::Stream; use std::io; use std::pin::Pin; use std::task::{Context, Poll}; use tokio::net::{UnixListener, UnixStream}; /// A wrapper around [`UnixListener`] that implements [`Stream`]. /// /// # Example /// /// ```no_run /// use tokio::net::UnixListener; /// use tokio_stream::{StreamExt, wrappers::UnixListener...
End of preview. Expand in Data Studio

No dataset card yet

Downloads last month
38