[−][src]Struct tokio::net::TcpStream
An I/O object representing a TCP stream connected to a remote endpoint.
A TCP stream can either be created by connecting to an endpoint, via the
connect
method, or by accepting a connection from a listener.
Examples
use futures::Future; use tokio::io::AsyncWrite; use tokio::net::TcpStream; use std::net::SocketAddr; let addr = "127.0.0.1:34254".parse::<SocketAddr>()?; let stream = TcpStream::connect(&addr); stream.map(|mut stream| { // Attempt to write bytes asynchronously to the stream stream.poll_write(&[1]); });
Methods
impl TcpStream
[src]
pub fn connect(addr: &SocketAddr) -> ConnectFuture
[src]
Create a new TCP stream connected to the specified address.
This function will create a new TCP socket and attempt to connect it to
the addr
provided. The returned future will be resolved once the
stream has successfully connected, or it will return an error if one
occurs.
Examples
use futures::Future; use tokio::net::TcpStream; use std::net::SocketAddr; let addr = "127.0.0.1:34254".parse::<SocketAddr>()?; let stream = TcpStream::connect(&addr) .map(|stream| println!("successfully connected to {}", stream.local_addr().unwrap()));
pub fn from_std(stream: TcpStream, handle: &Handle) -> Result<TcpStream, Error>
[src]
Create a new TcpStream
from a net::TcpStream
.
This function will convert a TCP stream created by the standard library
to a TCP stream ready to be used with the provided event loop handle.
Use Handle::default()
to lazily bind to an event loop, just like connect
does.
Examples
use tokio::net::TcpStream; use std::net::TcpStream as StdTcpStream; use tokio_reactor::Handle; let std_stream = StdTcpStream::connect("127.0.0.1:34254")?; let stream = TcpStream::from_std(std_stream, &Handle::default())?;
pub fn connect_std(
stream: TcpStream,
addr: &SocketAddr,
handle: &Handle
) -> ConnectFuture
[src]
stream: TcpStream,
addr: &SocketAddr,
handle: &Handle
) -> ConnectFuture
Creates a new TcpStream
from the pending socket inside the given
std::net::TcpStream
, connecting it to the address specified.
This constructor allows configuring the socket before it's actually
connected, and this function will transfer ownership to the returned
TcpStream
if successful. An unconnected TcpStream
can be created
with the net2::TcpBuilder
type (and also configured via that route).
The platform specific behavior of this function looks like:
-
On Unix, the socket is placed into nonblocking mode and then a
connect
call is issued. -
On Windows, the address is stored internally and the connect operation is issued when the returned
TcpStream
is registered with an event loop. Note that on Windows you mustbind
a socket before it can be connected, so if a customTcpBuilder
is used it should be bound (perhaps toINADDR_ANY
) before this method is called.
pub fn poll_read_ready(&self, mask: Ready) -> Result<Async<Ready>, Error>
[src]
Check the TCP stream's read readiness state.
The mask argument allows specifying what readiness to notify on. This
can be any value, including platform specific readiness, except
writable
. HUP is always implicitly included on platforms that support
it.
If the resource is not ready for a read then Async::NotReady
is
returned and the current task is notified once a new event is received.
The stream will remain in a read-ready state until calls to poll_read
return NotReady
.
Panics
This function panics if:
ready
includes writable.- called from outside of a task context.
Examples
use mio::Ready; use futures::Async; use futures::Future; use tokio::net::TcpStream; use std::net::SocketAddr; let addr = "127.0.0.1:34254".parse::<SocketAddr>()?; let stream = TcpStream::connect(&addr); stream.map(|stream| { match stream.poll_read_ready(Ready::readable()) { Ok(Async::Ready(_)) => println!("read ready"), Ok(Async::NotReady) => println!("not read ready"), Err(e) => eprintln!("got error: {}", e), } });
pub fn poll_write_ready(&self) -> Result<Async<Ready>, Error>
[src]
Check the TCP stream's write readiness state.
This always checks for writable readiness and also checks for HUP readiness on platforms that support it.
If the resource is not ready for a write then Async::NotReady
is
returned and the current task is notified once a new event is received.
The I/O resource will remain in a write-ready state until calls to
poll_write
return NotReady
.
Panics
This function panics if called from outside of a task context.
Examples
use futures::Async; use futures::Future; use tokio::net::TcpStream; use std::net::SocketAddr; let addr = "127.0.0.1:34254".parse::<SocketAddr>()?; let stream = TcpStream::connect(&addr); stream.map(|stream| { match stream.poll_write_ready() { Ok(Async::Ready(_)) => println!("write ready"), Ok(Async::NotReady) => println!("not write ready"), Err(e) => eprintln!("got error: {}", e), } });
pub fn local_addr(&self) -> Result<SocketAddr, Error>
[src]
Returns the local address that this stream is bound to.
Examples
use tokio::net::TcpStream; use futures::Future; use std::net::{Ipv4Addr, SocketAddr, SocketAddrV4}; let addr = "127.0.0.1:8080".parse::<SocketAddr>()?; let stream = TcpStream::connect(&addr); stream.map(|stream| { assert_eq!(stream.local_addr().unwrap(), SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::new(127, 0, 0, 1), 8080))); });
pub fn peer_addr(&self) -> Result<SocketAddr, Error>
[src]
Returns the remote address that this stream is connected to.
Examples
use tokio::net::TcpStream; use futures::Future; use std::net::{Ipv4Addr, SocketAddr, SocketAddrV4}; let addr = "127.0.0.1:8080".parse::<SocketAddr>()?; let stream = TcpStream::connect(&addr); stream.map(|stream| { assert_eq!(stream.peer_addr().unwrap(), SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::new(127, 0, 0, 1), 8080))); });
pub fn poll_peek(&mut self, buf: &mut [u8]) -> Result<Async<usize>, Error>
[src]
Receives data on the socket from the remote address to which it is connected, without removing that data from the queue. On success, returns the number of bytes peeked.
Successive calls return the same data. This is accomplished by passing
MSG_PEEK
as a flag to the underlying recv system call.
Return
On success, returns Ok(Async::Ready(num_bytes_read))
.
If no data is available for reading, the method returns
Ok(Async::NotReady)
and arranges for the current task to receive a
notification when the socket becomes readable or is closed.
Panics
This function will panic if called from outside of a task context.
Examples
use tokio::net::TcpStream; use futures::Async; use futures::Future; use std::net::SocketAddr; let addr = "127.0.0.1:8080".parse::<SocketAddr>()?; let stream = TcpStream::connect(&addr); stream.map(|mut stream| { let mut buf = [0; 10]; match stream.poll_peek(&mut buf) { Ok(Async::Ready(len)) => println!("read {} bytes", len), Ok(Async::NotReady) => println!("no data available"), Err(e) => eprintln!("got error: {}", e), } });
pub fn shutdown(&self, how: Shutdown) -> Result<(), Error>
[src]
Shuts down the read, write, or both halves of this connection.
This function will cause all pending and future I/O on the specified
portions to return immediately with an appropriate value (see the
documentation of Shutdown
).
Examples
use tokio::net::TcpStream; use futures::Future; use std::net::{Shutdown, SocketAddr}; let addr = "127.0.0.1:8080".parse::<SocketAddr>()?; let stream = TcpStream::connect(&addr); stream.map(|stream| { stream.shutdown(Shutdown::Both) });
pub fn nodelay(&self) -> Result<bool, Error>
[src]
Gets the value of the TCP_NODELAY
option on this socket.
For more information about this option, see set_nodelay
.
Examples
use tokio::net::TcpStream; use futures::Future; use std::net::SocketAddr; let addr = "127.0.0.1:8080".parse::<SocketAddr>()?; let stream = TcpStream::connect(&addr); stream.map(|stream| { stream.set_nodelay(true).expect("set_nodelay call failed");; assert_eq!(stream.nodelay().unwrap_or(false), true); });
pub fn set_nodelay(&self, nodelay: bool) -> Result<(), Error>
[src]
Sets the value of the TCP_NODELAY
option on this socket.
If set, this option disables the Nagle algorithm. This means that segments are always sent as soon as possible, even if there is only a small amount of data. When not set, data is buffered until there is a sufficient amount to send out, thereby avoiding the frequent sending of small packets.
Examples
use tokio::net::TcpStream; use futures::Future; use std::net::SocketAddr; let addr = "127.0.0.1:8080".parse::<SocketAddr>()?; let stream = TcpStream::connect(&addr); stream.map(|stream| { stream.set_nodelay(true).expect("set_nodelay call failed"); });
pub fn recv_buffer_size(&self) -> Result<usize, Error>
[src]
Gets the value of the SO_RCVBUF
option on this socket.
For more information about this option, see set_recv_buffer_size
.
Examples
use tokio::net::TcpStream; use futures::Future; use std::net::SocketAddr; let addr = "127.0.0.1:8080".parse::<SocketAddr>()?; let stream = TcpStream::connect(&addr); stream.map(|stream| { stream.set_recv_buffer_size(100).expect("set_recv_buffer_size failed"); assert_eq!(stream.recv_buffer_size().unwrap_or(0), 100); });
pub fn set_recv_buffer_size(&self, size: usize) -> Result<(), Error>
[src]
Sets the value of the SO_RCVBUF
option on this socket.
Changes the size of the operating system's receive buffer associated with the socket.
Examples
use tokio::net::TcpStream; use futures::Future; use std::net::SocketAddr; let addr = "127.0.0.1:8080".parse::<SocketAddr>()?; let stream = TcpStream::connect(&addr); stream.map(|stream| { stream.set_recv_buffer_size(100).expect("set_recv_buffer_size failed"); });
pub fn send_buffer_size(&self) -> Result<usize, Error>
[src]
Gets the value of the SO_SNDBUF
option on this socket.
For more information about this option, see set_send_buffer
.
Examples
use tokio::net::TcpStream; use futures::Future; use std::net::SocketAddr; let addr = "127.0.0.1:8080".parse::<SocketAddr>()?; let stream = TcpStream::connect(&addr); stream.map(|stream| { stream.set_send_buffer_size(100).expect("set_send_buffer_size failed"); assert_eq!(stream.send_buffer_size().unwrap_or(0), 100); });
pub fn set_send_buffer_size(&self, size: usize) -> Result<(), Error>
[src]
Sets the value of the SO_SNDBUF
option on this socket.
Changes the size of the operating system's send buffer associated with the socket.
Examples
use tokio::net::TcpStream; use futures::Future; use std::net::SocketAddr; let addr = "127.0.0.1:8080".parse::<SocketAddr>()?; let stream = TcpStream::connect(&addr); stream.map(|stream| { stream.set_send_buffer_size(100).expect("set_send_buffer_size failed"); });
pub fn keepalive(&self) -> Result<Option<Duration>, Error>
[src]
Returns whether keepalive messages are enabled on this socket, and if so the duration of time between them.
For more information about this option, see set_keepalive
.
Examples
use tokio::net::TcpStream; use futures::Future; use std::net::SocketAddr; let addr = "127.0.0.1:8080".parse::<SocketAddr>()?; let stream = TcpStream::connect(&addr); stream.map(|stream| { stream.set_keepalive(None).expect("set_keepalive failed"); assert_eq!(stream.keepalive().unwrap(), None); });
pub fn set_keepalive(&self, keepalive: Option<Duration>) -> Result<(), Error>
[src]
Sets whether keepalive messages are enabled to be sent on this socket.
On Unix, this option will set the SO_KEEPALIVE
as well as the
TCP_KEEPALIVE
or TCP_KEEPIDLE
option (depending on your platform).
On Windows, this will set the SIO_KEEPALIVE_VALS
option.
If None
is specified then keepalive messages are disabled, otherwise
the duration specified will be the time to remain idle before sending a
TCP keepalive probe.
Some platforms specify this value in seconds, so sub-second specifications may be omitted.
Examples
use tokio::net::TcpStream; use futures::Future; use std::net::SocketAddr; let addr = "127.0.0.1:8080".parse::<SocketAddr>()?; let stream = TcpStream::connect(&addr); stream.map(|stream| { stream.set_keepalive(None).expect("set_keepalive failed"); });
pub fn ttl(&self) -> Result<u32, Error>
[src]
Gets the value of the IP_TTL
option for this socket.
For more information about this option, see set_ttl
.
Examples
use tokio::net::TcpStream; use futures::Future; use std::net::SocketAddr; let addr = "127.0.0.1:8080".parse::<SocketAddr>()?; let stream = TcpStream::connect(&addr); stream.map(|stream| { stream.set_ttl(100).expect("set_ttl failed"); assert_eq!(stream.ttl().unwrap_or(0), 100); });
pub fn set_ttl(&self, ttl: u32) -> Result<(), Error>
[src]
Sets the value for the IP_TTL
option on this socket.
This value sets the time-to-live field that is used in every packet sent from this socket.
Examples
use tokio::net::TcpStream; use futures::Future; use std::net::SocketAddr; let addr = "127.0.0.1:8080".parse::<SocketAddr>()?; let stream = TcpStream::connect(&addr); stream.map(|stream| { stream.set_ttl(100).expect("set_ttl failed"); });
pub fn linger(&self) -> Result<Option<Duration>, Error>
[src]
Reads the linger duration for this socket by getting the SO_LINGER
option.
For more information about this option, see set_linger
.
Examples
use tokio::net::TcpStream; use futures::Future; use std::net::SocketAddr; let addr = "127.0.0.1:8080".parse::<SocketAddr>()?; let stream = TcpStream::connect(&addr); stream.map(|stream| { stream.set_linger(None).expect("set_linger failed"); assert_eq!(stream.linger().unwrap(), None); });
pub fn set_linger(&self, dur: Option<Duration>) -> Result<(), Error>
[src]
Sets the linger duration of this socket by setting the SO_LINGER
option.
This option controls the action taken when a stream has unsent messages
and the stream is closed. If SO_LINGER
is set, the system
shall block the process until it can transmit the data or until the
time expires.
If SO_LINGER
is not specified, and the stream is closed, the system
handles the call in a way that allows the process to continue as quickly
as possible.
Examples
use tokio::net::TcpStream; use futures::Future; use std::net::SocketAddr; let addr = "127.0.0.1:8080".parse::<SocketAddr>()?; let stream = TcpStream::connect(&addr); stream.map(|stream| { stream.set_linger(None).expect("set_linger failed"); });
Trait Implementations
impl Debug for TcpStream
[src]
impl<'a> Read for &'a TcpStream
[src]
fn read(&mut self, buf: &mut [u8]) -> Result<usize, Error>
[src]
fn read_vectored(&mut self, bufs: &mut [IoSliceMut]) -> Result<usize, Error>
1.36.0[src]
unsafe fn initializer(&self) -> Initializer
[src]
fn read_to_end(&mut self, buf: &mut Vec<u8>) -> Result<usize, Error>
1.0.0[src]
fn read_to_string(&mut self, buf: &mut String) -> Result<usize, Error>
1.0.0[src]
fn read_exact(&mut self, buf: &mut [u8]) -> Result<(), Error>
1.6.0[src]
ⓘImportant traits for &'_ mut Wfn by_ref(&mut self) -> &mut Self
1.0.0[src]
fn bytes(self) -> Bytes<Self>
1.0.0[src]
ⓘImportant traits for Chain<T, U>fn chain<R>(self, next: R) -> Chain<Self, R> where
R: Read,
1.0.0[src]
R: Read,
ⓘImportant traits for Take<T>fn take(self, limit: u64) -> Take<Self>
1.0.0[src]
impl Read for TcpStream
[src]
fn read(&mut self, buf: &mut [u8]) -> Result<usize, Error>
[src]
fn read_vectored(&mut self, bufs: &mut [IoSliceMut]) -> Result<usize, Error>
1.36.0[src]
unsafe fn initializer(&self) -> Initializer
[src]
fn read_to_end(&mut self, buf: &mut Vec<u8>) -> Result<usize, Error>
1.0.0[src]
fn read_to_string(&mut self, buf: &mut String) -> Result<usize, Error>
1.0.0[src]
fn read_exact(&mut self, buf: &mut [u8]) -> Result<(), Error>
1.6.0[src]
ⓘImportant traits for &'_ mut Wfn by_ref(&mut self) -> &mut Self
1.0.0[src]
fn bytes(self) -> Bytes<Self>
1.0.0[src]
ⓘImportant traits for Chain<T, U>fn chain<R>(self, next: R) -> Chain<Self, R> where
R: Read,
1.0.0[src]
R: Read,
ⓘImportant traits for Take<T>fn take(self, limit: u64) -> Take<Self>
1.0.0[src]
impl AsyncWrite for TcpStream
[src]
fn shutdown(&mut self) -> Result<Async<()>, Error>
[src]
fn write_buf<B>(&mut self, buf: &mut B) -> Result<Async<usize>, Error> where
B: Buf,
[src]
B: Buf,
fn poll_write(&mut self, buf: &[u8]) -> Result<Async<usize>, Error>
[src]
fn poll_flush(&mut self) -> Result<Async<()>, Error>
[src]
impl<'a> AsyncWrite for &'a TcpStream
[src]
fn shutdown(&mut self) -> Result<Async<()>, Error>
[src]
fn write_buf<B>(&mut self, buf: &mut B) -> Result<Async<usize>, Error> where
B: Buf,
[src]
B: Buf,
fn poll_write(&mut self, buf: &[u8]) -> Result<Async<usize>, Error>
[src]
fn poll_flush(&mut self) -> Result<Async<()>, Error>
[src]
impl AsyncRead for TcpStream
[src]
unsafe fn prepare_uninitialized_buffer(&self, &mut [u8]) -> bool
[src]
fn read_buf<B>(&mut self, buf: &mut B) -> Result<Async<usize>, Error> where
B: BufMut,
[src]
B: BufMut,
fn poll_read(&mut self, buf: &mut [u8]) -> Result<Async<usize>, Error>
[src]
fn framed<T>(self, codec: T) -> Framed<Self, T> where
Self: AsyncWrite,
T: Decoder + Encoder,
[src]
Self: AsyncWrite,
T: Decoder + Encoder,
fn split(self) -> (ReadHalf<Self>, WriteHalf<Self>) where
Self: AsyncWrite,
[src]
Self: AsyncWrite,
impl<'a> AsyncRead for &'a TcpStream
[src]
unsafe fn prepare_uninitialized_buffer(&self, &mut [u8]) -> bool
[src]
fn read_buf<B>(&mut self, buf: &mut B) -> Result<Async<usize>, Error> where
B: BufMut,
[src]
B: BufMut,
fn poll_read(&mut self, buf: &mut [u8]) -> Result<Async<usize>, Error>
[src]
fn framed<T>(self, codec: T) -> Framed<Self, T> where
Self: AsyncWrite,
T: Decoder + Encoder,
[src]
Self: AsyncWrite,
T: Decoder + Encoder,
fn split(self) -> (ReadHalf<Self>, WriteHalf<Self>) where
Self: AsyncWrite,
[src]
Self: AsyncWrite,
impl<'a> Write for &'a TcpStream
[src]
fn write(&mut self, buf: &[u8]) -> Result<usize, Error>
[src]
fn flush(&mut self) -> Result<(), Error>
[src]
fn write_vectored(&mut self, bufs: &[IoSlice]) -> Result<usize, Error>
1.36.0[src]
fn write_all(&mut self, buf: &[u8]) -> Result<(), Error>
1.0.0[src]
fn write_fmt(&mut self, fmt: Arguments) -> Result<(), Error>
1.0.0[src]
ⓘImportant traits for &'_ mut Wfn by_ref(&mut self) -> &mut Self
1.0.0[src]
impl Write for TcpStream
[src]
fn write(&mut self, buf: &[u8]) -> Result<usize, Error>
[src]
fn flush(&mut self) -> Result<(), Error>
[src]
fn write_vectored(&mut self, bufs: &[IoSlice]) -> Result<usize, Error>
1.36.0[src]
fn write_all(&mut self, buf: &[u8]) -> Result<(), Error>
1.0.0[src]
fn write_fmt(&mut self, fmt: Arguments) -> Result<(), Error>
1.0.0[src]
ⓘImportant traits for &'_ mut Wfn by_ref(&mut self) -> &mut Self
1.0.0[src]
impl AsRawFd for TcpStream
[src]
Auto Trait Implementations
impl Send for TcpStream
impl Unpin for TcpStream
impl Sync for TcpStream
impl !UnwindSafe for TcpStream
impl !RefUnwindSafe for TcpStream
Blanket Implementations
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T> From<T> for T
[src]
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
[src]
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
ⓘImportant traits for &'_ mut Wfn borrow_mut(&mut self) -> &mut T
[src]
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<R> ReadBytesExt for R where
R: Read + ?Sized,
[src]
R: Read + ?Sized,
fn read_u8(&mut self) -> Result<u8, Error>
[src]
fn read_i8(&mut self) -> Result<i8, Error>
[src]
fn read_u16<T>(&mut self) -> Result<u16, Error> where
T: ByteOrder,
[src]
T: ByteOrder,
fn read_i16<T>(&mut self) -> Result<i16, Error> where
T: ByteOrder,
[src]
T: ByteOrder,
fn read_u24<T>(&mut self) -> Result<u32, Error> where
T: ByteOrder,
[src]
T: ByteOrder,
fn read_i24<T>(&mut self) -> Result<i32, Error> where
T: ByteOrder,
[src]
T: ByteOrder,
fn read_u32<T>(&mut self) -> Result<u32, Error> where
T: ByteOrder,
[src]
T: ByteOrder,
fn read_i32<T>(&mut self) -> Result<i32, Error> where
T: ByteOrder,
[src]
T: ByteOrder,
fn read_u48<T>(&mut self) -> Result<u64, Error> where
T: ByteOrder,
[src]
T: ByteOrder,
fn read_i48<T>(&mut self) -> Result<i64, Error> where
T: ByteOrder,
[src]
T: ByteOrder,
fn read_u64<T>(&mut self) -> Result<u64, Error> where
T: ByteOrder,
[src]
T: ByteOrder,
fn read_i64<T>(&mut self) -> Result<i64, Error> where
T: ByteOrder,
[src]
T: ByteOrder,
fn read_u128<T>(&mut self) -> Result<u128, Error> where
T: ByteOrder,
[src]
T: ByteOrder,
fn read_i128<T>(&mut self) -> Result<i128, Error> where
T: ByteOrder,
[src]
T: ByteOrder,
fn read_uint<T>(&mut self, nbytes: usize) -> Result<u64, Error> where
T: ByteOrder,
[src]
T: ByteOrder,
fn read_int<T>(&mut self, nbytes: usize) -> Result<i64, Error> where
T: ByteOrder,
[src]
T: ByteOrder,
fn read_uint128<T>(&mut self, nbytes: usize) -> Result<u128, Error> where
T: ByteOrder,
[src]
T: ByteOrder,
fn read_int128<T>(&mut self, nbytes: usize) -> Result<i128, Error> where
T: ByteOrder,
[src]
T: ByteOrder,
fn read_f32<T>(&mut self) -> Result<f32, Error> where
T: ByteOrder,
[src]
T: ByteOrder,
fn read_f64<T>(&mut self) -> Result<f64, Error> where
T: ByteOrder,
[src]
T: ByteOrder,
fn read_u16_into<T>(&mut self, dst: &mut [u16]) -> Result<(), Error> where
T: ByteOrder,
[src]
T: ByteOrder,
fn read_u32_into<T>(&mut self, dst: &mut [u32]) -> Result<(), Error> where
T: ByteOrder,
[src]
T: ByteOrder,
fn read_u64_into<T>(&mut self, dst: &mut [u64]) -> Result<(), Error> where
T: ByteOrder,
[src]
T: ByteOrder,
fn read_u128_into<T>(&mut self, dst: &mut [u128]) -> Result<(), Error> where
T: ByteOrder,
[src]
T: ByteOrder,
fn read_i8_into(&mut self, dst: &mut [i8]) -> Result<(), Error>
[src]
fn read_i16_into<T>(&mut self, dst: &mut [i16]) -> Result<(), Error> where
T: ByteOrder,
[src]
T: ByteOrder,
fn read_i32_into<T>(&mut self, dst: &mut [i32]) -> Result<(), Error> where
T: ByteOrder,
[src]
T: ByteOrder,
fn read_i64_into<T>(&mut self, dst: &mut [i64]) -> Result<(), Error> where
T: ByteOrder,
[src]
T: ByteOrder,
fn read_i128_into<T>(&mut self, dst: &mut [i128]) -> Result<(), Error> where
T: ByteOrder,
[src]
T: ByteOrder,
fn read_f32_into<T>(&mut self, dst: &mut [f32]) -> Result<(), Error> where
T: ByteOrder,
[src]
T: ByteOrder,
fn read_f32_into_unchecked<T>(&mut self, dst: &mut [f32]) -> Result<(), Error> where
T: ByteOrder,
[src]
T: ByteOrder,
fn read_f64_into<T>(&mut self, dst: &mut [f64]) -> Result<(), Error> where
T: ByteOrder,
[src]
T: ByteOrder,
fn read_f64_into_unchecked<T>(&mut self, dst: &mut [f64]) -> Result<(), Error> where
T: ByteOrder,
[src]
T: ByteOrder,
impl<W> WriteBytesExt for W where
W: Write + ?Sized,
[src]
W: Write + ?Sized,
fn write_u8(&mut self, n: u8) -> Result<(), Error>
[src]
fn write_i8(&mut self, n: i8) -> Result<(), Error>
[src]
fn write_u16<T>(&mut self, n: u16) -> Result<(), Error> where
T: ByteOrder,
[src]
T: ByteOrder,
fn write_i16<T>(&mut self, n: i16) -> Result<(), Error> where
T: ByteOrder,
[src]
T: ByteOrder,
fn write_u24<T>(&mut self, n: u32) -> Result<(), Error> where
T: ByteOrder,
[src]
T: ByteOrder,
fn write_i24<T>(&mut self, n: i32) -> Result<(), Error> where
T: ByteOrder,
[src]
T: ByteOrder,
fn write_u32<T>(&mut self, n: u32) -> Result<(), Error> where
T: ByteOrder,
[src]
T: ByteOrder,
fn write_i32<T>(&mut self, n: i32) -> Result<(), Error> where
T: ByteOrder,
[src]
T: ByteOrder,
fn write_u48<T>(&mut self, n: u64) -> Result<(), Error> where
T: ByteOrder,
[src]
T: ByteOrder,
fn write_i48<T>(&mut self, n: i64) -> Result<(), Error> where
T: ByteOrder,
[src]
T: ByteOrder,
fn write_u64<T>(&mut self, n: u64) -> Result<(), Error> where
T: ByteOrder,
[src]
T: ByteOrder,
fn write_i64<T>(&mut self, n: i64) -> Result<(), Error> where
T: ByteOrder,
[src]
T: ByteOrder,
fn write_u128<T>(&mut self, n: u128) -> Result<(), Error> where
T: ByteOrder,
[src]
T: ByteOrder,
fn write_i128<T>(&mut self, n: i128) -> Result<(), Error> where
T: ByteOrder,
[src]
T: ByteOrder,
fn write_uint<T>(&mut self, n: u64, nbytes: usize) -> Result<(), Error> where
T: ByteOrder,
[src]
T: ByteOrder,
fn write_int<T>(&mut self, n: i64, nbytes: usize) -> Result<(), Error> where
T: ByteOrder,
[src]
T: ByteOrder,
fn write_uint128<T>(&mut self, n: u128, nbytes: usize) -> Result<(), Error> where
T: ByteOrder,
[src]
T: ByteOrder,
fn write_int128<T>(&mut self, n: i128, nbytes: usize) -> Result<(), Error> where
T: ByteOrder,
[src]
T: ByteOrder,
fn write_f32<T>(&mut self, n: f32) -> Result<(), Error> where
T: ByteOrder,
[src]
T: ByteOrder,
fn write_f64<T>(&mut self, n: f64) -> Result<(), Error> where
T: ByteOrder,
[src]
T: ByteOrder,