QAPI

https://docs.rs/qapi/latest/qapi/
Admin
QAPI is a Rust library that provides bindings and utilities for working with QEMU's QMP (QEMU...
Tokens:21,149
Snippets:216
Trust Score:9.7
Update:1 year ago
Show doc for...
Tokens:
Raw
### Rust Sink: Start Send (Unpin)

Source: https://docs.rs/qapi/latest/qapi/futures/struct

A convenience method for calling `Sink::start_send` on `Unpin` sink types. Requires the sink to be Unpin.

```Rust
fn start_send_unpin(&mut self, item: Item) -> Result<(), Self::Error>
where Self: Unpin,
```

--------------------------------

### Start Sending Item to QmpStreamTokio Sink in Rust

Source: https://docs.rs/qapi/latest/qapi/futures/struct

Initiates the process of sending an 'Execute' item to the QmpStreamTokio sink. This method must be called after 'poll_ready' returns 'Poll::Ready'.

```Rust
fn start_send( self: Pin<&mut Self>, item: Execute<C, I>, ) -> Result<(), Self::Error>
```

--------------------------------

### Rust Stream: Get Next Item

Source: https://docs.rs/qapi/latest/qapi/futures/struct

Creates a future that resolves to the next item in the stream. Requires the stream to be Unpin.

```Rust
fn next(&mut self) -> Next<'_, Self>
where Self: Unpin,
```

--------------------------------

### Get Size Hint for QmpStreamTokio Stream in Rust

Source: https://docs.rs/qapi/latest/qapi/futures/struct

Returns the bounds on the remaining length of the QmpStreamTokio stream, providing an estimate of the number of items left.

```Rust
fn size_hint(&self) -> (usize, Option<usize>)
```

--------------------------------

### Get Type ID of Any Type T in Rust

Source: https://docs.rs/qapi/latest/qapi/futures/struct

Provides a method to get the 'TypeId' of a type implementing the 'Any' trait, used for runtime type checking.

```Rust
fn type_id(&self) -> TypeId
```

--------------------------------

### Rust: Try Chunk Ready Stream Items

Source: https://docs.rs/qapi/latest/qapi/futures/struct

An adaptor for chunking up successful, ready items of the stream into vectors of a specified capacity. This specifically handles items that are immediately available.

```Rust
fn try_ready_chunks(self, capacity: usize) -> TryReadyChunks<Self>
where Self: Sized
```

--------------------------------

### Chunk ready items in a Rust stream

Source: https://docs.rs/qapi/latest/qapi/futures/struct

An adapter for chunking items that are immediately ready from a stream into vectors. This is efficient for streams that might yield items asynchronously.

```Rust
fn ready_chunks(self, capacity: usize) -> ReadyChunks<Self>
where Self: Sized
```

--------------------------------

### Rust: Try Chunk Stream Items

Source: https://docs.rs/qapi/latest/qapi/futures/struct

An adaptor for chunking up successful items of the stream into vectors of a specified capacity. Errors are propagated.

```Rust
fn try_chunks(self, capacity: usize) -> TryChunks<Self>
where Self: Sized
```

--------------------------------

### Rust: Box and pin a stream for dynamic dispatch

Source: https://docs.rs/qapi/latest/qapi/futures/struct

The `boxed` method wraps a stream in a `Pin<Box<dyn Stream>>`, enabling dynamic dispatch and allowing streams with different concrete types but the same item type to be used interchangeably. It requires the stream to be `Send` and `'a` bound.

```Rust
fn boxed<'a>(self) -> Pin<Box<dyn Stream<Item = Self::Item> + Send + 'a>>
where Self: Sized + Send + 'a,
```

--------------------------------

### Rust: Box and pin a stream locally

Source: https://docs.rs/qapi/latest/qapi/futures/struct

The `boxed_local` method is similar to `boxed` but does not require the stream to be `Send`. It wraps the stream in a `Pin<Box<dyn Stream>>` for local, non-`Send` streams.

```Rust
fn boxed_local<'a>(self) -> Pin<Box<dyn Stream<Item = Self::Item> + 'a>>
where Self: Sized + 'a,
```

--------------------------------

### Re-export qga from qapi

Source: https://docs.rs/qapi/latest/qapi/index

This snippet demonstrates the re-export of the 'qga' module from the 'qapi_qga' crate within the qapi crate. This provides convenient access to qga functionalities.

```Rust
pub use qapi_qga as qga;
```

--------------------------------

### Create New QmpStreamTokio Instance in Rust

Source: https://docs.rs/qapi/latest/qapi/futures/struct

Provides a constructor function 'new' to create a new instance of QmpStreamTokio with a given stream.

```Rust
pub fn new(stream: S) -> Self
```

--------------------------------

### Re-export qmp from qapi

Source: https://docs.rs/qapi/latest/qapi/index

This snippet shows the re-export of the 'qmp' module from the 'qapi_qmp' crate within the qapi crate. This allows users to access qmp functionality directly through the qapi crate.

```Rust
pub use qapi_qmp as qmp;
```

--------------------------------

### Open UDS QMP Stream with Tokio in Rust

Source: https://docs.rs/qapi/latest/qapi/futures/struct

Asynchronously opens a QMP stream over a Unix Domain Socket (UDS) using Tokio. It takes a path to the socket address and returns a Result.

```Rust
pub async fn open_uds<P: AsRef<Path>>( socket_addr: P, ) -> Result<QmpStreamNegotiation<Self, QmpStreamTokio<WriteHalf<UnixStream>>>>
```

--------------------------------

### Rust: Try For Each Element in Stream

Source: https://docs.rs/qapi/latest/qapi/futures/struct

Attempts to run this stream to completion, executing the provided asynchronous closure for each element on the stream. Exits early if an error occurs.

