Struct bytes::buf::Take

pub struct Take<T> { /* fields omitted */ }

A Buf adapter which limits the bytes read from an underlying buffer.

This struct is generally created by calling take() on Buf. See documentation of take() for more details.

Methods

impl<T> Take<T>

pub fn into_inner(self) -> T

Consumes this Take, returning the underlying value.

Examples

use bytes::{Buf, BufMut};
use std::io::Cursor;

let mut buf = Cursor::new(b"hello world").take(2);
let mut dst = vec![];

dst.put(&mut buf);
assert_eq!(*dst, b"he"[..]);

let mut buf = buf.into_inner();

dst.clear();
dst.put(&mut buf);
assert_eq!(*dst, b"llo world"[..]);

Important traits for &'a mut I

impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, 

pub fn get_ref(&self) -> &T

Gets a reference to the underlying Buf.

It is inadvisable to directly read from the underlying Buf.

Examples

use bytes::{Buf, BufMut};
use std::io::Cursor;

let mut buf = Cursor::new(b"hello world").take(2);

assert_eq!(0, buf.get_ref().position());

Important traits for &'a mut I

impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, 

pub fn get_mut(&mut self) -> &mut T

Gets a mutable reference to the underlying Buf.

It is inadvisable to directly read from the underlying Buf.

Examples

use bytes::{Buf, BufMut};
use std::io::Cursor;

let mut buf = Cursor::new(b"hello world").take(2);
let mut dst = vec![];

buf.get_mut().set_position(2);

dst.put(&mut buf);
assert_eq!(*dst, b"ll"[..]);

pub fn limit(&self) -> usize

Returns the maximum number of bytes that can be read.

Note

If the inner Buf has fewer bytes than indicated by this method then that is the actual number of available bytes.

Examples

use bytes::Buf;
use std::io::Cursor;

let mut buf = Cursor::new(b"hello world").take(2);

assert_eq!(2, buf.limit());
assert_eq!(b'h', buf.get_u8());
assert_eq!(1, buf.limit());

pub fn set_limit(&mut self, lim: usize)

Sets the maximum number of bytes that can be read.

Note

If the inner Buf has fewer bytes than lim then that is the actual number of available bytes.

Examples

use bytes::{Buf, BufMut};
use std::io::Cursor;

let mut buf = Cursor::new(b"hello world").take(2);
let mut dst = vec![];

dst.put(&mut buf);
assert_eq!(*dst, b"he"[..]);

dst.clear();

buf.set_limit(3);
dst.put(&mut buf);
assert_eq!(*dst, b"llo"[..]);

Trait Implementations

impl<T: Debug> Debug for Take<T>

fn fmt(&self, __arg_0: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<T: Buf> Buf for Take<T>

fn remaining(&self) -> usize

Returns the number of bytes between the current position and the end of the buffer.

Important traits for &'a [u8]

impl<'a> Read for &'a [u8]impl<'a> Write for &'a mut [u8]

fn bytes(&self) -> &[u8]

Returns a slice starting at the current position and of length between 0 and Buf::remaining().

fn advance(&mut self, cnt: usize)

Advance the internal cursor of the Buf

fn bytes_vec<'a>(&'a self, dst: &mut [&'a IoVec]) -> usize

Fills dst with potentially multiple slices starting at self's current position.

fn has_remaining(&self) -> bool

Returns true if there are any more bytes to consume

fn copy_to_slice(&mut self, dst: &mut [u8])

Copies bytes from self into dst.

fn get_u8(&mut self) -> u8

Gets an unsigned 8 bit integer from self.

fn get_i8(&mut self) -> i8

Gets a signed 8 bit integer from self.

fn get_u16<T: ByteOrder>(&mut self) -> u16

Gets an unsigned 16 bit integer from self in the specified byte order.

fn get_i16<T: ByteOrder>(&mut self) -> i16

Gets a signed 16 bit integer from self in the specified byte order.

fn get_u32<T: ByteOrder>(&mut self) -> u32

Gets an unsigned 32 bit integer from self in the specified byte order.

fn get_i32<T: ByteOrder>(&mut self) -> i32

Gets a signed 32 bit integer from self in the specified byte order.

fn get_u64<T: ByteOrder>(&mut self) -> u64

Gets an unsigned 64 bit integer from self in the specified byte order.

fn get_i64<T: ByteOrder>(&mut self) -> i64

Gets a signed 64 bit integer from self in the specified byte order.

fn get_uint<T: ByteOrder>(&mut self, nbytes: usize) -> u64

Gets an unsigned n-byte integer from self in the specified byte order.

fn get_int<T: ByteOrder>(&mut self, nbytes: usize) -> i64

Gets a signed n-byte integer from self in the specified byte order.

fn get_f32<T: ByteOrder>(&mut self) -> f32

Gets an IEEE754 single-precision (4 bytes) floating point number from self in the specified byte order.

fn get_f64<T: ByteOrder>(&mut self) -> f64

Gets an IEEE754 double-precision (8 bytes) floating point number from self in the specified byte order.

fn collect<B>(self) -> B where
    Self: Sized,
    B: FromBuf, 

Transforms a Buf into a concrete buffer.

fn take(self, limit: usize) -> Take<Self> where
    Self: Sized, 

Creates an adaptor which will read at most limit bytes from self.

fn chain<U>(self, next: U) -> Chain<Self, U::Buf> where
    U: IntoBuf,
    Self: Sized, 

Creates an adaptor which will chain this buffer with another.

Important traits for &'a mut I

impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, 

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

Creates a "by reference" adaptor for this instance of Buf.

Important traits for Reader<B>

impl<B: Buf + Sized> Read for Reader<B>

fn reader(self) -> Reader<Self> where
    Self: Sized, 

Creates an adaptor which implements the Read trait for self.

Important traits for Iter<T>

impl<T: Buf> Iterator for Iter<T> type Item = u8;

fn iter(self) -> Iter<Self> where
    Self: Sized, 

Returns an iterator over the bytes contained by the buffer.