# [−][src]Trait byteorder::ReadBytesExt

    pub trait ReadBytesExt: Read {
        fn read_u8(&mut self) -> Result<u8> { ... }
        fn read_i8(&mut self) -> Result<i8> { ... }
        fn read_u16<T: ByteOrder>(&mut self) -> Result<u16> { ... }
        fn read_i16<T: ByteOrder>(&mut self) -> Result<i16> { ... }
        fn read_u24<T: ByteOrder>(&mut self) -> Result<u32> { ... }
        fn read_i24<T: ByteOrder>(&mut self) -> Result<i32> { ... }
        fn read_u32<T: ByteOrder>(&mut self) -> Result<u32> { ... }
        fn read_i32<T: ByteOrder>(&mut self) -> Result<i32> { ... }
        fn read_u48<T: ByteOrder>(&mut self) -> Result<u64> { ... }
        fn read_i48<T: ByteOrder>(&mut self) -> Result<i64> { ... }
        fn read_u64<T: ByteOrder>(&mut self) -> Result<u64> { ... }
        fn read_i64<T: ByteOrder>(&mut self) -> Result<i64> { ... }
        fn read_u128<T: ByteOrder>(&mut self) -> Result<u128> { ... }
        fn read_i128<T: ByteOrder>(&mut self) -> Result<i128> { ... }
        fn read_uint<T: ByteOrder>(&mut self, nbytes: usize) -> Result<u64> { ... }
        fn read_int<T: ByteOrder>(&mut self, nbytes: usize) -> Result<i64> { ... }
        fn read_uint128<T: ByteOrder>(&mut self, nbytes: usize) -> Result<u128> { ... }
        fn read_int128<T: ByteOrder>(&mut self, nbytes: usize) -> Result<i128> { ... }
        fn read_f32<T: ByteOrder>(&mut self) -> Result<f32> { ... }
        fn read_f64<T: ByteOrder>(&mut self) -> Result<f64> { ... }
        fn read_u16_into<T: ByteOrder>(&mut self, dst: &mut [u16]) -> Result<()> { ... }
        fn read_u32_into<T: ByteOrder>(&mut self, dst: &mut [u32]) -> Result<()> { ... }
        fn read_u64_into<T: ByteOrder>(&mut self, dst: &mut [u64]) -> Result<()> { ... }
        fn read_u128_into<T: ByteOrder>(&mut self, dst: &mut [u128]) -> Result<()> { ... }
        fn read_i8_into(&mut self, dst: &mut [i8]) -> Result<()> { ... }
        fn read_i16_into<T: ByteOrder>(&mut self, dst: &mut [i16]) -> Result<()> { ... }
        fn read_i32_into<T: ByteOrder>(&mut self, dst: &mut [i32]) -> Result<()> { ... }
        fn read_i64_into<T: ByteOrder>(&mut self, dst: &mut [i64]) -> Result<()> { ... }
        fn read_i128_into<T: ByteOrder>(&mut self, dst: &mut [i128]) -> Result<()> { ... }
        fn read_f32_into<T: ByteOrder>(&mut self, dst: &mut [f32]) -> Result<()> { ... }
        fn read_f32_into_unchecked<T: ByteOrder>(
            &mut self,
            dst: &mut [f32]
        ) -> Result<()> { ... }
        fn read_f64_into<T: ByteOrder>(&mut self, dst: &mut [f64]) -> Result<()> { ... }
        fn read_f64_into_unchecked<T: ByteOrder>(
            &mut self,
            dst: &mut [f64]
        ) -> Result<()> { ... }
    }

Extends `Read` with methods for reading numbers. (For `std::io`.)

Most of the methods defined here have an unconstrained type parameter that must be explicitly instantiated. Typically, it is instantiated with either the `BigEndian` or `LittleEndian` types defined in this crate.

# Examples