```Rust
fn try_for_each<Fut, F>(self, f: F) -> TryForEach<Self, Fut, F>
where F: FnMut(Self::Ok) -> Fut, Fut: TryFuture<Ok = (), Error = Self::Error>, Self: Sized
```

--------------------------------

### Rust: Create stream with at most N items

Source: https://docs.rs/qapi/latest/qapi/futures/struct

The `take` method creates a new stream that yields at most `n` items from the underlying stream. If the original stream has fewer than `n` items, all of them will be yielded.

```Rust
fn take(self, n: usize) -> Take<Self>
where Self: Sized,
```

--------------------------------

### TryInto conversion in Rust

Source: https://docs.rs/qapi/latest/qapi/futures/struct

Provides the `try_into` function for attempting to convert a type into another, returning a `Result`. This is the inverse of `TryFrom`.

```Rust
type Error = <U as TryFrom<T>>::Error
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
```

--------------------------------

### Rust: Zip two streams together

Source: https://docs.rs/qapi/latest/qapi/futures/struct

The `zip` method combines two streams into a single stream of pairs. Each pair contains one item from each of the original streams. The resulting stream terminates when either of the input streams terminates.

```Rust
fn zip<St>(self, other: St) -> Zip<Self, St>
where St: Stream, Self: Sized,
```

--------------------------------

### Open TCP QMP Stream with Tokio in Rust

Source: https://docs.rs/qapi/latest/qapi/futures/struct

Asynchronously opens a QMP stream over a TCP connection using Tokio. It takes a socket address and returns a Result.

```Rust
pub async fn open_tcp<A: ToSocketAddrs>( socket_addr: A, ) -> Result<QmpStreamNegotiation<Self, QmpStreamTokio<WriteHalf<TcpStream>>>>
```

--------------------------------

### Open Split QMP Stream with Tokio in Rust

Source: https://docs.rs/qapi/latest/qapi/futures/struct

Asynchronously opens a split QMP stream using Tokio, separating read and write halves. It returns a Result containing QmpStreamNegotiation.

```Rust
pub async fn open_split<W>( read: S, write: W, ) -> Result<QmpStreamNegotiation<Self, QmpStreamTokio<W>>>
where S: AsyncRead + Unpin,
```

--------------------------------

### Rust: Convert Stream to AsyncBufRead

Source: https://docs.rs/qapi/latest/qapi/futures/struct

Adapter that converts this stream into an `AsyncBufRead`. This is useful for streams that produce byte chunks and need to be read like a file or buffer.

```Rust
fn into_async_read(self) -> IntoAsyncRead<Self>
where Self: Sized + TryStreamExt<Error = Error>, Self::Ok: AsRef<[u8]>
```

--------------------------------

### Rust Sink: Fanout to Multiple Sinks

Source: https://docs.rs/qapi/latest/qapi/futures/struct

Distributes items from a sink to multiple other sinks. Requires the item to be cloneable and the other sinks to implement the Sink trait.

```Rust
fn fanout<Si>(self, other: Si) -> Fanout<Self, Si>
where Self: Sized, Item: Clone, Si: Sink<Item, Error = Self::Error>,
```

--------------------------------

### Rust Sink: Feed Item and Await Reception

Source: https://docs.rs/qapi/latest/qapi/futures/struct

Feeds an item into the sink and returns a future that completes after the item has been received. Requires the sink to be Unpin.

```Rust
fn feed(&mut self, item: Item) -> Feed<'_, Self, Item>
where Self: Unpin,
```

--------------------------------

### Rust Stream: Enumerate Items

Source: https://docs.rs/qapi/latest/qapi/futures/struct

Creates a stream that yields the current iteration count along with the item. Requires the stream to be Sized.

```Rust
fn enumerate(self) -> Enumerate<Self>
where Self: Sized,
```

--------------------------------

### Poll Ready State of QmpStreamTokio Sink in Rust

Source: https://docs.rs/qapi/latest/qapi/futures/struct

Prepares the QmpStreamTokio sink to receive a value. It returns a Poll indicating whether the sink is ready or if the task needs to be woken up.

```Rust
fn poll_ready( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Result<(), Self::Error>>
```

--------------------------------

### TryFrom conversion in Rust

Source: https://docs.rs/qapi/latest/qapi/futures/struct

Provides the `try_from` function for converting one type into another, returning a `Result`. This is part of the standard conversion traits.

```Rust
type Error = Infallible
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
```

--------------------------------

### Open QMP Stream with Tokio in Rust

Source: https://docs.rs/qapi/latest/qapi/futures/struct

Asynchronously opens a QMP stream using Tokio, taking a generic RW type that implements AsyncRead and AsyncWrite. It returns a Result containing QmpStreamNegotiation.

```Rust
pub async fn open( stream: RW, ) -> Result<QmpStreamNegotiation<Self, QmpStreamTokio<WriteHalf<RW>>>>
where RW: Unpin,
```

--------------------------------

### Chunk items in a Rust stream

Source: https://docs.rs/qapi/latest/qapi/futures/struct

An adapter for grouping items from a stream into vectors of a specified capacity. Useful for batch processing.

```Rust
fn chunks(self, capacity: usize) -> Chunks<Self>
where Self: Sized
```

--------------------------------

### Rust: Take elements until future resolves

Source: https://docs.rs/qapi/latest/qapi/futures/struct

The `take_until` method takes elements from a stream until a provided future resolves. Once the future completes, the stream is terminated, regardless of whether there are more items available.

```Rust
fn take_until<Fut>(self, fut: Fut) -> TakeUntil<Self, Fut>
where Fut: Future, Self: Sized,
```

--------------------------------

### Rust: Create stream skipping N items

