dope-net 0.46.0

Owned network transports for dope
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

use dope_core::io::{socket::msg, transfer};
use o3::buffer::raw::Chunks as _;

use crate::wire::send::{self, Either, Payload, sources::plain::Slice};

/// Retains the original message's lifetime, descriptor bound and exact byte sum.
pub struct Vectored<'a, const N: usize = { msg::MAX_IOVECS }> {
    message: msg::Vectored<'a, N>,
}

impl<'a, const N: usize> Vectored<'a, N> {
    pub(in crate::wire::send) fn chunks(&self) -> msg::raw::Cursor<'a> {
        self.message.chunks()
    }

    /// Wraps a message whose descriptors already retain their source owners.
    pub fn from_message(msg: msg::Vectored<'a, N>) -> Self {
        Self { message: msg }
    }

    #[must_use]
    /// Returns whether descriptors, including zero-length ones, contain no bytes.
    pub fn is_empty(&self) -> bool {
        self.message.is_empty()
    }

    #[must_use]
    /// Returns the exact payload length cached by the retained source.
    pub fn bytes(&self) -> transfer::Len {
        self.message.bytes()
    }
}

pub(in crate::wire::send) struct Vectors<'a> {
    pub(in crate::wire::send) message: msg::Message<'a>,
    pub(in crate::wire::send) bytes: transfer::NonZero,
}

impl<'scope, 'bytes: 'scope, const N: usize> Payload<'scope> for Vectored<'bytes, N> {
    fn select(&self) -> Option<impl send::raw::Ready<'scope>> {
        let bytes = transfer::NonZero::try_from(self.message.bytes()).ok()?;
        Some(match self.message.contiguous() {
            Some(view) => Either::Left(Slice { view, bytes }),
            None => Either::Right(Vectors {
                message: self.message.message(),
                bytes,
            }),
        })
    }
}