use std::future::Future;
use std::pin::Pin;
use std::task::{Context, Poll};
use bytes::buf::UninitSlice;
use bytes::{BufMut, Bytes};
use super::{BufferPool, SegmentedBytes};
pub trait BufferPoolExt {
fn carrier_size(&self) -> usize;
fn try_reserve(&self, bytes: usize) -> Result<Option<Reservation>, ReserveError>;
fn reserve(&self, bytes: usize) -> ReserveFuture;
fn acquire(
&self,
reservation: &Reservation,
min_bytes: usize,
) -> Result<PooledBufMut, AcquireError>;
fn acquire_unreserved(&self, min_bytes: usize) -> Result<PooledBufMut, AcquireError>;
}
impl BufferPoolExt for BufferPool {
#[inline]
fn carrier_size(&self) -> usize {
BufferPool::carrier_size(self)
}
#[inline]
fn try_reserve(&self, bytes: usize) -> Result<Option<Reservation>, ReserveError> {
BufferPool::try_reserve(self, bytes)
.map(|grant| grant.map(Reservation))
.map_err(ReserveError)
}
#[inline]
fn reserve(&self, bytes: usize) -> ReserveFuture {
ReserveFuture(BufferPool::reserve(self, bytes))
}
#[inline]
fn acquire(
&self,
reservation: &Reservation,
min_bytes: usize,
) -> Result<PooledBufMut, AcquireError> {
BufferPool::acquire(self, &reservation.0, min_bytes)
.map(PooledBufMut)
.map_err(AcquireError)
}
#[inline]
fn acquire_unreserved(&self, min_bytes: usize) -> Result<PooledBufMut, AcquireError> {
BufferPool::acquire_unreserved(self, min_bytes)
.map(PooledBufMut)
.map_err(AcquireError)
}
}
#[derive(Debug)]
pub struct Reservation(super::Reservation);
impl Reservation {
#[inline]
pub fn close_acquisition(self) {
self.0.close_acquisition();
}
}
#[derive(Debug)]
#[must_use = "a reservation request does nothing unless polled or awaited"]
pub struct ReserveFuture(super::ReserveFuture);
impl Future for ReserveFuture {
type Output = Result<Reservation, ReserveError>;
#[inline]
fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
Pin::new(&mut self.0)
.poll(cx)
.map(|result| result.map(Reservation).map_err(ReserveError))
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct ReserveError(super::ReserveError);
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct AcquireError(super::AcquireError);
#[derive(Debug)]
pub struct PooledBufMut(super::PooledBufMut);
impl PooledBufMut {
#[inline]
pub fn capacity(&self) -> usize {
self.0.capacity()
}
#[inline]
pub fn len(&self) -> usize {
self.0.len()
}
#[inline]
pub fn is_empty(&self) -> bool {
self.0.is_empty()
}
#[inline]
pub fn initialized_chunk(&self) -> &[u8] {
self.0.initialized_chunk()
}
#[inline]
pub fn reserve(&mut self, min_writable: usize) -> Result<(), AcquireError> {
self.0.reserve(min_writable).map_err(AcquireError)
}
#[inline]
pub fn publish_prefix(&mut self, count: usize) -> Bytes {
self.0.publish_prefix(count)
}
#[inline]
pub fn freeze(self) -> SegmentedBytes {
self.0.freeze()
}
}
unsafe impl BufMut for PooledBufMut {
#[inline]
fn remaining_mut(&self) -> usize {
self.0.remaining_mut()
}
#[inline]
fn chunk_mut(&mut self) -> &mut UninitSlice {
self.0.chunk_mut()
}
#[inline]
unsafe fn advance_mut(&mut self, count: usize) {
unsafe { self.0.advance_mut(count) }
}
}