Source: https://docs.rs/qapi/latest/qapi/futures/struct

The `skip` method creates a new stream that skips the first `n` items from the underlying stream. All items after the skipped ones are then yielded.

```Rust
fn skip(self, n: usize) -> Skip<Self>
where Self: Sized,
```

--------------------------------

### Rust: Take elements while predicate is true

Source: https://docs.rs/qapi/latest/qapi/futures/struct

The `take_while` method takes elements from a stream as long as a given asynchronous predicate returns `true`. As soon as the predicate returns `false`, the stream is terminated.

```Rust
fn take_while<Fut, F>(self, f: F) -> TakeWhile<Self, Fut, F>
where F: FnMut(&Self::Item) -> Fut, Fut: Future<Output = bool>, Self: Sized,
```

--------------------------------

### Rust Stream: Count Items

Source: https://docs.rs/qapi/latest/qapi/futures/struct

Drives the stream to completion and counts the number of items processed. Requires the stream to be Sized.

```Rust
fn count(self) -> Count<Self>
where Self: Sized,
```

--------------------------------

### Rust: Try Buffer Stream Items

Source: https://docs.rs/qapi/latest/qapi/futures/struct

Attempts to execute several futures from a stream concurrently, respecting the order of the stream. The number of concurrent futures is limited by `n`. Errors are propagated.

```Rust
fn try_buffered(self, n: usize) -> TryBuffered<Self>
where Self::Ok: TryFuture<Error = Self::Error>, Self: Sized
```

--------------------------------

### Rust: Execute closure for each stream element

Source: https://docs.rs/qapi/latest/qapi/futures/struct

The `for_each` method consumes a stream and executes an asynchronous closure for each element. It runs the stream to completion and returns a future that resolves when all elements have been processed.

```Rust
fn for_each<Fut, F>(self, f: F) -> ForEach<Self, Fut, F>
where F: FnMut(Self::Item) -> Fut, Fut: Future<Output = ()>, Self: Sized,
```

--------------------------------

### Rust: Try Collect Stream into Collection

Source: https://docs.rs/qapi/latest/qapi/futures/struct

Attempts to transform a stream into a collection, returning a future that represents the result. The collection must implement `Default` and `Extend`.

```Rust
fn try_collect<C>(self) -> TryCollect<Self, C>
where C: Default + Extend<Self::Ok>, Self: Sized
```

--------------------------------

### Rust Sink: Send Item and Complete Processing

Source: https://docs.rs/qapi/latest/qapi/futures/struct

Sends an item to the sink and returns a future that completes after the item is fully processed, including flushing. Requires the sink to be Unpin.

```Rust
fn send(&mut self, item: Item) -> Send<'_, Self, Item>
where Self: Unpin,
```

--------------------------------

### Rust: Try For Each Concurrent Element

Source: https://docs.rs/qapi/latest/qapi/futures/struct

Attempts to run this stream to completion concurrently, executing the provided asynchronous closure for each element. Exits as soon as an error occurs. Supports a concurrency limit.

```Rust
fn try_for_each_concurrent<Fut, F>( self, limit: impl Into<Option<usize>>, f: F, ) -> TryForEachConcurrent<Self, Fut, F>
where F: FnMut(Self::Ok) -> Fut, Fut: Future<Output = Result<(), Self::Error>>, Self: Sized
```

--------------------------------

### Rust Stream: Map Items

Source: https://docs.rs/qapi/latest/qapi/futures/struct

Maps the items of a stream to a different type using a closure, returning a new stream. Requires the stream to be Sized.

```Rust
fn map<T, F>(self, f: F) -> Map<Self, F>
where F: FnMut(Self::Item) -> T, Self: Sized,
```

--------------------------------

### Rust: Try Buffer Stream Items Unordered

Source: https://docs.rs/qapi/latest/qapi/futures/struct

Attempts to execute several futures from a stream concurrently and unordered. The number of concurrent futures is limited by `n`. Errors are propagated.

```Rust
fn try_buffer_unordered(self, n: usize) -> TryBufferUnordered<Self>
where Self::Ok: TryFuture<Error = Self::Error>, Self: Sized
```

--------------------------------

### Rust: Try Next Item in Stream

Source: https://docs.rs/qapi/latest/qapi/futures/struct

Creates a future that attempts to resolve the next item in the stream. If an error is encountered before the next item, the error is returned instead.

```Rust
fn try_next(&mut self) -> TryNext<'_, Self>
where Self: Unpin
```

--------------------------------

### Implement TryInto<U> for T in Rust

Source: https://docs.rs/qapi/latest/qapi/enum

Implements the `TryInto<U>` trait for any type `T` where `U` implements `TryFrom<T>`. This provides a convenient way to attempt converting `T` into `U`. The `try_into` method consumes `self` and returns a `Result`.

```Rust
impl<T, U>
TryInto<U> for T
where
    U: TryFrom<T>,
{
    type Error = <U as TryFrom<T>>::Error;

    fn try_into(self) -> Result<U, Self::Error> {
        U::try_from(self)
    }
}

```

--------------------------------

### Rust: Borrow a stream by reference

Source: https://docs.rs/qapi/latest/qapi/futures/struct

The `by_ref` method provides a reference to the stream itself, rather than consuming it. This allows methods that require `&mut self` to be called on a borrowed stream.

```Rust
fn by_ref(&mut self) -> &mut Self
```

--------------------------------

### Rust Sink: Send All Items from a Stream

Source: https://docs.rs/qapi/latest/qapi/futures/struct

Processes all items from a given stream into the sink, including flushing. Returns a future that completes upon completion. Requires the sink and stream to be Unpin, and the stream to implement TryStream.

