Skip to main content

compio_driver/buffer_pool/
fusion.rs

1use std::{
2    borrow::{Borrow, BorrowMut},
3    fmt::{Debug, Formatter},
4    ops::{Deref, DerefMut},
5};
6
7pub use fallback::BufferPool as FallbackBufferPool;
8pub(crate) use fallback::OwnedBuffer;
9pub use iour::BufferPool as IoUringBufferPool;
10
11use super::{fallback, iour};
12
13/// Buffer pool
14///
15/// A buffer pool to allow user no need to specify a specific buffer to do the
16/// IO operation
17pub struct BufferPool {
18    inner: BufferPollInner,
19}
20
21impl Debug for BufferPool {
22    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
23        f.debug_struct("BufferPool").finish_non_exhaustive()
24    }
25}
26
27impl BufferPool {
28    pub(crate) fn is_io_uring(&self) -> bool {
29        matches!(&self.inner, BufferPollInner::IoUring(_))
30    }
31
32    pub(crate) fn new_io_uring(buffer_pool: iour::BufferPool) -> Self {
33        Self {
34            inner: BufferPollInner::IoUring(buffer_pool),
35        }
36    }
37
38    pub(crate) fn as_io_uring(&self) -> &iour::BufferPool {
39        match &self.inner {
40            BufferPollInner::IoUring(inner) => inner,
41            BufferPollInner::Poll(_) => panic!("BufferPool type is not poll type"),
42        }
43    }
44
45    pub(crate) fn as_poll(&self) -> &fallback::BufferPool {
46        match &self.inner {
47            BufferPollInner::Poll(inner) => inner,
48            BufferPollInner::IoUring(_) => panic!("BufferPool type is not io-uring type"),
49        }
50    }
51
52    pub(crate) fn new_poll(buffer_pool: fallback::BufferPool) -> Self {
53        Self {
54            inner: BufferPollInner::Poll(buffer_pool),
55        }
56    }
57
58    pub(crate) fn into_io_uring(self) -> iour::BufferPool {
59        match self.inner {
60            BufferPollInner::IoUring(inner) => inner,
61            BufferPollInner::Poll(_) => panic!("BufferPool type is not poll type"),
62        }
63    }
64}
65
66enum BufferPollInner {
67    IoUring(iour::BufferPool),
68    Poll(fallback::BufferPool),
69}
70
71/// Buffer borrowed from buffer pool
72///
73/// When IO operation finish, user will obtain a `BorrowedBuffer` to access the
74/// filled data
75pub struct BorrowedBuffer<'a> {
76    inner: BorrowedBufferInner<'a>,
77}
78
79impl<'a> BorrowedBuffer<'a> {
80    pub(crate) fn new_io_uring(buffer: iour::BorrowedBuffer<'a>) -> Self {
81        Self {
82            inner: BorrowedBufferInner::IoUring(buffer),
83        }
84    }
85
86    pub(crate) fn new_poll(buffer: fallback::BorrowedBuffer<'a>) -> Self {
87        Self {
88            inner: BorrowedBufferInner::Poll(buffer),
89        }
90    }
91}
92
93enum BorrowedBufferInner<'a> {
94    IoUring(iour::BorrowedBuffer<'a>),
95    Poll(fallback::BorrowedBuffer<'a>),
96}
97
98impl Debug for BorrowedBuffer<'_> {
99    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
100        f.debug_struct("BorrowedBuffer").finish_non_exhaustive()
101    }
102}
103
104impl Deref for BorrowedBuffer<'_> {
105    type Target = [u8];
106
107    fn deref(&self) -> &Self::Target {
108        match &self.inner {
109            BorrowedBufferInner::IoUring(inner) => inner.deref(),
110            BorrowedBufferInner::Poll(inner) => inner.deref(),
111        }
112    }
113}
114
115impl DerefMut for BorrowedBuffer<'_> {
116    fn deref_mut(&mut self) -> &mut Self::Target {
117        match &mut self.inner {
118            BorrowedBufferInner::IoUring(inner) => inner.deref_mut(),
119            BorrowedBufferInner::Poll(inner) => inner.deref_mut(),
120        }
121    }
122}
123
124impl AsRef<[u8]> for BorrowedBuffer<'_> {
125    fn as_ref(&self) -> &[u8] {
126        self.deref()
127    }
128}
129
130impl AsMut<[u8]> for BorrowedBuffer<'_> {
131    fn as_mut(&mut self) -> &mut [u8] {
132        self.deref_mut()
133    }
134}
135
136impl Borrow<[u8]> for BorrowedBuffer<'_> {
137    fn borrow(&self) -> &[u8] {
138        self.deref()
139    }
140}
141
142impl BorrowMut<[u8]> for BorrowedBuffer<'_> {
143    fn borrow_mut(&mut self) -> &mut [u8] {
144        self.deref_mut()
145    }
146}