Read unsigned 16 bit big-endian integers from a `Read`:

    use std::io::Cursor;
    use byteorder::{BigEndian, ReadBytesExt};

    let mut rdr = Cursor::new(vec![2, 5, 3, 0]);
    assert_eq!(517, rdr.read_u16::<BigEndian>().unwrap());
    assert_eq!(768, rdr.read_u16::<BigEndian>().unwrap());

## Provided methods

### `fn read_u8(&mut self) -> Result<u8>`

Reads an unsigned 8 bit integer from the underlying reader.

Note that since this reads a single byte, no byte order conversions are used. It is included for completeness.

# Errors

This method returns the same errors as `Read::read_exact`.

# Examples

Read unsigned 8 bit integers from a `Read`:

    use std::io::Cursor;
    use byteorder::ReadBytesExt;

    let mut rdr = Cursor::new(vec![2, 5]);
    assert_eq!(2, rdr.read_u8().unwrap());
    assert_eq!(5, rdr.read_u8().unwrap());

### `fn read_i8(&mut self) -> Result<i8>`

Reads a signed 8 bit integer from the underlying reader.

Note that since this reads a single byte, no byte order conversions are used. It is included for completeness.

# Errors

This method returns the same errors as `Read::read_exact`.

# Examples

Read signed 8 bit integers from a `Read`:

    use std::io::Cursor;
    use byteorder::ReadBytesExt;

    let mut rdr = Cursor::new(vec![0x02, 0xfb]);
    assert_eq!(2, rdr.read_i8().unwrap());
    assert_eq!(-5, rdr.read_i8().unwrap());

### `fn read_u16<T: ByteOrder>(&mut self) -> Result<u16>`

Reads an unsigned 16 bit integer from the underlying reader.

# Errors

This method returns the same errors as `Read::read_exact`.

# Examples

Read unsigned 16 bit big-endian integers from a `Read`:

    use std::io::Cursor;
    use byteorder::{BigEndian, ReadBytesExt};

    let mut rdr = Cursor::new(vec![2, 5, 3, 0]);
    assert_eq!(517, rdr.read_u16::<BigEndian>().unwrap());
    assert_eq!(768, rdr.read_u16::<BigEndian>().unwrap());

### `fn read_i16<T: ByteOrder>(&mut self) -> Result<i16>`

Reads a signed 16 bit integer from the underlying reader.

# Errors

This method returns the same errors as `Read::read_exact`.

# Examples

Read signed 16 bit big-endian integers from a `Read`:

    use std::io::Cursor;
    use byteorder::{BigEndian, ReadBytesExt};

    let mut rdr = Cursor::new(vec![0x00, 0xc1, 0xff, 0x7c]);
    assert_eq!(193, rdr.read_i16::<BigEndian>().unwrap());
    assert_eq!(-132, rdr.read_i16::<BigEndian>().unwrap());

### `fn read_u24<T: ByteOrder>(&mut self) -> Result<u32>`

Reads an unsigned 24 bit integer from the underlying reader.

# Errors

This method returns the same errors as `Read::read_exact`.

# Examples

Read unsigned 24 bit big-endian integers from a `Read`:

    use std::io::Cursor;
    use byteorder::{BigEndian, ReadBytesExt};

    let mut rdr = Cursor::new(vec![0x00, 0x01, 0x0b]);
    assert_eq!(267, rdr.read_u24::<BigEndian>().unwrap());

### `fn read_i24<T: ByteOrder>(&mut self) -> Result<i32>`

Reads a signed 24 bit integer from the underlying reader.

# Errors

This method returns the same errors as `Read::read_exact`.

# Examples

Read signed 24 bit big-endian integers from a `Read`:

    use std::io::Cursor;
    use byteorder::{BigEndian, ReadBytesExt};

    let mut rdr = Cursor::new(vec![0xff, 0x7a, 0x33]);
    assert_eq!(-34253, rdr.read_i24::<BigEndian>().unwrap());

### `fn read_u32<T: ByteOrder>(&mut self) -> Result<u32>`

Reads an unsigned 32 bit integer from the underlying reader.