```Rust
fn send_all<'a, St>(&'a mut self, stream: &'a mut St) -> SendAll<'a, Self, St>
where St: TryStream<Ok = Item, Error = Self::Error> + Stream + Unpin + ?Sized, Self: Unpin,
```

--------------------------------

### Rust: Create a buffered list of pending futures

Source: https://docs.rs/qapi/latest/qapi/futures/struct

The `buffered` method creates a new stream that buffers a specified number of pending futures. It yields futures as they complete, maintaining the order of the original stream.

```Rust
fn buffered(self, n: usize) -> Buffered<Self>
where Self::Item: Future, Self: Sized,
```

--------------------------------

### Identity Conversion in Rust

Source: https://docs.rs/qapi/latest/qapi/futures/struct

Provides an identity conversion function 'from' that returns the argument unchanged, as part of the 'From<T> for T' implementation.

```Rust
fn from(t: T) -> T
```

--------------------------------

### Map success value of Rust TryStream

Source: https://docs.rs/qapi/latest/qapi/futures/struct

Wraps a `TryStream` to apply a closure `f` to each successful item (`Ok` variant), transforming it into a new type `T`. Errors remain unchanged.

```Rust
fn map_ok<T, F>(self, f: F) -> MapOk<Self, F>
where Self: Sized, F: FnMut(Self::Ok) -> T
```

--------------------------------

### Rust: Execute accumulating async computation over a stream

Source: https://docs.rs/qapi/latest/qapi/futures/struct

The `fold` method executes an accumulating asynchronous computation over a stream, collecting all values into a single final result. It requires a closure that takes an accumulator and a stream item, returning a future that resolves to the next accumulator value.

```Rust
fn fold<T, Fut, F>(self, init: T, f: F) -> Fold<Self, Fut, T, F>
where F: FnMut(T, Self::Item) -> Fut, Fut: Future<Output = T>, Self: Sized,
```

--------------------------------

### Rust: Combinator for stateful stream processing

Source: https://docs.rs/qapi/latest/qapi/futures/struct

The `scan` method is a stateful stream combinator. It maintains an internal state that is updated by a provided asynchronous closure for each item, producing a new stream of results. The closure returns an `Option` to control stream termination.

```Rust
fn scan<S, B, Fut, F>(self, initial_state: S, f: F) -> Scan<Self, S, Fut, F>
where F: FnMut(&mut S, Self::Item) -> Fut, Fut: Future<Output = Option<B>>, Self: Sized,
```

--------------------------------

### Rust Sink: Poll Ready (Unpin)

Source: https://docs.rs/qapi/latest/qapi/futures/struct

A convenience method for calling `Sink::poll_ready` on `Unpin` sink types. Requires the sink to be Unpin.

```Rust
fn poll_ready_unpin(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>>
where Self: Unpin,
```

--------------------------------

### Poll next item from Unpin Rust stream

Source: https://docs.rs/qapi/latest/qapi/futures/struct

A convenience method for calling `Stream::poll_next` specifically for streams that implement `Unpin`. It simplifies polling for ready items.

```Rust
fn poll_next_unpin(&mut self, cx: &mut Context<'_>) -> Poll<Option<Self::Item>>
where Self: Unpin
```

--------------------------------

### Poll next result from Rust TryStream

Source: https://docs.rs/qapi/latest/qapi/futures/struct

Polls the next item from a `TryStream`, returning a `Poll` containing an `Option` of a `Result`. This is the core method for interacting with `TryStream`.

```Rust
type Ok = T
type Error = E
fn try_poll_next( self: Pin<&mut S>, cx: &mut Context<'_>, ) -> Poll<Option<Result<<S as TryStream>::Ok, <S as TryStream>::Error>>>
```

--------------------------------

### Compose FlatMap Function Before Sink in Rust

Source: https://docs.rs/qapi/latest/qapi/futures/struct

Composes a function 'f' that returns a Stream in front of a sink, allowing asynchronous mapping and flattening of items before sending.

```Rust
fn with_flat_map<U, St, F>(self, f: F) -> WithFlatMap<Self, Item, U, St, F>
where F: FnMut(U) -> St, St: Stream<Item = Result<Item, Self::Error>>, Self: Sized,
```

--------------------------------

### Rust: Create a buffered list of pending futures (unordered)

Source: https://docs.rs/qapi/latest/qapi/futures/struct

The `buffer_unordered` method creates a stream that buffers futures up to a specified limit, yielding them in the order they complete. This is useful for processing futures concurrently without regard to their original order.

```Rust
fn buffer_unordered(self, n: usize) -> BufferUnordered<Self>
where Self::Item: Future, Self: Sized,
```

--------------------------------

### Rust Stream: Filter and Map with Async Closure

Source: https://docs.rs/qapi/latest/qapi/futures/struct

Filters and maps stream items simultaneously using an asynchronous closure. Requires the stream to be Sized.

```Rust
fn filter_map<Fut, T, F>(self, f: F) -> FilterMap<Self, Fut, F>
where F: FnMut(Self::Item) -> Fut, Fut: Future<Output = Option<T>>, Self: Sized,
```

--------------------------------

### Rust: Execute predicate over async stream for any element

Source: https://docs.rs/qapi/latest/qapi/futures/struct

The `any` method executes a predicate over an asynchronous stream. It returns `true` if any element in the stream satisfies the predicate, and `false` otherwise. The predicate itself must return a future that resolves to a boolean.

```Rust
fn any<Fut, F>(self, f: F) -> Any<Self, Fut, F>
where F: FnMut(Self::Item) -> Fut, Fut: Future<Output = bool>, Self: Sized,
```

--------------------------------

### Implement Event Trait for RESUME in Rust

Source: https://docs.rs/qapi/latest/qapi/trait

