对T的要求是T: Sized + Copy。

如果您想在使用futures_ringbuf之前对缓冲区进行初始化，可以使用ringbuf的Producer和Consumer类型。 futures_ringbuf::RingBuffer实现了From< (Producer<T>, Consumer<T>) >。

WASM

此crate在WASM上运行。请参阅集成测试中的代码。

基本示例

//! Frame a RingBuf with futures_codec. This example shows how the sending task will
//! block when the buffer is full. When a reader consumes the buffer, the sender is woken up.
//!
//! Run with `cargo run --example basic`.
//
use
{
   futures_ringbuf    :: { *                                            } ,
   futures            :: { SinkExt, StreamExt, executor::block_on, join } ,
   asynchronous_codec :: { Framed, LinesCodec                           } ,
};


#[ async_std::main ]
//
async fn main()
{
   let mock = RingBuffer::new( 13 );
   let (mut writer, mut reader) = Framed::new( mock, LinesCodec{} ).split();


   let send_task = async move
   {
      writer.send( "Hello World\n".to_string() ).await.expect( "send" );
      println!( "sent first line" );

      writer.send( "Second line\n".to_string() ).await.expect( "send" );
      println!( "sent second line" );

      writer.close().await.expect( "close sender" );
      println!( "sink closed" );
   };


   let receive_task = async move
   {
      // If we would return here, the second line will never get sent
      // because the buffer is full.
      //
      // return;

      while let Some(msg) = reader.next().await.transpose().expect( "receive message" )
      {
         println!( "Received: {:#?}", msg );
      }
   };


   // Poll them in concurrently
   //
   join!( send_task, receive_task );
}

端点

当使用一个环形缓冲区时，我们获得一个连接的两端。如果我们想要一个更真实的全双工连接，我们需要两个环形缓冲区，一个端点从环形缓冲区读取，另一个端点写入。当有新数据或空间可用时，任务需要正确唤醒……为此，提供了一个Endpoint类型，它会为您处理这个设置。

端点示例

use
{
   futures_ringbuf :: { *                                               } ,
   futures         :: { AsyncWriteExt, AsyncReadExt, executor::block_on } ,
};


#[ async_std::main ]
//
async fn main()
{
   // Buffer of 10 bytes in each direction. The buffer size always refers to the writing side, so here
   // the first 10 means the server can write 10 bytes before it's buffer is full.
   // When it's full it will return pending on writing and when it's empty it returns
   // pending on reading.
   //
   let (mut server, mut client) = Endpoint::pair( 10, 10 );

   let     data = vec![ 1,2,3 ];
   let mut read = [0u8;3];

   server.write( &data ).await.expect( "write" );

   let n = client.read( &mut read ).await.expect( "read" );

   assert_eq!( n   , 3                 );
   assert_eq!( read, vec![ 1,2,3 ][..] );
}

API

API文档可以在docs.rs上找到。

贡献

请查看贡献指南。

测试

cargotest

在WASM上，安装wasm-pack之后

wasm-pack test--firefox--无头

或

wasm-pack test--chrome--无头

行为准则

任何在公民行为准则的第4点“不可接受的行为”中描述的行为都不受欢迎，可能会让您被禁言。如果包括维护者和项目管理员在内的任何人都未能尊重这些/您的限制，您有权指出。

许可