# Errors

This method returns the same errors as `Read::read_exact`.

# Examples

Read unsigned 32 bit big-endian integers from a `Read`:

    use std::io::Cursor;
    use byteorder::{BigEndian, ReadBytesExt};

    let mut rdr = Cursor::new(vec![0x00, 0x00, 0x01, 0x0b]);
    assert_eq!(267, rdr.read_u32::<BigEndian>().unwrap());

### `fn read_i32<T: ByteOrder>(&mut self) -> Result<i32>`

Reads a signed 32 bit integer from the underlying reader.

# Errors

This method returns the same errors as `Read::read_exact`.

# Examples

Read signed 32 bit big-endian integers from a `Read`:

    use std::io::Cursor;
    use byteorder::{BigEndian, ReadBytesExt};

    let mut rdr = Cursor::new(vec![0xff, 0xff, 0x7a, 0x33]);
    assert_eq!(-34253, rdr.read_i32::<BigEndian>().unwrap());

### `fn read_u48<T: ByteOrder>(&mut self) -> Result<u64>`

Reads an unsigned 48 bit integer from the underlying reader.

# Errors

This method returns the same errors as `Read::read_exact`.

# Examples

Read unsigned 48 bit big-endian integers from a `Read`:

    use std::io::Cursor;
    use byteorder::{BigEndian, ReadBytesExt};

    let mut rdr = Cursor::new(vec![0xb6, 0x71, 0x6b, 0xdc, 0x2b, 0x31]);
    assert_eq!(200598257150769, rdr.read_u48::<BigEndian>().unwrap());

### `fn read_i48<T: ByteOrder>(&mut self) -> Result<i64>`

Reads a signed 48 bit integer from the underlying reader.

# Errors

This method returns the same errors as `Read::read_exact`.

# Examples

Read signed 48 bit big-endian integers from a `Read`:

    use std::io::Cursor;
    use byteorder::{BigEndian, ReadBytesExt};

    let mut rdr = Cursor::new(vec![0x9d, 0x71, 0xab, 0xe7, 0x97, 0x8f]);
    assert_eq!(-108363435763825, rdr.read_i48::<BigEndian>().unwrap());

### `fn read_u64<T: ByteOrder>(&mut self) -> Result<u64>`

Reads an unsigned 64 bit integer from the underlying reader.

# Errors

This method returns the same errors as `Read::read_exact`.

# Examples

Read an unsigned 64 bit big-endian integer from a `Read`:

    use std::io::Cursor;
    use byteorder::{BigEndian, ReadBytesExt};

    let mut rdr = Cursor::new(vec![0x00, 0x03, 0x43, 0x95, 0x4d, 0x60, 0x86, 0x83]);
    assert_eq!(918733457491587, rdr.read_u64::<BigEndian>().unwrap());

### `fn read_i64<T: ByteOrder>(&mut self) -> Result<i64>`

Reads a signed 64 bit integer from the underlying reader.

# Errors

This method returns the same errors as `Read::read_exact`.

# Examples

Read a signed 64 bit big-endian integer from a `Read`:

    use std::io::Cursor;
    use byteorder::{BigEndian, ReadBytesExt};

    let mut rdr = Cursor::new(vec![0x80, 0, 0, 0, 0, 0, 0, 0]);
    assert_eq!(i64::min_value(), rdr.read_i64::<BigEndian>().unwrap());

### `fn read_u128<T: ByteOrder>(&mut self) -> Result<u128>`

Reads an unsigned 128 bit integer from the underlying reader.

# Errors

This method returns the same errors as `Read::read_exact`.

# Examples

Read an unsigned 128 bit big-endian integer from a `Read`:

    use std::io::Cursor;
    use byteorder::{BigEndian, ReadBytesExt};

    let mut rdr = Cursor::new(vec![
        0x00, 0x03, 0x43, 0x95, 0x4d, 0x60, 0x86, 0x83,
        0x00, 0x03, 0x43, 0x95, 0x4d, 0x60, 0x86, 0x83
    ]);
    assert_eq!(16947640962301618749969007319746179, rdr.read_u128::<BigEndian>().unwrap());