This Rust code implements the `Event` trait for the `RESUME` type. It sets the associated constant `NAME` to 'RESUME', identifying this specific event.

```Rust
impl Event for RESUME {
    const NAME: &'static str = "RESUME";
}
```

--------------------------------

### Rust: Try Filter and Map Stream Elements

Source: https://docs.rs/qapi/latest/qapi/futures/struct

Attempts to filter and map the values produced by this stream simultaneously using an asynchronous closure. The closure returns `Option<T>` and can also return an error.

```Rust
fn try_filter_map<Fut, F, T>(self, f: F) -> TryFilterMap<Self, Fut, F>
where Fut: TryFuture<Ok = Option<T>, Error = Self::Error>, F: FnMut(Self::Ok) -> Fut, Self: Sized
```

--------------------------------

### Chain computation on Rust TryStream success

Source: https://docs.rs/qapi/latest/qapi/futures/struct

Chains a future-producing closure `f` to be executed when a `TryStream` yields a successful item. The closure receives the success value and must return a `TryFuture`.

```Rust
fn and_then<Fut, F>(self, f: F) -> AndThen<Self, Fut, F>
where F: FnMut(Self::Ok) -> Fut, Fut: TryFuture<Error = Self::Error>, Self: Sized
```

--------------------------------

### Implement CloneToUninit for Generic Type T in Rust

Source: https://docs.rs/qapi/latest/qapi/struct

Implements the nightly-only experimental 'CloneToUninit' trait for any type 'T' that implements 'Clone' in Rust. This unsafe function copies data to an uninitialized memory location.

```Rust
unsafe fn clone_to_uninit(&self, dest: *mut u8)
```

--------------------------------

### Forward Rust stream to a Sink

Source: https://docs.rs/qapi/latest/qapi/futures/struct

Creates a future that completes after all items from a stream have been processed by a sink and the sink has been flushed and closed. Requires the sink to accept the stream's item type and handle errors.

```Rust
fn forward<S>(self, sink: S) -> Forward<Self, S>
where S: Sink<Self::Ok, Error = Self::Error>, Self: Sized + TryStream
```

--------------------------------

### Rust: Map and flatten nested streams

Source: https://docs.rs/qapi/latest/qapi/futures/struct

The `flat_map` method is similar to `map` but specifically designed for streams where the mapping function returns another stream. It then flattens these nested streams into a single output stream.

```Rust
fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
where F: FnMut(Self::Item) -> U, U: Stream, Self: Sized,
```

--------------------------------

### Rust: Try Any Item in Async Stream

Source: https://docs.rs/qapi/latest/qapi/futures/struct

Executes a predicate over an asynchronous stream to check if any item satisfies it. The operation exits early if an error is encountered or if an item satisfies the predicate. Requires the stream item to be convertible to a future that returns a boolean.

```Rust
fn try_any<Fut, F>(self, f: F) -> TryAny<Self, Fut, F>
where
    Self: Sized,
    F: FnMut(Self::Ok) -> Fut,
    Fut: Future<Output = bool>,
{
    // Implementation details...
}
```

--------------------------------

### Create a peekable Rust stream

Source: https://docs.rs/qapi/latest/qapi/futures/struct

Creates a new stream that allows peeking at the next item without consuming it. This is useful for lookahead operations in stream processing.

```Rust
fn peekable(self) -> Peekable<Self>
where Self: Sized
```

--------------------------------

### Rust: Try Poll Next Item (Unpin)

Source: https://docs.rs/qapi/latest/qapi/futures/struct

A convenience method for calling `TryStream::try_poll_next` on `Unpin` stream types. It polls the stream for the next item, returning `Poll::Ready(Some(Ok(item)))`, `Poll::Ready(Some(Err(error)))`, `Poll::Ready(None)`, or `Poll::Pending`.

```Rust
fn try_poll_next_unpin( &mut self, cx: &mut Context<'_>, ) -> Poll<Option<Result<Self::Ok, Self::Error>>>
where Self: Unpin
```

--------------------------------

### Implement Sync for QmpStreamTokio in Rust

Source: https://docs.rs/qapi/latest/qapi/futures/struct

Implements the 'Sync' trait for QmpStreamTokio, indicating that it can be safely shared between threads if the underlying stream type S also implements 'Sync'.

```Rust
impl<S> Sync for QmpStreamTokio<S>
where S: Sync,
```

--------------------------------

### Chain two Rust streams

Source: https://docs.rs/qapi/latest/qapi/futures/struct

Chains two streams together, allowing sequential processing of items from both. Requires the second stream to yield items compatible with the first stream's item type.

```Rust
fn chain<St>(self, other: St) -> Chain<Self, St>
where St: Stream<Item = Self::Item>, Self: Sized
```

--------------------------------

### Rust Sink: Flush Pending Items

Source: https://docs.rs/qapi/latest/qapi/futures/struct

Flushes the sink, ensuring all pending items are processed. Requires the sink to be Unpin.

```Rust
fn flush(&mut self) -> Flush<'_, Self, Item>
where Self: Unpin,
```

--------------------------------

### Define VNC_INITIALIZED Event Name in Rust

Source: https://docs.rs/qapi/latest/qapi/trait

This snippet defines a static string slice named NAME with the value "VNC_INITIALIZED". This constant is used to represent the VNC_INITIALIZED event.

```rust
const NAME: &'static str = "VNC_INITIALIZED"
```

--------------------------------

### Rust: Execute predicate over async stream for all elements

Source: https://docs.rs/qapi/latest/qapi/futures/struct

The `all` method executes a predicate over an asynchronous stream. It returns `true` if all elements in the stream satisfy the predicate, and `false` otherwise. The predicate must return a future that resolves to a boolean.

