SYMBOL INDEX (367 symbols across 50 files)

FILE: examples/copy-file.rs
  function main (line 6) | fn main() {

FILE: examples/echo-client.rs
  function main (line 8) | fn main() {

FILE: examples/echo-server.rs
  function main (line 7) | fn main() {

FILE: examples/read-event.rs
  function main (line 6) | fn main() -> io::Result<()> {

FILE: src/buf.rs
  type Buffer (line 10) | pub struct Buffer {
    method buffered_from_read (line 17) | pub fn buffered_from_read(&self) -> &[u8] {
    method fill_buf (line 21) | pub fn fill_buf(&mut self, fill: impl FnOnce(&mut [u8]) -> Poll<io::Re...
    method consume (line 37) | pub fn consume(&mut self, amt: usize) {
    method clear (line 41) | pub fn clear(&mut self) {
    method into_boxed_slice (line 46) | pub fn into_boxed_slice(self) -> Option<Box<[u8]>> {
    method cancellation (line 50) | pub fn cancellation(&mut self) -> Cancellation {

FILE: src/drive/demo.rs
  constant ENTRIES (line 15) | const ENTRIES: u32   = 32;
  type Queues (line 21) | type Queues = (
  type DemoDriver (line 31) | pub struct DemoDriver {
    method poll_submit_inner (line 36) | fn poll_submit_inner(&mut self, ctx: &mut Context<'_>, sq: &mut Submis...
  method default (line 60) | fn default() -> Self {
  method clone (line 66) | fn clone(&self) -> DemoDriver {
  method poll_prepare (line 72) | fn poll_prepare<'cx>(
  method poll_submit (line 89) | fn poll_submit(
  function driver (line 98) | pub fn driver() -> DemoDriver {
  function registrar (line 108) | pub fn registrar() -> Option<&'static Registrar<'static>> {
  function init (line 117) | fn init() -> Queues {
  function start_completion_thread (line 128) | fn start_completion_thread() {

FILE: src/drive/mod.rs
  type Completion (line 20) | pub struct Completion<'cx> {
  function new (line 26) | pub(crate) fn new(mut sqe: SQE<'_>, _sqes: SQEs<'_>, cx: &mut Context<'c...
  type Drive (line 41) | pub trait Drive {
    method poll_prepare (line 55) | fn poll_prepare<'cx>(
    method poll_submit (line 76) | fn poll_submit(
    method submit (line 81) | fn submit<E: Event>(self, event: E) -> Submission<E, Self> where Self:...

FILE: src/event/accept.rs
  type Accept (line 9) | pub struct Accept<FD = RawFd> {
  method sqes_needed (line 16) | fn sqes_needed(&self) -> u32 { 1 }
  method prepare (line 18) | unsafe fn prepare<'sq>(&mut self, sqs: &mut SQEs<'sq>) -> SQE<'sq> {
  method cancel (line 24) | fn cancel(this: ManuallyDrop<Self>) -> Cancellation {

FILE: src/event/close.rs
  type Close (line 7) | pub struct Close<FD = RawFd> {
  method sqes_needed (line 12) | fn sqes_needed(&self) -> u32 { 1 }
  method prepare (line 14) | unsafe fn prepare<'sq>(&mut self, sqs: &mut SQEs<'sq>) -> SQE<'sq> {

FILE: src/event/connect.rs
  type Connect (line 9) | pub struct Connect<FD = RawFd> {
  method sqes_needed (line 15) | fn sqes_needed(&self) -> u32 { 1 }
  method prepare (line 17) | unsafe fn prepare<'sq>(&mut self, sqs: &mut SQEs<'sq>) -> SQE<'sq> {
  method cancel (line 23) | fn cancel(this: ManuallyDrop<Self>) -> Cancellation {

FILE: src/event/epoll_ctl.rs
  type EpollCtl (line 8) | pub struct EpollCtl {
  method sqes_needed (line 16) | fn sqes_needed(&self) -> u32 { 1 }
  method prepare (line 18) | unsafe fn prepare<'sq>(&mut self, sqs: &mut SQEs<'sq>) -> SQE<'sq> {
  method cancel (line 24) | fn cancel(this: ManuallyDrop<Self>) -> Cancellation {

FILE: src/event/fadvise.rs
  type Fadvise (line 8) | pub struct Fadvise<FD = RawFd> {
  method sqes_needed (line 16) | fn sqes_needed(&self) -> u32 { 1 }
  method prepare (line 18) | unsafe fn prepare<'sq>(&mut self, sqs: &mut SQEs<'sq>) -> SQE<'sq> {

FILE: src/event/fallocate.rs
  type Fallocate (line 8) | pub struct Fallocate<FD = RawFd> {
  method sqes_needed (line 16) | fn sqes_needed(&self) -> u32 { 1 }
  method prepare (line 18) | unsafe fn prepare<'sq>(&mut self, sqs: &mut SQEs<'sq>) -> SQE<'sq> {

FILE: src/event/files_update.rs
  type FilesUpdate (line 6) | pub struct FilesUpdate {
  method sqes_needed (line 12) | fn sqes_needed(&self) -> u32 { 1 }
  method prepare (line 14) | unsafe fn prepare<'sq>(&mut self, sqs: &mut SQEs<'sq>) -> SQE<'sq> {
  method cancel (line 20) | fn cancel(this: ManuallyDrop<Self>) -> Cancellation {

FILE: src/event/fsync.rs
  type Fsync (line 8) | pub struct Fsync<FD = RawFd> {
  method sqes_needed (line 14) | fn sqes_needed(&self) -> u32 { 1 }
  method prepare (line 16) | unsafe fn prepare<'sq>(&mut self, sqs: &mut SQEs<'sq>) -> SQE<'sq> {

FILE: src/event/mod.rs
  type Event (line 60) | pub trait Event {
    method sqes_needed (line 61) | fn sqes_needed(&self) -> u32;
    method prepare (line 79) | unsafe fn prepare<'a>(&mut self, sqs: &mut SQEs<'a>) -> SQE<'a>;
    method cancel (line 86) | fn cancel(_: ManuallyDrop<Self>) -> Cancellation where Self: Sized {

FILE: src/event/openat.rs
  type OpenAt (line 11) | pub struct OpenAt {
    method without_dir (line 19) | pub fn without_dir(path: impl AsRef<Path>, flags: OFlag, mode: Mode) -...
  method sqes_needed (line 26) | fn sqes_needed(&self) -> u32 { 1 }
  method prepare (line 28) | unsafe fn prepare<'sq>(&mut self, sqs: &mut SQEs<'sq>) -> SQE<'sq> {
  method cancel (line 34) | fn cancel(this: ManuallyDrop<Self>) -> Cancellation {

FILE: src/event/provide_buffers.rs
  type ProvideBuffers (line 6) | pub struct ProvideBuffers {
  method sqes_needed (line 14) | fn sqes_needed(&self) -> u32 { 1 }
  method prepare (line 16) | unsafe fn prepare<'sq>(&mut self, sqs: &mut SQEs<'sq>) -> SQE<'sq> {
  method cancel (line 22) | fn cancel(this: ManuallyDrop<Self>) -> Cancellation {
  type RemoveBuffers (line 27) | pub struct RemoveBuffers {
  method sqes_needed (line 33) | fn sqes_needed(&self) -> u32 { 1 }
  method prepare (line 35) | unsafe fn prepare<'sq>(&mut self, sqs: &mut SQEs<'sq>) -> SQE<'sq> {

FILE: src/event/read.rs
  type Read (line 9) | pub struct Read<FD = RawFd> {
  method sqes_needed (line 16) | fn sqes_needed(&self) -> u32 { 1 }
  method prepare (line 18) | unsafe fn prepare<'sq>(&mut self, sqs: &mut SQEs<'sq>) -> SQE<'sq> {
  method cancel (line 24) | fn cancel(this: ManuallyDrop<Self>) -> Cancellation {
  type ReadFixed (line 29) | pub struct ReadFixed<FD = RawFd> {
  method sqes_needed (line 36) | fn sqes_needed(&self) -> u32 { 1 }
  method prepare (line 38) | unsafe fn prepare<'sq>(&mut self, sqs: &mut SQEs<'sq>) -> SQE<'sq> {
  method cancel (line 44) | fn cancel(this: ManuallyDrop<Self>) -> Cancellation {

FILE: src/event/readv.rs
  type ReadVectored (line 10) | pub struct ReadVectored<FD = RawFd> {
  function as_iovecs (line 17) | fn as_iovecs(buffers: &mut [Box<[u8]>]) -> &mut [IoSliceMut] {
  method sqes_needed (line 37) | fn sqes_needed(&self) -> u32 { 1 }
  method prepare (line 39) | unsafe fn prepare<'sq>(&mut self, sqs: &mut SQEs<'sq>) -> SQE<'sq> {
  method cancel (line 45) | fn cancel(this: ManuallyDrop<Self>) -> Cancellation {

FILE: src/event/recv.rs
  type Recv (line 9) | pub struct Recv<FD = RawFd> {
  method sqes_needed (line 16) | fn sqes_needed(&self) -> u32 { 1 }
  method prepare (line 18) | unsafe fn prepare<'sq>(&mut self, sqs: &mut SQEs<'sq>) -> SQE<'sq> {
  method cancel (line 24) | fn cancel(this: ManuallyDrop<Self>) -> Cancellation {

FILE: src/event/send.rs
  type Send (line 9) | pub struct Send<FD = RawFd> {
  method sqes_needed (line 16) | fn sqes_needed(&self) -> u32 { 1 }
  method prepare (line 18) | unsafe fn prepare<'sq>(&mut self, sqs: &mut SQEs<'sq>) -> SQE<'sq> {
  method cancel (line 24) | fn cancel(this: ManuallyDrop<Self>) -> Cancellation {

FILE: src/event/splice.rs
  type Splice (line 7) | pub struct Splice {
  method sqes_needed (line 17) | fn sqes_needed(&self) -> u32 { 1 }
  method prepare (line 19) | unsafe fn prepare<'sq>(&mut self, sqs: &mut SQEs<'sq>) -> SQE<'sq> {

FILE: src/event/statx.rs
  type Statx (line 12) | pub struct Statx<FD = RawFd> {
    method without_dir (line 21) | pub fn without_dir(path: impl AsRef<Path>, flags: StatxFlags, mask: St...
  function without_path (line 29) | pub fn without_path(fd: FD, mut flags: StatxFlags, mask: StatxMode) -> S...
  method sqes_needed (line 41) | fn sqes_needed(&self) -> u32 { 1 }
  method prepare (line 43) | unsafe fn prepare<'sq>(&mut self, sqs: &mut SQEs<'sq>) -> SQE<'sq> {
  method cancel (line 49) | fn cancel(this: ManuallyDrop<Self>) -> Cancellation {

FILE: src/event/timeout.rs
  type StaticTimeout (line 8) | pub struct StaticTimeout {
    method new (line 15) | pub const fn new(duration: Duration, events: u32, flags: TimeoutFlags)...
  method sqes_needed (line 24) | fn sqes_needed(&self) -> u32 { 1 }
  method prepare (line 26) | unsafe fn prepare<'sq>(&mut self, sqs: &mut SQEs<'sq>) -> SQE<'sq> {
  type Timeout (line 33) | pub struct Timeout {
    method new (line 40) | pub fn new(duration: Duration, events: u32, flags: TimeoutFlags) -> Ti...
  method sqes_needed (line 49) | fn sqes_needed(&self) -> u32 { 1 }
  method prepare (line 51) | unsafe fn prepare<'sq>(&mut self, sqs: &mut SQEs<'sq>) -> SQE<'sq> {
  method cancel (line 57) | fn cancel(this: ManuallyDrop<Self>) -> Cancellation {
  function timespec (line 62) | const fn timespec(duration: Duration) -> uring_sys::__kernel_timespec {

FILE: src/event/write.rs
  type Write (line 9) | pub struct Write<FD = RawFd> {
  method sqes_needed (line 16) | fn sqes_needed(&self) -> u32 { 1 }
  method prepare (line 18) | unsafe fn prepare<'sq>(&mut self, sqs: &mut SQEs<'sq>) -> SQE<'sq> {
  method cancel (line 24) | fn cancel(this: ManuallyDrop<Self>) -> Cancellation {
  type WriteFixed (line 29) | pub struct WriteFixed<FD = RawFd> {
  method sqes_needed (line 36) | fn sqes_needed(&self) -> u32 { 1 }
  method prepare (line 38) | unsafe fn prepare<'sq>(&mut self, sqs: &mut SQEs<'sq>) -> SQE<'sq> {
  method cancel (line 44) | fn cancel(this: ManuallyDrop<Self>) -> Cancellation {

FILE: src/event/writev.rs
  type WriteVectored (line 10) | pub struct WriteVectored<FD = RawFd> {
  function iovecs (line 17) | fn iovecs(&self) -> &[IoSlice] {
  method sqes_needed (line 23) | fn sqes_needed(&self) -> u32 { 1 }
  method prepare (line 25) | unsafe fn prepare<'sq>(&mut self, sqs: &mut SQEs<'sq>) -> SQE<'sq> {
  method cancel (line 31) | fn cancel(this: ManuallyDrop<Self>) -> Cancellation {

FILE: src/fs.rs
  type FileBuf (line 24) | type FileBuf = Either<Buffer, Box<libc::statx>>;
  type File (line 27) | pub struct File<D: Drive = DemoDriver> {
    method open (line 47) | pub fn open(path: impl AsRef<Path>) -> Open {
    method create (line 52) | pub fn create(path: impl AsRef<Path>) -> Create {
    method from (line 295) | fn from(file: fs::File) -> File {
  type Op (line 36) | enum Op {
  function open_on_driver (line 59) | pub fn open_on_driver(path: impl AsRef<Path>, driver: D) -> Open<D> {
  function create_on_driver (line 65) | pub fn create_on_driver(path: impl AsRef<Path>, driver: D) -> Create<D> {
  function run_on_driver (line 73) | pub fn run_on_driver(file: fs::File, driver: D) -> File<D> {
  function from_fd (line 78) | fn from_fd(fd: RawFd, driver: D) -> File<D> {
  function read_buffered (line 93) | pub fn read_buffered(&self) -> &[u8] {
  function guard_op (line 99) | fn guard_op(self: Pin<&mut Self>, op: Op) {
  function cancel (line 110) | fn cancel(&mut self) {
  function poll_file_size (line 116) | fn poll_file_size(mut self: Pin<&mut Self>, ctx: &mut Context<'_>) -> Po...
  function split (line 136) | fn split(self: Pin<&mut Self>) -> (Pin<&mut Ring<D>>, &mut FileBuf, &mut...
  function split_with_buf (line 144) | fn split_with_buf(self: Pin<&mut Self>)
  function split_with_statx (line 153) | fn split_with_statx(self: Pin<&mut Self>)
  function ring (line 165) | fn ring(self: Pin<&mut Self>) -> Pin<&mut Ring<D>> {
  function buf (line 170) | fn buf(self: Pin<&mut Self>) -> &mut Buffer {
  function pos (line 175) | fn pos(self: Pin<&mut Self>) -> &mut u64 {
  function confirm_close (line 179) | fn confirm_close(self: Pin<&mut Self>) {
  method poll_read (line 185) | fn poll_read(mut self: Pin<&mut Self>, ctx: &mut Context<'_>, buf: &mut ...
  method poll_fill_buf (line 196) | fn poll_fill_buf(mut self: Pin<&mut Self>, ctx: &mut Context<'_>) -> Pol...
  method consume (line 213) | fn consume(self: Pin<&mut Self>, amt: usize) {
  method poll_write (line 219) | fn poll_write(mut self: Pin<&mut Self>, ctx: &mut Context<'_>, slice: &[...
  method poll_flush (line 238) | fn poll_flush(self: Pin<&mut Self>, ctx: &mut Context<'_>) -> Poll<io::R...
  method poll_close (line 243) | fn poll_close(mut self: Pin<&mut Self>, ctx: &mut Context<'_>) -> Poll<i...
  method poll_seek (line 259) | fn poll_seek(mut self: Pin<&mut Self>, ctx: &mut Context, pos: io::SeekF...
  function from (line 301) | fn from(mut file: File<D>) -> fs::File {
  method drop (line 311) | fn drop(&mut self) {
  type Open (line 321) | pub struct Open<D: Drive = DemoDriver>(Submission<OpenAt, D>);
  function inner (line 324) | fn inner(self: Pin<&mut Self>) -> Pin<&mut Submission<OpenAt, D>> {
  type Output (line 330) | type Output = io::Result<File<D>>;
  method poll (line 332) | fn poll(self: Pin<&mut Self>, ctx: &mut Context<'_>) -> Poll<io::Result<...
  type Create (line 342) | pub struct Create<D: Drive = DemoDriver>(Submission<OpenAt, D>);
  function inner (line 345) | fn inner(self: Pin<&mut Self>) -> Pin<&mut Submission<OpenAt, D>> {
  type Output (line 351) | type Output = io::Result<File<D>>;
  method poll (line 353) | fn poll(self: Pin<&mut Self>, ctx: &mut Context<'_>) -> Poll<io::Result<...

FILE: src/io.rs
  function __print (line 52) | pub async fn __print<D: Drive>(driver: D, bytes: impl Into<Cow<'static, ...
  function __eprint (line 62) | pub async fn __eprint<D: Drive>(driver: D, bytes: impl Into<Cow<'static,...
  type Print (line 71) | struct Print<D: Drive> {
  function split (line 79) | fn split(self: Pin<&mut Self>) -> (Pin<&mut Ring<D>>, RawFd, &[u8], &mut...
  type Output (line 89) | type Output = io::Result<()>;
  method poll (line 91) | fn poll(self: Pin<&mut Self>, ctx: &mut Context<'_>) -> Poll<Self::Outpu...
  type Stdout (line 114) | pub struct Stdout<D: Drive> {
  function stdout (line 131) | pub fn stdout() -> Stdout<DemoDriver> {
  function stdout_on_driver (line 136) | pub fn stdout_on_driver<D: Drive>(driver: D) -> Stdout<D> {
  function split (line 145) | fn split(self: Pin<&mut Self>) -> (Pin<&mut Ring<D>>, &mut Buffer) {
  method poll_write (line 154) | fn poll_write(self: Pin<&mut Self>, ctx: &mut Context<'_>, slice: &[u8])
  method poll_flush (line 173) | fn poll_flush(self: Pin<&mut Self>, ctx: &mut Context<'_>) -> Poll<io::R...
  method poll_close (line 178) | fn poll_close(self: Pin<&mut Self>, ctx: &mut Context<'_>) -> Poll<io::R...
  method as_raw_fd (line 184) | fn as_raw_fd(&self) -> RawFd {

FILE: src/net/listener.rs
  type TcpListener (line 17) | pub struct TcpListener<D: Drive = DemoDriver> {
    method bind (line 33) | pub fn bind<A: ToSocketAddrs>(addr: A) -> io::Result<TcpListener> {
  type Op (line 25) | enum Op {
  function bind_on_driver (line 39) | pub fn bind_on_driver<A: ToSocketAddrs>(addr: A, driver: D) -> io::Resul...
  function close (line 54) | pub fn close(&mut self) -> Close<D> where D: Unpin {
  function close_pinned (line 58) | pub fn close_pinned(self: Pin<&mut Self>) -> Close<D> {
  function guard_op (line 62) | fn guard_op(self: Pin<&mut Self>, op: Op) {
  function cancel (line 72) | fn cancel(&mut self) {
  function drop_addr (line 83) | fn drop_addr(self: Pin<&mut Self>) {
  function ring (line 87) | fn ring(self: Pin<&mut Self>) -> Pin<&mut Ring<D>> {
  function split (line 91) | fn split(self: Pin<&mut Self>)
  function split_with_addr (line 100) | fn split_with_addr(self: Pin<&mut Self>)
  function confirm_close (line 110) | fn confirm_close(self: Pin<&mut Self>) {
  function accept (line 116) | pub fn accept(&mut self) -> Accept<'_, D> where D: Unpin {
  function accept_pinned (line 120) | pub fn accept_pinned(self: Pin<&mut Self>) -> Accept<'_, D> {
  function incoming (line 124) | pub fn incoming(&mut self) -> Incoming<'_, D> where D: Unpin {
  function incoming_pinned (line 128) | pub fn incoming_pinned(self: Pin<&mut Self>) -> Incoming<'_, D> {
  function accept_no_addr (line 132) | pub fn accept_no_addr(&mut self) -> AcceptNoAddr<'_, D> where D: Unpin {
  function accept_no_addr_pinned (line 136) | pub fn accept_no_addr_pinned(self: Pin<&mut Self>) -> AcceptNoAddr<'_, D> {
  function incoming_no_addr (line 140) | pub fn incoming_no_addr(&mut self) -> IncomingNoAddr<'_, D> where D: Unp...
  function incoming_no_addr_pinned (line 144) | pub fn incoming_no_addr_pinned(self: Pin<&mut Self>) -> IncomingNoAddr<'...
  function poll_accept (line 148) | pub fn poll_accept(mut self: Pin<&mut Self>, ctx: &mut Context<'_>)
  function poll_accept_no_addr (line 173) | pub fn poll_accept_no_addr(mut self: Pin<&mut Self>, ctx: &mut Context<'_>)
  method drop (line 190) | fn drop(&mut self) {
  type Accept (line 199) | pub struct Accept<'a, D: Drive> {
  type Output (line 204) | type Output = io::Result<(TcpStream<D>, SocketAddr)>;
  method poll (line 206) | fn poll(mut self: Pin<&mut Self>, ctx: &mut Context<'_>) -> Poll<Self::O...
  type AcceptNoAddr (line 211) | pub struct AcceptNoAddr<'a, D: Drive> {
  type Output (line 216) | type Output = io::Result<TcpStream<D>>;
  method poll (line 218) | fn poll(mut self: Pin<&mut Self>, ctx: &mut Context<'_>) -> Poll<Self::O...
  type Incoming (line 223) | pub struct Incoming<'a, D: Drive> {
  function inner (line 228) | fn inner(self: Pin<&mut Self>) -> Pin<&mut Accept<'a, D>> {
  type Item (line 234) | type Item = io::Result<(TcpStream<D>, SocketAddr)>;
  method poll_next (line 236) | fn poll_next(self: Pin<&mut Self>, ctx: &mut Context<'_>) -> Poll<Option...
  type IncomingNoAddr (line 242) | pub struct IncomingNoAddr<'a, D: Drive> {
  function inner (line 247) | fn inner(self: Pin<&mut Self>) -> Pin<&mut AcceptNoAddr<'a, D>> {
  type Item (line 253) | type Item = io::Result<TcpStream<D>>;
  method poll_next (line 255) | fn poll_next(self: Pin<&mut Self>, ctx: &mut Context<'_>) -> Poll<Option...
  type Close (line 261) | pub struct Close<'a, D: Drive> {
  type Output (line 266) | type Output = io::Result<()>;
  method poll (line 268) | fn poll(mut self: Pin<&mut Self>, ctx: &mut Context<'_>) -> Poll<io::Res...

FILE: src/net/mod.rs
  function socket (line 13) | fn socket<A: ToSocketAddrs>(addr: A, protocol: nix::SockProtocol) -> io:...

FILE: src/net/stream.rs
  type TcpStream (line 21) | pub struct TcpStream<D: Drive = DemoDriver> {
    method connect (line 38) | pub fn connect<A: ToSocketAddrs>(addr: A) -> Connect {
  type Op (line 29) | enum Op {
  function connect_on_driver (line 44) | pub fn connect_on_driver<A: ToSocketAddrs>(addr: A, driver: D) -> Connec...
  function from_fd (line 55) | pub(crate) fn from_fd(fd: RawFd, ring: Ring<D>) -> TcpStream<D> {
  function guard_op (line 63) | fn guard_op(self: Pin<&mut Self>, op: Op) {
  function cancel (line 73) | fn cancel(&mut self) {
  function ring (line 79) | fn ring(self: Pin<&mut Self>) -> Pin<&mut Ring<D>> {
  function buf (line 84) | fn buf(self: Pin<&mut Self>) -> &mut Buffer {
  function split (line 89) | fn split(self: Pin<&mut Self>) -> (Pin<&mut Ring<D>>, &mut Buffer, &mut ...
  function confirm_close (line 96) | fn confirm_close(self: Pin<&mut Self>) {
  type Connect (line 101) | pub struct Connect<D: Drive = DemoDriver>(
  type Output (line 106) | type Output = io::Result<TcpStream<D>>;
  method poll (line 108) | fn poll(self: Pin<&mut Self>, ctx: &mut Context<'_>) -> Poll<Self::Outpu...
  function project (line 125) | fn project(self: Pin<&mut Self>)
  method poll_read (line 138) | fn poll_read(mut self: Pin<&mut Self>, ctx: &mut Context<'_>, buf: &mut ...
  method poll_fill_buf (line 149) | fn poll_fill_buf(mut self: Pin<&mut Self>, ctx: &mut Context<'_>) -> Pol...
  method consume (line 165) | fn consume(self: Pin<&mut Self>, amt: usize) {
  method poll_write (line 171) | fn poll_write(mut self: Pin<&mut Self>, ctx: &mut Context<'_>, slice: &[...
  method poll_flush (line 189) | fn poll_flush(self: Pin<&mut Self>, ctx: &mut Context<'_>) -> Poll<io::R...
  method poll_close (line 194) | fn poll_close(mut self: Pin<&mut Self>, ctx: &mut Context<'_>) -> Poll<i...
  method drop (line 210) | fn drop(&mut self) {

FILE: src/ring/cancellation.rs
  type Cancellation (line 16) | pub struct Cancellation {
    method new (line 114) | fn new<T: Cancel>(object: T) -> Cancellation {
    method from (line 121) | fn from(object: T) -> Cancellation {
    method from (line 127) | fn from(object: Option<T>) -> Cancellation {
    method from (line 133) | fn from(buffer: Buffer) -> Cancellation {
    method from (line 139) | fn from(object: Either<T, U>) -> Cancellation {
  type Cancel (line 22) | pub unsafe trait Cancel {
    method into_raw (line 23) | fn into_raw(self) -> (*mut (), usize);
    method drop_raw (line 24) | unsafe fn drop_raw(data: *mut (), metadata: usize);
    method into_raw (line 28) | fn into_raw(self) -> (*mut (), usize) {
    method drop_raw (line 32) | unsafe fn drop_raw(data: *mut (), _: usize) {
    method into_raw (line 38) | fn into_raw(self) -> (*mut (), usize) {
    method drop_raw (line 43) | unsafe fn drop_raw(data: *mut (), len: usize) {
    method into_raw (line 55) | fn into_raw(self) -> (*mut (), usize) {
    method drop_raw (line 60) | unsafe fn drop_raw(data: *mut (), metadata: usize) {
    method into_raw (line 67) | fn into_raw(self) -> (*mut (), usize) {
    method drop_raw (line 71) | unsafe fn drop_raw(data: *mut (), metadata: usize) {
    method into_raw (line 77) | fn into_raw(self) -> (*mut (), usize) {
    method drop_raw (line 81) | unsafe fn drop_raw(data: *mut (), _: usize) {
    method into_raw (line 87) | fn into_raw(self) -> (*mut (), usize) {
    method drop_raw (line 91) | unsafe fn drop_raw(_: *mut (), _: usize) { }
    method into_raw (line 100) | fn into_raw(self) -> (*mut (), usize) {
    method drop_raw (line 106) | unsafe fn drop_raw(data: *mut (), metadata: usize) {
  type TraitObject (line 49) | struct TraitObject {
  type CancelNarrow (line 94) | pub unsafe trait CancelNarrow: Cancel { }
  method drop (line 148) | fn drop(&mut self) {

FILE: src/ring/completion.rs
  type Completion (line 23) | pub struct Completion {
    method new (line 37) | pub fn new(waker: Waker) -> Completion {
    method addr (line 45) | pub fn addr(&self) -> u64 {
    method check (line 52) | pub fn check(self, waker: &Waker) -> Result<io::Result<u32>, Completio...
    method cancel (line 72) | pub fn cancel(self, callback: Cancellation) {
    method complete (line 88) | fn complete(self, result: io::Result<u32>) {
  type State (line 27) | enum State {
  function complete (line 105) | pub fn complete(cqe: CQE) {

FILE: src/ring/mod.rs
  type Ring (line 31) | pub struct Ring<D: Drive> {
  type State (line 36) | enum State {
    method cancel (line 204) | fn cancel(&mut self, cancellation: Cancellation) {
  method default (line 46) | fn default() -> Ring<D> {
  method clone (line 52) | fn clone(&self) -> Ring<D> {
  function new (line 60) | pub fn new(driver: D) -> Ring<D> {
  function driver (line 67) | pub fn driver(&self) -> &D {
  function poll (line 78) | pub fn poll(
  function poll_prepare (line 105) | fn poll_prepare(
  function poll_submit (line 135) | fn poll_submit(self: Pin<&mut Self>, ctx: &mut Context<'_>) -> Poll<()> {
  function poll_complete (line 148) | fn poll_complete(self: Pin<&mut Self>, ctx: &mut Context<'_>) -> Poll<io...
  function cancel (line 184) | pub fn cancel(&mut self, cancellation: Cancellation) {
  function cancel_pinned (line 191) | pub fn cancel_pinned(self: Pin<&mut Self>, cancellation: Cancellation) {
  function split (line 195) | fn split(self: Pin<&mut Self>) -> (Pin<&mut D>, &mut State) {

FILE: src/submission.rs
  type Submission (line 12) | pub struct Submission<E: Event, D: Drive> {
  function new (line 19) | pub fn new(event: E, driver: D) -> Submission<E, D> {
  function driver (line 27) | pub fn driver(&self) -> &D {
  function replace_event (line 31) | pub fn replace_event(self: Pin<&mut Self>, event: E) {
  function split (line 39) | fn split(self: Pin<&mut Self>) -> (Pin<&mut Ring<D>>, &mut Option<E>) {
  type Output (line 51) | type Output = (E, io::Result<u32>);
  method poll (line 53) | fn poll(self: Pin<&mut Self>, ctx: &mut Context<'_>) -> Poll<Self::Outpu...
  method drop (line 69) | fn drop(&mut self) {

FILE: src/unix/listener.rs
  type UnixListener (line 16) | pub struct UnixListener<D: Drive = DemoDriver> {
    method bind (line 31) | pub fn bind(path: impl AsRef<Path>) -> io::Result<UnixListener> {
  type Op (line 23) | enum Op {
  function bind_on_driver (line 37) | pub fn bind_on_driver(path: impl AsRef<Path>, driver: D) -> io::Result<U...
  function close (line 49) | pub fn close(&mut self) -> Close<D> where D: Unpin {
  function close_pinned (line 53) | pub fn close_pinned(self: Pin<&mut Self>) -> Close<D> {
  function guard_op (line 57) | fn guard_op(self: Pin<&mut Self>, op: Op) {
  function cancel (line 68) | fn cancel(&mut self) {
  function ring (line 75) | fn ring(self: Pin<&mut Self>) -> Pin<&mut Ring<D>> {
  function confirm_close (line 79) | fn confirm_close(self: Pin<&mut Self>) {
  function accept (line 85) | pub fn accept(&mut self) -> Accept<'_, D> where D: Unpin {
  function accept_pinned (line 89) | pub fn accept_pinned(self: Pin<&mut Self>) -> Accept<'_, D> {
  function incoming (line 93) | pub fn incoming(&mut self) -> Incoming<'_, D> where D: Unpin {
  function incoming_pinned (line 97) | pub fn incoming_pinned(self: Pin<&mut Self>) -> Incoming<'_, D> {
  function poll_accept (line 101) | pub fn poll_accept(mut self: Pin<&mut Self>, ctx: &mut Context<'_>)
  method drop (line 117) | fn drop(&mut self) {
  type Accept (line 126) | pub struct Accept<'a, D: Drive> {
  type Output (line 131) | type Output = io::Result<UnixStream<D>>;
  method poll (line 133) | fn poll(mut self: Pin<&mut Self>, ctx: &mut Context<'_>) -> Poll<Self::O...
  type Incoming (line 138) | pub struct Incoming<'a, D: Drive> {
  function inner (line 143) | fn inner(self: Pin<&mut Self>) -> Pin<&mut Accept<'a, D>> {
  type Item (line 149) | type Item = io::Result<UnixStream<D>>;
  method poll_next (line 151) | fn poll_next(self: Pin<&mut Self>, ctx: &mut Context<'_>) -> Poll<Option...
  type Close (line 158) | pub struct Close<'a, D: Drive> {
  type Output (line 163) | type Output = io::Result<()>;
  method poll (line 165) | fn poll(mut self: Pin<&mut Self>, ctx: &mut Context<'_>) -> Poll<io::Res...

FILE: src/unix/mod.rs
  function socket (line 12) | fn socket() -> io::Result<RawFd> {
  function socketpair (line 19) | fn socketpair() -> io::Result<(RawFd, RawFd)> {

FILE: src/unix/stream.rs
  type UnixStream (line 22) | pub struct UnixStream<D: Drive = DemoDriver> {
    method connect (line 27) | pub fn connect(path: &impl AsRef<Path>) -> Connect {
    method pair (line 31) | pub fn pair() -> io::Result<(UnixStream, UnixStream)> {
  function connect_on_driver (line 37) | pub fn connect_on_driver(path: &impl AsRef<Path>, driver: D) -> Connect<...
  function pair_on_driver (line 46) | pub fn pair_on_driver(driver: D) -> io::Result<(UnixStream<D>, UnixStrea...
  function from_fd (line 55) | pub(super) fn from_fd(fd: RawFd, ring: Ring<D>) -> UnixStream<D> {
  function inner (line 62) | fn inner(self: Pin<&mut Self>) -> Pin<&mut TcpStream<D>> {
  type Connect (line 67) | pub struct Connect<D: Drive = DemoDriver>(
  type Output (line 72) | type Output = io::Result<UnixStream<D>>;
  method poll (line 74) | fn poll(self: Pin<&mut Self>, ctx: &mut Context<'_>) -> Poll<Self::Outpu...
  method poll_read (line 94) | fn poll_read(self: Pin<&mut Self>, ctx: &mut Context<'_>, buf: &mut [u8])
  method poll_fill_buf (line 102) | fn poll_fill_buf(self: Pin<&mut Self>, ctx: &mut Context<'_>) -> Poll<io...
  method consume (line 106) | fn consume(self: Pin<&mut Self>, amt: usize) {
  method poll_write (line 112) | fn poll_write(self: Pin<&mut Self>, ctx: &mut Context<'_>, slice: &[u8])...
  method poll_flush (line 116) | fn poll_flush(self: Pin<&mut Self>, ctx: &mut Context<'_>) -> Poll<io::R...
  method poll_close (line 120) | fn poll_close(self: Pin<&mut Self>, ctx: &mut Context<'_>) -> Poll<io::R...

FILE: tests/basic-read.rs
  constant ASSERT (line 8) | const ASSERT: &[u8] = b"But this formidable power of death -";
  function read_file (line 11) | fn read_file() {

FILE: tests/basic-readv.rs
  constant ASSERT (line 8) | const ASSERT: &[u8] = b"But this formidable power of death -";
  function readv_file (line 11) | fn readv_file() {

FILE: tests/basic-write.rs
  constant ASSERT (line 8) | const ASSERT: &[u8] = b"But this formidable power of death -";
  function write_file (line 11) | fn write_file() {

FILE: tests/basic-writev.rs
  constant ASSERT (line 8) | const ASSERT: &[u8] = b"But this formidable power of death -";
  function writev_file (line 11) | fn writev_file() {

FILE: tests/file-close.rs
  constant ASSERT (line 5) | const ASSERT: &[u8] = b"But this formidable power of death -";
  function read_and_close_file (line 8) | fn read_and_close_file() {

FILE: tests/file-read.rs
  constant ASSERT (line 5) | const ASSERT: &[u8] = b"But this formidable power of death -";
  function read_file (line 8) | fn read_file() {
  function read_to_end (line 18) | fn read_to_end() {

FILE: tests/file-seek.rs
  function seek_to_end (line 7) | fn seek_to_end() {
  function seek_and_then_io (line 15) | fn seek_and_then_io() {

FILE: tests/file-write.rs
  constant ASSERT (line 7) | const ASSERT: &[u8] = b"But this formidable power of death -";
  function write_file (line 10) | fn write_file() {
  function select_complete_many_futures (line 24) | fn select_complete_many_futures() {

FILE: tests/println.rs
  function println (line 4) | fn println() {
  function print (line 11) | fn print() {
  function eprintln (line 18) | fn eprintln() {
  function eprint (line 25) | fn eprint() {

FILE: tests/registered-fd.rs
  function test_registered_fd_ops (line 9) | fn test_registered_fd_ops() {

FILE: tests/stdio.rs
  constant ASSERT (line 5) | const ASSERT: &[u8] = b"Hello, world!\n";
  function write_stdout (line 8) | fn write_stdout() {