### `fn read_i128<T: ByteOrder>(&mut self) -> Result<i128>`

Reads a signed 128 bit integer from the underlying reader.

# Errors

This method returns the same errors as `Read::read_exact`.

# Examples

Read a signed 128 bit big-endian integer from a `Read`:

    use std::io::Cursor;
    use byteorder::{BigEndian, ReadBytesExt};

    let mut rdr = Cursor::new(vec![0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
    assert_eq!(i128::min_value(), rdr.read_i128::<BigEndian>().unwrap());

### `fn read_uint<T: ByteOrder>(&mut self, nbytes: usize) -> Result<u64>`

Reads an unsigned n-bytes integer from the underlying reader.

# Errors

This method returns the same errors as `Read::read_exact`.

# Examples

Read an unsigned n-byte big-endian integer from a `Read`:

    use std::io::Cursor;
    use byteorder::{BigEndian, ReadBytesExt};

    let mut rdr = Cursor::new(vec![0x80, 0x74, 0xfa]);
    assert_eq!(8418554, rdr.read_uint::<BigEndian>(3).unwrap());

### `fn read_int<T: ByteOrder>(&mut self, nbytes: usize) -> Result<i64>`

Reads a signed n-bytes integer from the underlying reader.

# Errors

This method returns the same errors as `Read::read_exact`.

# Examples

Read an unsigned n-byte big-endian integer from a `Read`:

    use std::io::Cursor;
    use byteorder::{BigEndian, ReadBytesExt};

    let mut rdr = Cursor::new(vec![0xc1, 0xff, 0x7c]);
    assert_eq!(-4063364, rdr.read_int::<BigEndian>(3).unwrap());

### `fn read_uint128<T: ByteOrder>(&mut self, nbytes: usize) -> Result<u128>`

Reads an unsigned n-bytes integer from the underlying reader.

### `fn read_int128<T: ByteOrder>(&mut self, nbytes: usize) -> Result<i128>`

Reads a signed n-bytes integer from the underlying reader.

### `fn read_f32<T: ByteOrder>(&mut self) -> Result<f32>`

Reads a IEEE754 single-precision (4 bytes) floating point number from the underlying reader.

# Errors

This method returns the same errors as `Read::read_exact`.

# Examples

Read a big-endian single-precision floating point number from a `Read`:

    use std::f32;
    use std::io::Cursor;

    use byteorder::{BigEndian, ReadBytesExt};

    let mut rdr = Cursor::new(vec![
        0x40, 0x49, 0x0f, 0xdb,
    ]);
    assert_eq!(f32::consts::PI, rdr.read_f32::<BigEndian>().unwrap());

### `fn read_f64<T: ByteOrder>(&mut self) -> Result<f64>`

Reads a IEEE754 double-precision (8 bytes) floating point number from the underlying reader.

# Errors

This method returns the same errors as `Read::read_exact`.

# Examples

Read a big-endian double-precision floating point number from a `Read`:

    use std::f64;
    use std::io::Cursor;

    use byteorder::{BigEndian, ReadBytesExt};

    let mut rdr = Cursor::new(vec![
        0x40, 0x09, 0x21, 0xfb, 0x54, 0x44, 0x2d, 0x18,
    ]);
    assert_eq!(f64::consts::PI, rdr.read_f64::<BigEndian>().unwrap());

### `fn read_u16_into<T: ByteOrder>(&mut self, dst: &mut [u16]) -> Result<()>`

Reads a sequence of unsigned 16 bit integers from the underlying reader.

The given buffer is either filled completely or an error is returned. If an error is returned, the contents of `dst` are unspecified.

# Errors

This method returns the same errors as `Read::read_exact`.

# Examples

Read a sequence of unsigned 16 bit big-endian integers from a `Read`:

    use std::io::Cursor;
    use byteorder::{BigEndian, ReadBytesExt};

    let mut rdr = Cursor::new(vec![2, 5, 3, 0]);
    let mut dst = [0; 2];
    rdr.read_u16_into::<BigEndian>(&mut dst).unwrap();
    assert_eq!([517, 768], dst);

### `fn read_u32_into<T: ByteOrder>(&mut self, dst: &mut [u32]) -> Result<()>`

Reads a sequence of unsigned 32 bit integers from the underlying reader.

The given buffer is either filled completely or an error is returned. If an error is returned, the contents of `dst` are unspecified.

# Errors

This method returns the same errors as `Read::read_exact`.

# Examples

Read a sequence of unsigned 32 bit big-endian integers from a `Read`:

    use std::io::Cursor;
    use byteorder::{BigEndian, ReadBytesExt};

    let mut rdr = Cursor::new(vec![0, 0, 2, 5, 0, 0, 3, 0]);
    let mut dst = [0; 2];
    rdr.read_u32_into::<BigEndian>(&mut dst).unwrap();
    assert_eq!([517, 768], dst);

### `fn read_u64_into<T: ByteOrder>(&mut self, dst: &mut [u64]) -> Result<()>`

Reads a sequence of unsigned 64 bit integers from the underlying reader.

The given buffer is either filled completely or an error is returned. If an error is returned, the contents of `dst` are unspecified.

# Errors

This method returns the same errors as `Read::read_exact`.

# Examples

Read a sequence of unsigned 64 bit big-endian integers from a `Read`:

    use std::io::Cursor;
    use byteorder::{BigEndian, ReadBytesExt};

    let mut rdr = Cursor::new(vec![
        0, 0, 0, 0, 0, 0, 2, 5,
        0, 0, 0, 0, 0, 0, 3, 0,
    ]);
    let mut dst = [0; 2];
    rdr.read_u64_into::<BigEndian>(&mut dst).unwrap();
    assert_eq!([517, 768], dst);

### `fn read_u128_into<T: ByteOrder>(&mut self, dst: &mut [u128]) -> Result<()>`

Reads a sequence of unsigned 128 bit integers from the underlying reader.

The given buffer is either filled completely or an error is returned. If an error is returned, the contents of `dst` are unspecified.

# Errors

This method returns the same errors as `Read::read_exact`.

# Examples

Read a sequence of unsigned 128 bit big-endian integers from a `Read`:

    use std::io::Cursor;
    use byteorder::{BigEndian, ReadBytesExt};

    let mut rdr = Cursor::new(vec![
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 5,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0,
    ]);
    let mut dst = [0; 2];
    rdr.read_u128_into::<BigEndian>(&mut dst).unwrap();
    assert_eq!([517, 768], dst);

### `fn read_i8_into(&mut self, dst: &mut [i8]) -> Result<()>`

Reads a sequence of signed 8 bit integers from the underlying reader.

The given buffer is either filled completely or an error is returned. If an error is returned, the contents of `dst` are unspecified.

Note that since each `i8` is a single byte, no byte order conversions are used. This method is included because it provides a safe, simple way for the caller to read into a `&mut [i8]` buffer. (Without this method, the caller would have to either use `unsafe` code or convert each byte to `i8` individually.)

# Errors

This method returns the same errors as `Read::read_exact`.

# Examples

Read a sequence of signed 8 bit integers from a `Read`:

    use std::io::Cursor;
    use byteorder::{BigEndian, ReadBytesExt};

    let mut rdr = Cursor::new(vec![2, 251, 3]);
    let mut dst = [0; 3];
    rdr.read_i8_into(&mut dst).unwrap();
    assert_eq!([2, -5, 3], dst);

### `fn read_i16_into<T: ByteOrder>(&mut self, dst: &mut [i16]) -> Result<()>`

Reads a sequence of signed 16 bit integers from the underlying reader.

The given buffer is either filled completely or an error is returned. If an error is returned, the contents of `dst` are unspecified.

# Errors

This method returns the same errors as `Read::read_exact`.

# Examples

Read a sequence of signed 16 bit big-endian integers from a `Read`:

    use std::io::Cursor;
    use byteorder::{BigEndian, ReadBytesExt};

    let mut rdr = Cursor::new(vec![2, 5, 3, 0]);
    let mut dst = [0; 2];
    rdr.read_i16_into::<BigEndian>(&mut dst).unwrap();
    assert_eq!([517, 768], dst);

### `fn read_i32_into<T: ByteOrder>(&mut self, dst: &mut [i32]) -> Result<()>`

Reads a sequence of signed 32 bit integers from the underlying reader.

The given buffer is either filled completely or an error is returned. If an error is returned, the contents of `dst` are unspecified.

# Errors

This method returns the same errors as `Read::read_exact`.

# Examples

Read a sequence of signed 32 bit big-endian integers from a `Read`:

    use std::io::Cursor;
    use byteorder::{BigEndian, ReadBytesExt};

    let mut rdr = Cursor::new(vec![0, 0, 2, 5, 0, 0, 3, 0]);
    let mut dst = [0; 2];
    rdr.read_i32_into::<BigEndian>(&mut dst).unwrap();
    assert_eq!([517, 768], dst);

### `fn read_i64_into<T: ByteOrder>(&mut self, dst: &mut [i64]) -> Result<()>`

Reads a sequence of signed 64 bit integers from the underlying reader.

The given buffer is either filled completely or an error is returned. If an error is returned, the contents of `dst` are unspecified.

# Errors

This method returns the same errors as `Read::read_exact`.

# Examples

Read a sequence of signed 64 bit big-endian integers from a `Read`:

    use std::io::Cursor;
    use byteorder::{BigEndian, ReadBytesExt};

    let mut rdr = Cursor::new(vec![
        0, 0, 0, 0, 0, 0, 2, 5,
        0, 0, 0, 0, 0, 0, 3, 0,
    ]);
    let mut dst = [0; 2];
    rdr.read_i64_into::<BigEndian>(&mut dst).unwrap();
    assert_eq!([517, 768], dst);

### `fn read_i128_into<T: ByteOrder>(&mut self, dst: &mut [i128]) -> Result<()>`

Reads a sequence of signed 128 bit integers from the underlying reader.

The given buffer is either filled completely or an error is returned. If an error is returned, the contents of `dst` are unspecified.

# Errors

This method returns the same errors as `Read::read_exact`.

# Examples

Read a sequence of signed 128 bit big-endian integers from a `Read`:

    use std::io::Cursor;
    use byteorder::{BigEndian, ReadBytesExt};

    let mut rdr = Cursor::new(vec![
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 5,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0,
    ]);
    let mut dst = [0; 2];
    rdr.read_i128_into::<BigEndian>(&mut dst).unwrap();
    assert_eq!([517, 768], dst);

### `fn read_f32_into<T: ByteOrder>(&mut self, dst: &mut [f32]) -> Result<()>`

Reads a sequence of IEEE754 single-precision (4 bytes) floating point numbers from the underlying reader.

The given buffer is either filled completely or an error is returned. If an error is returned, the contents of `dst` are unspecified.

# Errors

This method returns the same errors as `Read::read_exact`.

# Examples

Read a sequence of big-endian single-precision floating point number from a `Read`:

    use std::f32;
    use std::io::Cursor;

    use byteorder::{BigEndian, ReadBytesExt};

    let mut rdr = Cursor::new(vec![
        0x40, 0x49, 0x0f, 0xdb,
        0x3f, 0x80, 0x00, 0x00,
    ]);
    let mut dst = [0.0; 2];
    rdr.read_f32_into::<BigEndian>(&mut dst).unwrap();
    assert_eq!([f32::consts::PI, 1.0], dst);

### `fn read_f32_into_unchecked<T: ByteOrder>(
&mut self,
dst: &mut [f32]
) -> Result<()>`

Deprecated since 1.2.0:

please use `read_f32_into` instead

DEPRECATED.

This method is deprecated. Use `read_f32_into` instead.

Reads a sequence of IEEE754 single-precision (4 bytes) floating point numbers from the underlying reader.

The given buffer is either filled completely or an error is returned. If an error is returned, the contents of `dst` are unspecified.

# Errors

This method returns the same errors as `Read::read_exact`.

# Examples

Read a sequence of big-endian single-precision floating point number from a `Read`:

    use std::f32;
    use std::io::Cursor;

    use byteorder::{BigEndian, ReadBytesExt};

    let mut rdr = Cursor::new(vec![
        0x40, 0x49, 0x0f, 0xdb,
        0x3f, 0x80, 0x00, 0x00,
    ]);
    let mut dst = [0.0; 2];
    rdr.read_f32_into_unchecked::<BigEndian>(&mut dst).unwrap();
    assert_eq!([f32::consts::PI, 1.0], dst);

### `fn read_f64_into<T: ByteOrder>(&mut self, dst: &mut [f64]) -> Result<()>`

Reads a sequence of IEEE754 double-precision (8 bytes) floating point numbers from the underlying reader.

The given buffer is either filled completely or an error is returned. If an error is returned, the contents of `dst` are unspecified.

# Errors

This method returns the same errors as `Read::read_exact`.

# Examples

Read a sequence of big-endian single-precision floating point number from a `Read`:

    use std::f64;
    use std::io::Cursor;

    use byteorder::{BigEndian, ReadBytesExt};

    let mut rdr = Cursor::new(vec![
        0x40, 0x09, 0x21, 0xfb, 0x54, 0x44, 0x2d, 0x18,
        0x3f, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    ]);
    let mut dst = [0.0; 2];
    rdr.read_f64_into::<BigEndian>(&mut dst).unwrap();
    assert_eq!([f64::consts::PI, 1.0], dst);

### `fn read_f64_into_unchecked<T: ByteOrder>(
&mut self,
dst: &mut [f64]
) -> Result<()>`

Deprecated since 1.2.0:

please use `read_f64_into` instead

DEPRECATED.

This method is deprecated. Use `read_f64_into` instead.

Reads a sequence of IEEE754 double-precision (8 bytes) floating point numbers from the underlying reader.

The given buffer is either filled completely or an error is returned. If an error is returned, the contents of `dst` are unspecified.

# Safety

This method is unsafe because there are no guarantees made about the floating point values. In particular, this method does not check for signaling NaNs, which may result in undefined behavior.

# Errors

This method returns the same errors as `Read::read_exact`.

# Examples

Read a sequence of big-endian single-precision floating point number from a `Read`:

    use std::f64;
    use std::io::Cursor;

    use byteorder::{BigEndian, ReadBytesExt};

    let mut rdr = Cursor::new(vec![
        0x40, 0x09, 0x21, 0xfb, 0x54, 0x44, 0x2d, 0x18,
        0x3f, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    ]);
    let mut dst = [0.0; 2];
    rdr.read_f64_into_unchecked::<BigEndian>(&mut dst).unwrap();
    assert_eq!([f64::consts::PI, 1.0], dst);

Loading content...

## Implementors

### `impl<R: Read + ?Sized> ReadBytesExt for R`[src]

All types that implement `Read` get methods defined in `ReadBytesExt` for free.

Loading content...

# Help

## Keyboard Shortcuts

`?`
  Show this help dialog
`S`
  Focus the search field
`↑`
  Move up in search results
`↓`
  Move down in search results
`↹`
  Switch tab
`⏎`
  Go to active search result
`+`
  Expand all sections
`-`
  Collapse all sections

## Search Tricks

Prefix searches with a type followed by a colon (e.g., `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g., `vec -> usize` or `* -> vec`)

Search multiple things at once by splitting your query with comma (e.g., `str,u8` or `String,struct:Vec,test`)