```Rust
fn all<Fut, F>(self, f: F) -> All<Self, Fut, F>
where F: FnMut(Self::Item) -> Fut, Fut: Future<Output = bool>, Self: Sized,
```

--------------------------------

### Rust: Try Take Elements While Predicate is True

Source: https://docs.rs/qapi/latest/qapi/futures/struct

Takes elements on this stream while the provided asynchronous predicate resolves to `true`. Stops taking when the predicate returns `false` or an error occurs.

```Rust
fn try_take_while<Fut, F>(self, f: F) -> TryTakeWhile<Self, Fut, F>
where F: FnMut(&Self::Ok) -> Fut, Fut: TryFuture<Ok = bool, Error = Self::Error>, Self: Sized
```

--------------------------------

### Implement TryFrom<U> for T in Rust

Source: https://docs.rs/qapi/latest/qapi/enum

Implements the `TryFrom<U>` trait for any type `T` where `U` implements `Into<T>`. This allows for fallible conversions from `U` to `T`. The `try_from` method attempts the conversion and returns a `Result`.

```Rust
impl<T, U>
TryFrom<U> for T
where
    U: Into<T>,
{
    type Error = Infallible; // Infallible indicates the conversion always succeeds.

    fn try_from(value: U) -> Result<T, Self::Error> {
        Ok(value.into())
    }
}

```

--------------------------------

### Split Rust Stream + Sink

Source: https://docs.rs/qapi/latest/qapi/futures/struct

Splits a stream that also implements Sink into two separate objects: one for sending (Sink) and one for receiving (Stream).

```Rust
fn split<Item>(self) -> (SplitSink<Self, Item>, SplitStream<Self>)
where Self: Sized + Sink<Item>
```

--------------------------------

### Implement Event Trait for ACPI_DEVICE_OST in Rust

Source: https://docs.rs/qapi/latest/qapi/trait

This Rust code implements the `Event` trait for the `ACPI_DEVICE_OST` type. It sets the associated constant `NAME` to 'ACPI_DEVICE_OST', identifying this specific event.

```Rust
impl Event for ACPI_DEVICE_OST {
    const NAME: &'static str = "ACPI_DEVICE_OST";
}
```

--------------------------------

### Convert Rust TryStream to Stream

Source: https://docs.rs/qapi/latest/qapi/futures/struct

Wraps a `TryStream` into a type that implements the standard `Stream` trait. This allows using `Stream` combinators on streams that originally produced `Result` items.

```Rust
fn into_stream(self) -> IntoStream<Self>
where Self: Sized
```

--------------------------------

### Rust Stream: Unzip into Two Collections

Source: https://docs.rs/qapi/latest/qapi/futures/struct

Converts a stream of pairs into a future that resolves to two collections, one for each element of the pair. Requires the collection types to implement Default and Extend.

```Rust
fn unzip<A, B, FromA, FromB>(self) -> Unzip<Self, FromA, FromB>
where FromA: Default + Extend<A>, FromB: Default + Extend<B>, Self: Sized + Stream<Item = (A, B)>,
```

--------------------------------

### Select next item from Fused Rust stream

Source: https://docs.rs/qapi/latest/qapi/futures/struct

Returns a future that resolves when the next item is available from a `FusedStream`. This is useful for efficiently waiting for stream data.

```Rust
fn select_next_some(&mut self) -> SelectNextSome<'_, Self>
where Self: Unpin + FusedStream
```

--------------------------------

### Rust Stream: Convert to Future

Source: https://docs.rs/qapi/latest/qapi/futures/struct

Converts a stream into a future that yields the next item and the rest of the stream. If the stream terminates, the next item is `None`. Requires the stream to be Sized and Unpin.

```Rust
fn into_future(self) -> StreamFuture<Self>
where Self: Sized + Unpin,
```

--------------------------------

### Define VNC_CONNECTED Event Name in Rust

Source: https://docs.rs/qapi/latest/qapi/trait

This snippet defines a static string slice named NAME with the value "VNC_CONNECTED". This constant is used to represent the VNC_CONNECTED event.

```rust
const NAME: &'static str = "VNC_CONNECTED"
```

--------------------------------

### Inspect items in a Rust stream

Source: https://docs.rs/qapi/latest/qapi/futures/struct

Applies a closure to each item of a stream without consuming it, allowing side effects like logging or debugging. The item is then passed on.

```Rust
fn inspect<F>(self, f: F) -> Inspect<Self, F>
where F: FnMut(&Self::Item), Self: Sized
```

--------------------------------

### Rust Stream: Cycle Infinitely

Source: https://docs.rs/qapi/latest/qapi/futures/struct

Repeats the items of a stream endlessly. Requires the stream to be Sized and Clone.

```Rust
fn cycle(self) -> Cycle<Self>
where Self: Sized + Clone,
```

--------------------------------

### Implement From<T> for T in Rust

Source: https://docs.rs/qapi/latest/qapi/enum

Implements the `From<T>` trait for any type `T`. This allows a type to be converted from itself, effectively returning the original value. The `from` method takes ownership of the value and returns it unchanged.

```Rust
impl<T> From<T> for T {
    fn from(t: T) -> T {
        t
    }
}

```

--------------------------------

### Rust: Try Flatten Stream of Streams

Source: https://docs.rs/qapi/latest/qapi/futures/struct

Flattens a stream of streams into a single continuous stream. Errors from inner streams or the base stream are propagated.

```Rust
fn try_flatten(self) -> TryFlatten<Self>
where Self::Ok: TryStream, <Self::Ok as TryStream>::Error: From<Self::Error>, Self: Sized
```

--------------------------------

### Inspect success value of Rust TryStream

