Struct rustbus::connection::ll_conn::SendMessageContext [−][src]
#[must_use = "Dropping this type is considered an error since it might leave the connection in an illdefined state if only some bytes of a message have been written"]pub struct SendMessageContext<'a> { /* fields omitted */ }
Handles the process of actually sending a message over the connection it was created from. This allows graceful handling of short writes or timeouts with only parts of the message written. You can loop over write or write_once or use write_all to wait until all bytes have been written or an error besides a timeout arises.
Implementations
impl SendMessageContext<'_>[src]
impl SendMessageContext<'_>[src]pub fn serial(&self) -> u32[src]
pub fn resume<'a>(
conn: &'a mut SendConn,
msg: &'a MarshalledMessage,
progress: SendMessageState
) -> SendMessageContext<'a>[src]
conn: &'a mut SendConn,
msg: &'a MarshalledMessage,
progress: SendMessageState
) -> SendMessageContext<'a>
Resume a SendMessageContext from the progress. This needs to be called with the same conn and msg that were used to create the original SendMessageContext.
pub fn into_progress(self) -> SendMessageState[src]
Turn this into the progress to resume the sending later. Note that you cannot send another message while doing that. You need to resume a SendMessageContext from this progress and send the current message beofre starting the next one.
pub fn force_finish(self)[src]
only call if you deem the connection doomed by an error returned from writing. The connection might be left in an invalid state if some but not all bytes of the message have been written
pub fn write(self, timeout: Timeout) -> Result<u32, (Self, Error)>[src]
Try writing as many bytes as possible until either no more bytes need to be written or the timeout is reached. For an infinite timeout there is write_all as a shortcut
pub fn write_all(self) -> Result<u32, (Self, Error)>[src]
Block until all bytes have been written
pub fn bytes_total(&self) -> usize[src]
How many bytes need to be sent in total
pub fn all_bytes_written(&self) -> bool[src]
Check if all bytes have been written
pub fn write_once(&mut self, timeout: Timeout) -> Result<usize, Error>[src]
Basic routine to do a write to the fd once. Mostly useful if you are using a nonblocking timeout. But even then I would recommend using write() and not write_once()
Trait Implementations
impl Drop for SendMessageContext<'_>[src]
impl Drop for SendMessageContext<'_>[src]This panics if the SendMessageContext was dropped when it was not yet finished. Use force_finish / force_finish_on_error if you want to do this. It will be necessary for handling errors that make the connection unusable.