Source: https://docs.rs/qapi/latest/qapi/futures/struct

Applies a closure `f` to the success value of a `TryStream` without consuming it, allowing side effects. The success value is then passed on.

```Rust
fn inspect_ok<F>(self, f: F) -> InspectOk<Self, F>
where F: FnMut(&Self::Ok), Self: Sized
```

--------------------------------

### Rust Stream: Collect into Collection

Source: https://docs.rs/qapi/latest/qapi/futures/struct

Collects all items from a stream into a specified collection type, returning a future for the result. Requires the collection to implement Default and Extend.

```Rust
fn collect<C>(self) -> Collect<Self, C>
where C: Default + Extend<Self::Item>, Self: Sized,
```

--------------------------------

### Rust Stream: Filter with Async Predicate

Source: https://docs.rs/qapi/latest/qapi/futures/struct

Filters stream items based on an asynchronous predicate. Requires the stream to be Sized.

```Rust
fn filter<Fut, F>(self, f: F) -> Filter<Self, Fut, F>
where F: FnMut(&Self::Item) -> Fut, Fut: Future<Output = bool>, Self: Sized,
```

--------------------------------

### Rust: Execute closure concurrently for each stream element

Source: https://docs.rs/qapi/latest/qapi/futures/struct

The `for_each_concurrent` method processes a stream by executing an asynchronous closure for each element concurrently. It allows specifying a concurrency limit and ensures all elements are processed before the returned future resolves.

```Rust
fn for_each_concurrent<Fut, F>( self, limit: impl Into<Option<usize>>, f: F, ) -> ForEachConcurrent<Self, Fut, F>
where F: FnMut(Self::Item) -> Fut, Fut: Future<Output = ()>, Self: Sized,
```

--------------------------------

### Rust: Try Fold Stream with Accumulator

Source: https://docs.rs/qapi/latest/qapi/futures/struct

Attempts to execute an accumulating asynchronous computation over a stream, collecting all values into one final result. The accumulator function can return an error.

```Rust
fn try_fold<T, Fut, F>(self, init: T, f: F) -> TryFold<Self, Fut, T, F>
where F: FnMut(T, Self::Ok) -> Fut, Fut: TryFuture<Ok = T, Error = Self::Error>, Self: Sized
```

--------------------------------

### Implement SinkExt for Generic Sink in Rust

Source: https://docs.rs/qapi/latest/qapi/futures/struct

Implements the 'SinkExt' trait for any type T that implements the 'Sink' trait, providing additional utility methods for sinks.

```Rust
impl<T, Item> SinkExt<Item> for T
where T: Sink<Item> + ?Sized,
```

--------------------------------

### Implement Event Trait for DEVICE_TRAY_MOVED in Rust

Source: https://docs.rs/qapi/latest/qapi/trait

This Rust code implements the `Event` trait for the `DEVICE_TRAY_MOVED` type. It sets the associated constant `NAME` to 'DEVICE_TRAY_MOVED', identifying this specific event.

```Rust
impl Event for DEVICE_TRAY_MOVED {
    const NAME: &'static str = "DEVICE_TRAY_MOVED";
}
```

--------------------------------

### Compose Function Before Sink in Rust

Source: https://docs.rs/qapi/latest/qapi/futures/struct

Composes a function 'f' in front of a sink, allowing asynchronous transformation of items before they are sent. Requires the function to return a Future.

```Rust
fn with<U, Fut, F, E>(self, f: F) -> With<Self, Item, U, Fut, F>
where F: FnMut(U) -> Fut, Fut: Future<Output = Result<Item, E>>, E: From<Self::Error>, Self: Sized,
```

--------------------------------

### Rust: Try All Items in Async Stream

Source: https://docs.rs/qapi/latest/qapi/futures/struct

Executes a predicate over an asynchronous stream to check if all items satisfy it. The operation exits early if an error is encountered or if an item does not satisfy the predicate. Requires the stream item to be convertible to a future that returns a boolean.

```Rust
fn try_all<Fut, F>(self, f: F) -> TryAll<Self, Fut, F>
where
    Self: Sized,
    F: FnMut(Self::Ok) -> Fut,
    Fut: Future<Output = bool>,
{
    // Implementation details...
}
```

--------------------------------

### Implement Into<U> for T in Rust

Source: https://docs.rs/qapi/latest/qapi/enum

Implements the `Into<U>` trait for any type `T` where `U` implements `From<T>`. This provides a convenient way to convert `T` into `U` by calling `U::from(self)`. The `into` method consumes `self` and returns the converted value.

```Rust
impl<T, U> Into<U> for T
where
    U: From<T>,
{
    fn into(self) -> U {
        U::from(self)
    }
}

```

--------------------------------

### Implement Clone for Timestamp in Rust

Source: https://docs.rs/qapi/latest/qapi/struct

Provides implementations for the 'Clone' trait for the 'Timestamp' struct in Rust. This allows creating duplicate values of 'Timestamp'. It includes methods for both cloning and cloning from another source.

```Rust
fn clone(&self) -> Timestamp
```

```Rust
fn clone_from(&mut self, source: &Self)
```

--------------------------------

### Rust Sink: Poll Flush (Unpin)

Source: https://docs.rs/qapi/latest/qapi/futures/struct

A convenience method for calling `Sink::poll_flush` on `Unpin` sink types. Requires the sink to be Unpin.

```Rust
fn poll_flush_unpin(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>>
where Self: Unpin,
```

--------------------------------

### Convert TryStream error to another type

Source: https://docs.rs/qapi/latest/qapi/futures/struct

Wraps a `TryStream` to convert its error type into a specified type `E`, provided the original error implements `Into<E>`. This simplifies error handling chains.

```Rust
fn err_into<E>(self) -> ErrInto<Self, E>
where Self: Sized, Self::Error: Into<E>
```

--------------------------------

### Implement Event Trait for GUEST_CRASHLOADED in Rust

Source: https://docs.rs/qapi/latest/qapi/trait

This Rust code implements the `Event` trait for the `GUEST_CRASHLOADED` type. It sets the associated constant `NAME` to 'GUEST_CRASHLOADED', identifying this specific event.

```Rust
impl Event for GUEST_CRASHLOADED {
    const NAME: &'static str = "GUEST_CRASHLOADED";
}
```

--------------------------------

### Rust: Try Flatten Stream of Streams (Unordered)

Source: https://docs.rs/qapi/latest/qapi/futures/struct

Flattens a stream of streams into a single continuous stream, polling inner streams concurrently and unordered. Errors from inner streams or the base stream are propagated immediately.

```Rust
fn try_flatten_unordered( self, limit: impl Into<Option<usize>>, ) -> TryFlattenUnordered<Self>
where Self::Ok: TryStream + Unpin, <Self::Ok as TryStream>::Error: From<Self::Error>, Self: Sized
```

--------------------------------

### Rust Sink: Wrap in Either (Left)

Source: https://docs.rs/qapi/latest/qapi/futures/struct

Wraps a sink in an `Either` sink, making it the left-hand variant. Requires the other sink to implement the Sink trait.

```Rust
fn left_sink<Si2>(self) -> Either<Self, Si2>
where Si2: Sink<Item, Error = Self::Error>, Self: Sized,
```

--------------------------------

### Map error value of Rust TryStream

Source: https://docs.rs/qapi/latest/qapi/futures/struct

Wraps a `TryStream` to apply a closure `f` to each error (`Err` variant), transforming it into a new error type `E`. Success values remain unchanged.

```Rust
fn map_err<E, F>(self, f: F) -> MapErr<Self, F>
where Self: Sized, F: FnMut(Self::Error) -> E
```

--------------------------------

### Rust Sink: Wrap in Either (Right)

Source: https://docs.rs/qapi/latest/qapi/futures/struct

Wraps a sink in an `Either` sink, making it the right-hand variant. Requires the other sink to implement the Sink trait.

```Rust
fn right_sink<Si1>(self) -> Either<Si1, Self>
where Si1: Sink<Item, Error = Self::Error>, Self: Sized,
```

--------------------------------

### Implement Serialize for Never in Rust

Source: https://docs.rs/qapi/latest/qapi/enum

Implements the `Serialize` trait for the `Never` enum. This allows instances of `Never` to be serialized into a Serde serializer. Since `Never` cannot be constructed, this serialization method is typically a no-op or an error.

```Rust
impl Serialize for Never
where
    S: Serializer,
{
    fn serialize<S>(&self, _: S) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> {
        // This function is never actually called because Never cannot be constructed.
        // It's required by the Serialize trait.
        unimplemented!("Never cannot be serialized")
    }
}

```

--------------------------------

### Poll Next Item from QmpStreamTokio Stream in Rust

Source: https://docs.rs/qapi/latest/qapi/futures/struct

Attempts to retrieve the next item from the QmpStreamTokio stream. It registers the current task for wakeup if the item is not yet available and returns None if the stream is exhausted.

```Rust
fn poll_next( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Option<Self::Item>>
```

--------------------------------

### Implement Any for Generic Type T in Rust

Source: https://docs.rs/qapi/latest/qapi/futures/struct

Implements the 'Any' trait for any type T that is 'static and sized, allowing for runtime type identification.

```Rust
impl<T> Any for T
where T: 'static + ?Sized,
```

--------------------------------

### Rust: Map and flatten nested streams concurrently

Source: https://docs.rs/qapi/latest/qapi/futures/struct

The `flat_map_unordered` method maps items to streams and flattens them concurrently. It accepts a concurrency limit and yields items as they are ready, providing efficient processing of nested asynchronous operations.

```Rust
fn flat_map_unordered<U, F>( self, limit: impl Into<Option<usize>>, f: F, ) -> FlatMapUnordered<Self, U, F>
where U: Stream + Unpin, F: FnMut(Self::Item) -> U, Self: Sized,
```

--------------------------------

### Implement Event Trait for GUEST_PVSHUTDOWN in Rust

Source: https://docs.rs/qapi/latest/qapi/trait

This Rust code implements the `Event` trait for the `GUEST_PVSHUTDOWN` type. It sets the associated constant `NAME` to 'GUEST_PVSHUTDOWN', identifying this specific event.

```Rust
impl Event for GUEST_PVSHUTDOWN {
    const NAME: &'static str = "GUEST_PVSHUTDOWN";
}
```

--------------------------------

### Rust: Try Skip Elements While Predicate is True

Source: https://docs.rs/qapi/latest/qapi/futures/struct

Skips elements on this stream while the provided asynchronous predicate resolves to `true`. Stops skipping when the predicate returns `false` or an error occurs.

```Rust
fn try_skip_while<Fut, F>(self, f: F) -> TrySkipWhile<Self, Fut, F>
where F: FnMut(&Self::Ok) -> Fut, Fut: TryFuture<Ok = bool, Error = Self::Error>, Self: Sized
```

--------------------------------

### Chain computation on Rust TryStream error

Source: https://docs.rs/qapi/latest/qapi/futures/struct

Chains a future-producing closure `f` to be executed when a `TryStream` yields an error. The closure receives the error value and must return a `TryFuture`.

```Rust
fn or_else<Fut, F>(self, f: F) -> OrElse<Self, Fut, F>
where F: FnMut(Self::Error) -> Fut, Fut: TryFuture<Ok = Self::Ok>, Self: Sized
```
Tokens:
Raw