2023-09-20 21:35:15 +02:00
<!DOCTYPE html> < html lang = "en" > < head > < meta charset = "utf-8" > < meta name = "viewport" content = "width=device-width, initial-scale=1.0" > < meta name = "generator" content = "rustdoc" > < meta name = "description" content = "`ByteOrder` describes types that can serialize integers as bytes." > < title > ByteOrder in byteorder - Rust< / title > < link rel = "preload" as = "font" type = "font/woff2" crossorigin href = "../static.files/SourceSerif4-Regular-46f98efaafac5295.ttf.woff2" > < link rel = "preload" as = "font" type = "font/woff2" crossorigin href = "../static.files/FiraSans-Regular-018c141bf0843ffd.woff2" > < link rel = "preload" as = "font" type = "font/woff2" crossorigin href = "../static.files/FiraSans-Medium-8f9a781e4970d388.woff2" > < link rel = "preload" as = "font" type = "font/woff2" crossorigin href = "../static.files/SourceCodePro-Regular-562dcc5011b6de7d.ttf.woff2" > < link rel = "preload" as = "font" type = "font/woff2" crossorigin href = "../static.files/SourceSerif4-Bold-a2c9cd1067f8b328.ttf.woff2" > < link rel = "preload" as = "font" type = "font/woff2" crossorigin href = "../static.files/SourceCodePro-Semibold-d899c5a5c4aeb14a.ttf.woff2" > < link rel = "stylesheet" href = "../static.files/normalize-76eba96aa4d2e634.css" > < link rel = "stylesheet" href = "../static.files/rustdoc-47e7ab555ef2818a.css" > < meta name = "rustdoc-vars" data-root-path = "../" data-static-root-path = "../static.files/" data-current-crate = "byteorder" data-themes = "" data-resource-suffix = "" data-rustdoc-version = "1.74.0-nightly (d9c8274fb 2023-09-12)" data-channel = "nightly" data-search-js = "search-5d3eaacf19ebf04f.js" data-settings-js = "settings-74424d7eec62a23e.js" data-settings-css = "settings-8c76f75bfb6bd192.css" data-theme-light-css = "light-f194925aa375ae96.css" data-theme-dark-css = "dark-1dd4d1ce031e15de.css" data-theme-ayu-css = "ayu-49e58d069f567085.css" > < script src = "../static.files/storage-db41da1a38ea3cb8.js" > < / script > < script defer src = "sidebar-items.js" > < / script > < script defer src = "../static.files/main-8d035c8cea6edbc4.js" > < / script > < noscript > < link rel = "stylesheet" media = "(prefers-color-scheme:light)" href = "../static.files/light-f194925aa375ae96.css" > < link rel = "stylesheet" media = "(prefers-color-scheme:dark)" href = "../static.files/dark-1dd4d1ce031e15de.css" > < link rel = "stylesheet" href = "../static.files/noscript-cffde32267a19fd6.css" > < / noscript > < link rel = "alternate icon" type = "image/png" href = "../static.files/favicon-16x16-8b506e7a72182f1c.png" > < link rel = "alternate icon" type = "image/png" href = "../static.files/favicon-32x32-422f7d1d52889060.png" > < link rel = "icon" type = "image/svg+xml" href = "../static.files/favicon-2c020d218678b618.svg" > < / head > < body class = "rustdoc trait" > <!-- [if lte IE 11]><div class="warning">This old browser is unsupported and will most likely display funky things.</div><![endif] --> < nav class = "mobile-topbar" > < button class = "sidebar-menu-toggle" > ☰ < / button > < a class = "logo-container" href = "../byteorder/index.html" > < img class = "rust-logo" src = "../static.files/rust-logo-151179464ae7ed46.svg" alt = "logo" > < / a > < h2 > < / h2 > < / nav > < nav class = "sidebar" > < a class = "logo-container" href = "../byteorder/index.html" > < img class = "rust-logo" src = "../static.files/rust-logo-151179464ae7ed46.svg" alt = "logo" > < / a > < h2 class = "location" > < a href = "#" > ByteOrder< / a > < / h2 > < div class = "sidebar-elems" > < section > < h3 > < a href = "#required-methods" > Required Methods< / a > < / h3 > < ul class = "block" > < li > < a href = "#tymethod.from_slice_f32" > from_slice_f32< / a > < / li > < li > < a href = "#tymethod.from_slice_f64" > from_slice_f64< / a > < / li > < li > < a href = "#tymethod.from_slice_u128" > from_slice_u128< / a > < / li > < li > < a href = "#tymethod.from_slice_u16" > from_slice_u16< / a > < / li > < li > < a href = "#tymethod.from_slice_u32" > from_slice_u32< / a > < / li > < li > < a href = "#tymethod.from_slice_u64" > from_slice_u64< / a > < / li > < li > < a href = "#tymethod.read_u128" > read_u128< / a > < / li > < li > < a href = "#tymethod.read_u128_into" > read_u128_into< / a > < / li > < li > < a href = "#tymethod.read_u16" > read_u16< / a > < / li > < li > < a href = "#tymethod.read_u16_into" > read_u16_into< / a > < / li > < li > < a href = "#tymethod.read_u32" > read_u32< / a > < / li > < li > < a href = "#tymethod.read_u32_into" > read_u32_into< / a > < / li > < li > < a href = "#tymethod.read_u64" > read_u64< / a > < / li > < li > < a href = "#tymethod.read_u64_into" > re
2023-08-19 19:14:32 +02:00
< details class = "toggle type-contents-toggle" > < summary class = "hideme" > < span > Show 69 methods< / span > < / summary > // Required methods
fn < a href = "#tymethod.read_u16" class = "fn" > read_u16< / a > (buf: & [u8]) -> u16;
< span class = "item-spacer" > < / span > fn < a href = "#tymethod.read_u32" class = "fn" > read_u32< / a > (buf: & [u8]) -> u32;
< span class = "item-spacer" > < / span > fn < a href = "#tymethod.read_u64" class = "fn" > read_u64< / a > (buf: & [u8]) -> u64;
< span class = "item-spacer" > < / span > fn < a href = "#tymethod.read_u128" class = "fn" > read_u128< / a > (buf: & [u8]) -> u128;
< span class = "item-spacer" > < / span > fn < a href = "#tymethod.read_uint" class = "fn" > read_uint< / a > (buf: & [u8], nbytes: usize) -> u64;
< span class = "item-spacer" > < / span > fn < a href = "#tymethod.read_uint128" class = "fn" > read_uint128< / a > (buf: & [u8], nbytes: usize) -> u128;
< span class = "item-spacer" > < / span > fn < a href = "#tymethod.write_u16" class = "fn" > write_u16< / a > (buf: & mut [u8], n: u16);
< span class = "item-spacer" > < / span > fn < a href = "#tymethod.write_u32" class = "fn" > write_u32< / a > (buf: & mut [u8], n: u32);
< span class = "item-spacer" > < / span > fn < a href = "#tymethod.write_u64" class = "fn" > write_u64< / a > (buf: & mut [u8], n: u64);
< span class = "item-spacer" > < / span > fn < a href = "#tymethod.write_u128" class = "fn" > write_u128< / a > (buf: & mut [u8], n: u128);
< span class = "item-spacer" > < / span > fn < a href = "#tymethod.write_uint" class = "fn" > write_uint< / a > (buf: & mut [u8], n: u64, nbytes: usize);
< span class = "item-spacer" > < / span > fn < a href = "#tymethod.write_uint128" class = "fn" > write_uint128< / a > (buf: & mut [u8], n: u128, nbytes: usize);
< span class = "item-spacer" > < / span > fn < a href = "#tymethod.read_u16_into" class = "fn" > read_u16_into< / a > (src: & [u8], dst: & mut [u16]);
< span class = "item-spacer" > < / span > fn < a href = "#tymethod.read_u32_into" class = "fn" > read_u32_into< / a > (src: & [u8], dst: & mut [u32]);
< span class = "item-spacer" > < / span > fn < a href = "#tymethod.read_u64_into" class = "fn" > read_u64_into< / a > (src: & [u8], dst: & mut [u64]);
< span class = "item-spacer" > < / span > fn < a href = "#tymethod.read_u128_into" class = "fn" > read_u128_into< / a > (src: & [u8], dst: & mut [u128]);
< span class = "item-spacer" > < / span > fn < a href = "#tymethod.write_u16_into" class = "fn" > write_u16_into< / a > (src: & [u16], dst: & mut [u8]);
< span class = "item-spacer" > < / span > fn < a href = "#tymethod.write_u32_into" class = "fn" > write_u32_into< / a > (src: & [u32], dst: & mut [u8]);
< span class = "item-spacer" > < / span > fn < a href = "#tymethod.write_u64_into" class = "fn" > write_u64_into< / a > (src: & [u64], dst: & mut [u8]);
< span class = "item-spacer" > < / span > fn < a href = "#tymethod.write_u128_into" class = "fn" > write_u128_into< / a > (src: & [u128], dst: & mut [u8]);
< span class = "item-spacer" > < / span > fn < a href = "#tymethod.from_slice_u16" class = "fn" > from_slice_u16< / a > (numbers: & mut [u16]);
< span class = "item-spacer" > < / span > fn < a href = "#tymethod.from_slice_u32" class = "fn" > from_slice_u32< / a > (numbers: & mut [u32]);
< span class = "item-spacer" > < / span > fn < a href = "#tymethod.from_slice_u64" class = "fn" > from_slice_u64< / a > (numbers: & mut [u64]);
< span class = "item-spacer" > < / span > fn < a href = "#tymethod.from_slice_u128" class = "fn" > from_slice_u128< / a > (numbers: & mut [u128]);
< span class = "item-spacer" > < / span > fn < a href = "#tymethod.from_slice_f32" class = "fn" > from_slice_f32< / a > (numbers: & mut [f32]);
< span class = "item-spacer" > < / span > fn < a href = "#tymethod.from_slice_f64" class = "fn" > from_slice_f64< / a > (numbers: & mut [f64]);
// Provided methods
fn < a href = "#method.read_u24" class = "fn" > read_u24< / a > (buf: & [u8]) -> u32 { ... }
< span class = "item-spacer" > < / span > fn < a href = "#method.read_u48" class = "fn" > read_u48< / a > (buf: & [u8]) -> u64 { ... }
< span class = "item-spacer" > < / span > fn < a href = "#method.write_u24" class = "fn" > write_u24< / a > (buf: & mut [u8], n: u32) { ... }
< span class = "item-spacer" > < / span > fn < a href = "#method.write_u48" class = "fn" > write_u48< / a > (buf: & mut [u8], n: u64) { ... }
< span class = "item-spacer" > < / span > fn < a href = "#method.read_i16" class = "fn" > read_i16< / a > (buf: & [u8]) -> i16 { ... }
< span class = "item-spacer" > < / span > fn < a href = "#method.read_i24" class = "fn" > read_i24< / a > (buf: & [u8]) -> i32 { ... }
< span class = "item-spacer" > < / span > fn < a href = "#method.read_i32" class = "fn" > read_i32< / a > (buf: & [u8]) -> i32 { ... }
< span class = "item-spacer" > < / span > fn < a href = "#method.read_i48" class = "fn" > read_i48< / a > (buf: & [u8]) -> i64 { ... }
< span class = "item-spacer" > < / span > fn < a href = "#method.read_i64" class = "fn" > read_i64< / a > (buf: & [u8]) -> i64 { ... }
< span class = "item-spacer" > < / span > fn < a href = "#method.read_i128" class = "fn" > read_i128< / a > (buf: & [u8]) -> i128 { ... }
< span class = "item-spacer" > < / span > fn < a href = "#method.read_int" class = "fn" > read_int< / a > (buf: & [u8], nbytes: usize) -> i64 { ... }
< span class = "item-spacer" > < / span > fn < a href = "#method.read_int128" class = "fn" > read_int128< / a > (buf: & [u8], nbytes: usize) -> i128 { ... }
< span class = "item-spacer" > < / span > fn < a href = "#method.read_f32" class = "fn" > read_f32< / a > (buf: & [u8]) -> f32 { ... }
< span class = "item-spacer" > < / span > fn < a href = "#method.read_f64" class = "fn" > read_f64< / a > (buf: & [u8]) -> f64 { ... }
< span class = "item-spacer" > < / span > fn < a href = "#method.write_i16" class = "fn" > write_i16< / a > (buf: & mut [u8], n: i16) { ... }
< span class = "item-spacer" > < / span > fn < a href = "#method.write_i24" class = "fn" > write_i24< / a > (buf: & mut [u8], n: i32) { ... }
< span class = "item-spacer" > < / span > fn < a href = "#method.write_i32" class = "fn" > write_i32< / a > (buf: & mut [u8], n: i32) { ... }
< span class = "item-spacer" > < / span > fn < a href = "#method.write_i48" class = "fn" > write_i48< / a > (buf: & mut [u8], n: i64) { ... }
< span class = "item-spacer" > < / span > fn < a href = "#method.write_i64" class = "fn" > write_i64< / a > (buf: & mut [u8], n: i64) { ... }
< span class = "item-spacer" > < / span > fn < a href = "#method.write_i128" class = "fn" > write_i128< / a > (buf: & mut [u8], n: i128) { ... }
< span class = "item-spacer" > < / span > fn < a href = "#method.write_int" class = "fn" > write_int< / a > (buf: & mut [u8], n: i64, nbytes: usize) { ... }
< span class = "item-spacer" > < / span > fn < a href = "#method.write_int128" class = "fn" > write_int128< / a > (buf: & mut [u8], n: i128, nbytes: usize) { ... }
< span class = "item-spacer" > < / span > fn < a href = "#method.write_f32" class = "fn" > write_f32< / a > (buf: & mut [u8], n: f32) { ... }
< span class = "item-spacer" > < / span > fn < a href = "#method.write_f64" class = "fn" > write_f64< / a > (buf: & mut [u8], n: f64) { ... }
< span class = "item-spacer" > < / span > fn < a href = "#method.read_i16_into" class = "fn" > read_i16_into< / a > (src: & [u8], dst: & mut [i16]) { ... }
< span class = "item-spacer" > < / span > fn < a href = "#method.read_i32_into" class = "fn" > read_i32_into< / a > (src: & [u8], dst: & mut [i32]) { ... }
< span class = "item-spacer" > < / span > fn < a href = "#method.read_i64_into" class = "fn" > read_i64_into< / a > (src: & [u8], dst: & mut [i64]) { ... }
< span class = "item-spacer" > < / span > fn < a href = "#method.read_i128_into" class = "fn" > read_i128_into< / a > (src: & [u8], dst: & mut [i128]) { ... }
< span class = "item-spacer" > < / span > fn < a href = "#method.read_f32_into" class = "fn" > read_f32_into< / a > (src: & [u8], dst: & mut [f32]) { ... }
< span class = "item-spacer" > < / span > fn < a href = "#method.read_f32_into_unchecked" class = "fn" > read_f32_into_unchecked< / a > (src: & [u8], dst: & mut [f32]) { ... }
< span class = "item-spacer" > < / span > fn < a href = "#method.read_f64_into" class = "fn" > read_f64_into< / a > (src: & [u8], dst: & mut [f64]) { ... }
< span class = "item-spacer" > < / span > fn < a href = "#method.read_f64_into_unchecked" class = "fn" > read_f64_into_unchecked< / a > (src: & [u8], dst: & mut [f64]) { ... }
< span class = "item-spacer" > < / span > fn < a href = "#method.write_i8_into" class = "fn" > write_i8_into< / a > (src: & [i8], dst: & mut [u8]) { ... }
< span class = "item-spacer" > < / span > fn < a href = "#method.write_i16_into" class = "fn" > write_i16_into< / a > (src: & [i16], dst: & mut [u8]) { ... }
< span class = "item-spacer" > < / span > fn < a href = "#method.write_i32_into" class = "fn" > write_i32_into< / a > (src: & [i32], dst: & mut [u8]) { ... }
< span class = "item-spacer" > < / span > fn < a href = "#method.write_i64_into" class = "fn" > write_i64_into< / a > (src: & [i64], dst: & mut [u8]) { ... }
< span class = "item-spacer" > < / span > fn < a href = "#method.write_i128_into" class = "fn" > write_i128_into< / a > (src: & [i128], dst: & mut [u8]) { ... }
< span class = "item-spacer" > < / span > fn < a href = "#method.write_f32_into" class = "fn" > write_f32_into< / a > (src: & [f32], dst: & mut [u8]) { ... }
< span class = "item-spacer" > < / span > fn < a href = "#method.write_f64_into" class = "fn" > write_f64_into< / a > (src: & [f64], dst: & mut [u8]) { ... }
< span class = "item-spacer" > < / span > fn < a href = "#method.from_slice_i16" class = "fn" > from_slice_i16< / a > (src: & mut [i16]) { ... }
< span class = "item-spacer" > < / span > fn < a href = "#method.from_slice_i32" class = "fn" > from_slice_i32< / a > (src: & mut [i32]) { ... }
< span class = "item-spacer" > < / span > fn < a href = "#method.from_slice_i64" class = "fn" > from_slice_i64< / a > (src: & mut [i64]) { ... }
< span class = "item-spacer" > < / span > fn < a href = "#method.from_slice_i128" class = "fn" > from_slice_i128< / a > (src: & mut [i128]) { ... }
< / details > }< / code > < / pre > < details class = "toggle top-doc" open > < summary class = "hideme" > < span > Expand description< / span > < / summary > < div class = "docblock" > < p > < code > ByteOrder< / code > describes types that can serialize integers as bytes.< / p >
< p > Note that < code > Self< / code > does not appear anywhere in this trait’
Therefore, in order to use it, you’
< code > T::read_u16(& [0, 1])< / code > where < code > T< / code > implements < code > ByteOrder< / code > .< / p >
< p > This crate provides two types that implement < code > ByteOrder< / code > : < a href = "enum.BigEndian.html" > < code > BigEndian< / code > < / a >
and < a href = "enum.LittleEndian.html" > < code > LittleEndian< / code > < / a > .
This trait is sealed and cannot be implemented for callers to avoid
breaking backwards compatibility when adding new derived traits.< / p >
< h2 id = "examples" > < a href = "#examples" > Examples< / a > < / h2 >
< p > Write and read < code > u32< / code > numbers in little endian order:< / p >
< div class = "example-wrap" > < pre class = "rust rust-example-rendered" > < code > < span class = "kw" > use < / span > byteorder::{ByteOrder, LittleEndian};
< span class = "kw" > let < / span > < span class = "kw-2" > mut < / span > buf = [< span class = "number" > 0< / span > ; < span class = "number" > 4< / span > ];
LittleEndian::write_u32(< span class = "kw-2" > & mut < / span > buf, < span class = "number" > 1_000_000< / span > );
< span class = "macro" > assert_eq!< / span > (< span class = "number" > 1_000_000< / span > , LittleEndian::read_u32(< span class = "kw-2" > & < / span > buf));< / code > < / pre > < / div >
< p > Write and read < code > i16< / code > numbers in big endian order:< / p >
< div class = "example-wrap" > < pre class = "rust rust-example-rendered" > < code > < span class = "kw" > use < / span > byteorder::{ByteOrder, BigEndian};
< span class = "kw" > let < / span > < span class = "kw-2" > mut < / span > buf = [< span class = "number" > 0< / span > ; < span class = "number" > 2< / span > ];
BigEndian::write_i16(< span class = "kw-2" > & mut < / span > buf, -< span class = "number" > 5_000< / span > );
< span class = "macro" > assert_eq!< / span > (-< span class = "number" > 5_000< / span > , BigEndian::read_i16(< span class = "kw-2" > & < / span > buf));< / code > < / pre > < / div >
< / div > < / details > < h2 id = "required-methods" class = "small-section-header" > Required Methods< a href = "#required-methods" class = "anchor" > §< / a > < / h2 > < div class = "methods" > < details class = "toggle method-toggle" open > < summary > < section id = "tymethod.read_u16" class = "method" > < a class = "src rightside" href = "../src/byteorder/lib.rs.html#225" > source< / a > < h4 class = "code-header" > fn < a href = "#tymethod.read_u16" class = "fn" > read_u16< / a > (buf: & [u8]) -> u16< / h4 > < / section > < / summary > < div class = "docblock" > < p > Reads an unsigned 16 bit integer from < code > buf< / code > .< / p >
< h5 id = "panics" > < a href = "#panics" > Panics< / a > < / h5 >
< p > Panics when < code > buf.len() < 2< / code > .< / p >
< / div > < / details > < details class = "toggle method-toggle" open > < summary > < section id = "tymethod.read_u32" class = "method" > < a class = "src rightside" href = "../src/byteorder/lib.rs.html#265" > source< / a > < h4 class = "code-header" > fn < a href = "#tymethod.read_u32" class = "fn" > read_u32< / a > (buf: & [u8]) -> u32< / h4 > < / section > < / summary > < div class = "docblock" > < p > Reads an unsigned 32 bit integer from < code > buf< / code > .< / p >
< h5 id = "panics-1" > < a href = "#panics-1" > Panics< / a > < / h5 >
< p > Panics when < code > buf.len() < 4< / code > .< / p >
< h5 id = "examples-1" > < a href = "#examples-1" > Examples< / a > < / h5 >
< p > Write and read < code > u32< / code > numbers in little endian order:< / p >
< div class = "example-wrap" > < pre class = "rust rust-example-rendered" > < code > < span class = "kw" > use < / span > byteorder::{ByteOrder, LittleEndian};
< span class = "kw" > let < / span > < span class = "kw-2" > mut < / span > buf = [< span class = "number" > 0< / span > ; < span class = "number" > 4< / span > ];
LittleEndian::write_u32(< span class = "kw-2" > & mut < / span > buf, < span class = "number" > 1_000_000< / span > );
< span class = "macro" > assert_eq!< / span > (< span class = "number" > 1_000_000< / span > , LittleEndian::read_u32(< span class = "kw-2" > & < / span > buf));< / code > < / pre > < / div >
< / div > < / details > < details class = "toggle method-toggle" open > < summary > < section id = "tymethod.read_u64" class = "method" > < a class = "src rightside" href = "../src/byteorder/lib.rs.html#305" > source< / a > < h4 class = "code-header" > fn < a href = "#tymethod.read_u64" class = "fn" > read_u64< / a > (buf: & [u8]) -> u64< / h4 > < / section > < / summary > < div class = "docblock" > < p > Reads an unsigned 64 bit integer from < code > buf< / code > .< / p >
< h5 id = "panics-2" > < a href = "#panics-2" > Panics< / a > < / h5 >
< p > Panics when < code > buf.len() < 8< / code > .< / p >
< h5 id = "examples-2" > < a href = "#examples-2" > Examples< / a > < / h5 >
< p > Write and read < code > u64< / code > numbers in little endian order:< / p >
< div class = "example-wrap" > < pre class = "rust rust-example-rendered" > < code > < span class = "kw" > use < / span > byteorder::{ByteOrder, LittleEndian};
< span class = "kw" > let < / span > < span class = "kw-2" > mut < / span > buf = [< span class = "number" > 0< / span > ; < span class = "number" > 8< / span > ];
LittleEndian::write_u64(< span class = "kw-2" > & mut < / span > buf, < span class = "number" > 1_000_000< / span > );
< span class = "macro" > assert_eq!< / span > (< span class = "number" > 1_000_000< / span > , LittleEndian::read_u64(< span class = "kw-2" > & < / span > buf));< / code > < / pre > < / div >
< / div > < / details > < details class = "toggle method-toggle" open > < summary > < section id = "tymethod.read_u128" class = "method" > < a class = "src rightside" href = "../src/byteorder/lib.rs.html#324" > source< / a > < h4 class = "code-header" > fn < a href = "#tymethod.read_u128" class = "fn" > read_u128< / a > (buf: & [u8]) -> u128< / h4 > < / section > < / summary > < div class = "docblock" > < p > Reads an unsigned 128 bit integer from < code > buf< / code > .< / p >
< h5 id = "panics-3" > < a href = "#panics-3" > Panics< / a > < / h5 >
< p > Panics when < code > buf.len() < 16< / code > .< / p >
< h5 id = "examples-3" > < a href = "#examples-3" > Examples< / a > < / h5 >
< p > Write and read < code > u128< / code > numbers in little endian order:< / p >
< div class = "example-wrap" > < pre class = "rust rust-example-rendered" > < code > < span class = "kw" > use < / span > byteorder::{ByteOrder, LittleEndian};
< span class = "kw" > let < / span > < span class = "kw-2" > mut < / span > buf = [< span class = "number" > 0< / span > ; < span class = "number" > 16< / span > ];
LittleEndian::write_u128(< span class = "kw-2" > & mut < / span > buf, < span class = "number" > 1_000_000< / span > );
< span class = "macro" > assert_eq!< / span > (< span class = "number" > 1_000_000< / span > , LittleEndian::read_u128(< span class = "kw-2" > & < / span > buf));< / code > < / pre > < / div >
< / div > < / details > < details class = "toggle method-toggle" open > < summary > < section id = "tymethod.read_uint" class = "method" > < a class = "src rightside" href = "../src/byteorder/lib.rs.html#344" > source< / a > < h4 class = "code-header" > fn < a href = "#tymethod.read_uint" class = "fn" > read_uint< / a > (buf: & [u8], nbytes: usize) -> u64< / h4 > < / section > < / summary > < div class = "docblock" > < p > Reads an unsigned n-bytes integer from < code > buf< / code > .< / p >
< h5 id = "panics-4" > < a href = "#panics-4" > Panics< / a > < / h5 >
< p > Panics when < code > nbytes < 1< / code > or < code > nbytes > 8< / code > or
< code > buf.len() < nbytes< / code > < / p >
< h5 id = "examples-4" > < a href = "#examples-4" > Examples< / a > < / h5 >
< p > Write and read an n-byte number in little endian order:< / p >
< div class = "example-wrap" > < pre class = "rust rust-example-rendered" > < code > < span class = "kw" > use < / span > byteorder::{ByteOrder, LittleEndian};
< span class = "kw" > let < / span > < span class = "kw-2" > mut < / span > buf = [< span class = "number" > 0< / span > ; < span class = "number" > 3< / span > ];
LittleEndian::write_uint(< span class = "kw-2" > & mut < / span > buf, < span class = "number" > 1_000_000< / span > , < span class = "number" > 3< / span > );
< span class = "macro" > assert_eq!< / span > (< span class = "number" > 1_000_000< / span > , LittleEndian::read_uint(< span class = "kw-2" > & < / span > buf, < span class = "number" > 3< / span > ));< / code > < / pre > < / div >
< / div > < / details > < details class = "toggle method-toggle" open > < summary > < section id = "tymethod.read_uint128" class = "method" > < a class = "src rightside" href = "../src/byteorder/lib.rs.html#364" > source< / a > < h4 class = "code-header" > fn < a href = "#tymethod.read_uint128" class = "fn" > read_uint128< / a > (buf: & [u8], nbytes: usize) -> u128< / h4 > < / section > < / summary > < div class = "docblock" > < p > Reads an unsigned n-bytes integer from < code > buf< / code > .< / p >
< h5 id = "panics-5" > < a href = "#panics-5" > Panics< / a > < / h5 >
< p > Panics when < code > nbytes < 1< / code > or < code > nbytes > 16< / code > or
< code > buf.len() < nbytes< / code > < / p >
< h5 id = "examples-5" > < a href = "#examples-5" > Examples< / a > < / h5 >
< p > Write and read an n-byte number in little endian order:< / p >
< div class = "example-wrap" > < pre class = "rust rust-example-rendered" > < code > < span class = "kw" > use < / span > byteorder::{ByteOrder, LittleEndian};
< span class = "kw" > let < / span > < span class = "kw-2" > mut < / span > buf = [< span class = "number" > 0< / span > ; < span class = "number" > 3< / span > ];
LittleEndian::write_uint128(< span class = "kw-2" > & mut < / span > buf, < span class = "number" > 1_000_000< / span > , < span class = "number" > 3< / span > );
< span class = "macro" > assert_eq!< / span > (< span class = "number" > 1_000_000< / span > , LittleEndian::read_uint128(< span class = "kw-2" > & < / span > buf, < span class = "number" > 3< / span > ));< / code > < / pre > < / div >
< / div > < / details > < details class = "toggle method-toggle" open > < summary > < section id = "tymethod.write_u16" class = "method" > < a class = "src rightside" href = "../src/byteorder/lib.rs.html#383" > source< / a > < h4 class = "code-header" > fn < a href = "#tymethod.write_u16" class = "fn" > write_u16< / a > (buf: & mut [u8], n: u16)< / h4 > < / section > < / summary > < div class = "docblock" > < p > Writes an unsigned 16 bit integer < code > n< / code > to < code > buf< / code > .< / p >
< h5 id = "panics-6" > < a href = "#panics-6" > Panics< / a > < / h5 >
< p > Panics when < code > buf.len() < 2< / code > .< / p >
< h5 id = "examples-6" > < a href = "#examples-6" > Examples< / a > < / h5 >
< p > Write and read < code > u16< / code > numbers in little endian order:< / p >
< div class = "example-wrap" > < pre class = "rust rust-example-rendered" > < code > < span class = "kw" > use < / span > byteorder::{ByteOrder, LittleEndian};
< span class = "kw" > let < / span > < span class = "kw-2" > mut < / span > buf = [< span class = "number" > 0< / span > ; < span class = "number" > 2< / span > ];
LittleEndian::write_u16(< span class = "kw-2" > & mut < / span > buf, < span class = "number" > 1_000< / span > );
< span class = "macro" > assert_eq!< / span > (< span class = "number" > 1_000< / span > , LittleEndian::read_u16(< span class = "kw-2" > & < / span > buf));< / code > < / pre > < / div >
< / div > < / details > < details class = "toggle method-toggle" open > < summary > < section id = "tymethod.write_u32" class = "method" > < a class = "src rightside" href = "../src/byteorder/lib.rs.html#423" > source< / a > < h4 class = "code-header" > fn < a href = "#tymethod.write_u32" class = "fn" > write_u32< / a > (buf: & mut [u8], n: u32)< / h4 > < / section > < / summary > < div class = "docblock" > < p > Writes an unsigned 32 bit integer < code > n< / code > to < code > buf< / code > .< / p >
< h5 id = "panics-7" > < a href = "#panics-7" > Panics< / a > < / h5 >
< p > Panics when < code > buf.len() < 4< / code > .< / p >
< h5 id = "examples-7" > < a href = "#examples-7" > Examples< / a > < / h5 >
< p > Write and read < code > u32< / code > numbers in little endian order:< / p >
< div class = "example-wrap" > < pre class = "rust rust-example-rendered" > < code > < span class = "kw" > use < / span > byteorder::{ByteOrder, LittleEndian};
< span class = "kw" > let < / span > < span class = "kw-2" > mut < / span > buf = [< span class = "number" > 0< / span > ; < span class = "number" > 4< / span > ];
LittleEndian::write_u32(< span class = "kw-2" > & mut < / span > buf, < span class = "number" > 1_000_000< / span > );
< span class = "macro" > assert_eq!< / span > (< span class = "number" > 1_000_000< / span > , LittleEndian::read_u32(< span class = "kw-2" > & < / span > buf));< / code > < / pre > < / div >
< / div > < / details > < details class = "toggle method-toggle" open > < summary > < section id = "tymethod.write_u64" class = "method" > < a class = "src rightside" href = "../src/byteorder/lib.rs.html#463" > source< / a > < h4 class = "code-header" > fn < a href = "#tymethod.write_u64" class = "fn" > write_u64< / a > (buf: & mut [u8], n: u64)< / h4 > < / section > < / summary > < div class = "docblock" > < p > Writes an unsigned 64 bit integer < code > n< / code > to < code > buf< / code > .< / p >
< h5 id = "panics-8" > < a href = "#panics-8" > Panics< / a > < / h5 >
< p > Panics when < code > buf.len() < 8< / code > .< / p >
< h5 id = "examples-8" > < a href = "#examples-8" > Examples< / a > < / h5 >
< p > Write and read < code > u64< / code > numbers in little endian order:< / p >
< div class = "example-wrap" > < pre class = "rust rust-example-rendered" > < code > < span class = "kw" > use < / span > byteorder::{ByteOrder, LittleEndian};
< span class = "kw" > let < / span > < span class = "kw-2" > mut < / span > buf = [< span class = "number" > 0< / span > ; < span class = "number" > 8< / span > ];
LittleEndian::write_u64(< span class = "kw-2" > & mut < / span > buf, < span class = "number" > 1_000_000< / span > );
< span class = "macro" > assert_eq!< / span > (< span class = "number" > 1_000_000< / span > , LittleEndian::read_u64(< span class = "kw-2" > & < / span > buf));< / code > < / pre > < / div >
< / div > < / details > < details class = "toggle method-toggle" open > < summary > < section id = "tymethod.write_u128" class = "method" > < a class = "src rightside" href = "../src/byteorder/lib.rs.html#482" > source< / a > < h4 class = "code-header" > fn < a href = "#tymethod.write_u128" class = "fn" > write_u128< / a > (buf: & mut [u8], n: u128)< / h4 > < / section > < / summary > < div class = "docblock" > < p > Writes an unsigned 128 bit integer < code > n< / code > to < code > buf< / code > .< / p >
< h5 id = "panics-9" > < a href = "#panics-9" > Panics< / a > < / h5 >
< p > Panics when < code > buf.len() < 16< / code > .< / p >
< h5 id = "examples-9" > < a href = "#examples-9" > Examples< / a > < / h5 >
< p > Write and read < code > u128< / code > numbers in little endian order:< / p >
< div class = "example-wrap" > < pre class = "rust rust-example-rendered" > < code > < span class = "kw" > use < / span > byteorder::{ByteOrder, LittleEndian};
< span class = "kw" > let < / span > < span class = "kw-2" > mut < / span > buf = [< span class = "number" > 0< / span > ; < span class = "number" > 16< / span > ];
LittleEndian::write_u128(< span class = "kw-2" > & mut < / span > buf, < span class = "number" > 1_000_000< / span > );
< span class = "macro" > assert_eq!< / span > (< span class = "number" > 1_000_000< / span > , LittleEndian::read_u128(< span class = "kw-2" > & < / span > buf));< / code > < / pre > < / div >
< / div > < / details > < details class = "toggle method-toggle" open > < summary > < section id = "tymethod.write_uint" class = "method" > < a class = "src rightside" href = "../src/byteorder/lib.rs.html#502" > source< / a > < h4 class = "code-header" > fn < a href = "#tymethod.write_uint" class = "fn" > write_uint< / a > (buf: & mut [u8], n: u64, nbytes: usize)< / h4 > < / section > < / summary > < div class = "docblock" > < p > Writes an unsigned integer < code > n< / code > to < code > buf< / code > using only < code > nbytes< / code > .< / p >
< h5 id = "panics-10" > < a href = "#panics-10" > Panics< / a > < / h5 >
< p > If < code > n< / code > is not representable in < code > nbytes< / code > , or if < code > nbytes< / code > is < code > > 8< / code > , then
this method panics.< / p >
< h5 id = "examples-10" > < a href = "#examples-10" > Examples< / a > < / h5 >
< p > Write and read an n-byte number in little endian order:< / p >
< div class = "example-wrap" > < pre class = "rust rust-example-rendered" > < code > < span class = "kw" > use < / span > byteorder::{ByteOrder, LittleEndian};
< span class = "kw" > let < / span > < span class = "kw-2" > mut < / span > buf = [< span class = "number" > 0< / span > ; < span class = "number" > 3< / span > ];
LittleEndian::write_uint(< span class = "kw-2" > & mut < / span > buf, < span class = "number" > 1_000_000< / span > , < span class = "number" > 3< / span > );
< span class = "macro" > assert_eq!< / span > (< span class = "number" > 1_000_000< / span > , LittleEndian::read_uint(< span class = "kw-2" > & < / span > buf, < span class = "number" > 3< / span > ));< / code > < / pre > < / div >
< / div > < / details > < details class = "toggle method-toggle" open > < summary > < section id = "tymethod.write_uint128" class = "method" > < a class = "src rightside" href = "../src/byteorder/lib.rs.html#522" > source< / a > < h4 class = "code-header" > fn < a href = "#tymethod.write_uint128" class = "fn" > write_uint128< / a > (buf: & mut [u8], n: u128, nbytes: usize)< / h4 > < / section > < / summary > < div class = "docblock" > < p > Writes an unsigned integer < code > n< / code > to < code > buf< / code > using only < code > nbytes< / code > .< / p >
< h5 id = "panics-11" > < a href = "#panics-11" > Panics< / a > < / h5 >
< p > If < code > n< / code > is not representable in < code > nbytes< / code > , or if < code > nbytes< / code > is < code > > 16< / code > , then
this method panics.< / p >
< h5 id = "examples-11" > < a href = "#examples-11" > Examples< / a > < / h5 >
< p > Write and read an n-byte number in little endian order:< / p >
< div class = "example-wrap" > < pre class = "rust rust-example-rendered" > < code > < span class = "kw" > use < / span > byteorder::{ByteOrder, LittleEndian};
< span class = "kw" > let < / span > < span class = "kw-2" > mut < / span > buf = [< span class = "number" > 0< / span > ; < span class = "number" > 3< / span > ];
LittleEndian::write_uint128(< span class = "kw-2" > & mut < / span > buf, < span class = "number" > 1_000_000< / span > , < span class = "number" > 3< / span > );
< span class = "macro" > assert_eq!< / span > (< span class = "number" > 1_000_000< / span > , LittleEndian::read_uint128(< span class = "kw-2" > & < / span > buf, < span class = "number" > 3< / span > ));< / code > < / pre > < / div >
< / div > < / details > < details class = "toggle method-toggle" open > < summary > < section id = "tymethod.read_u16_into" class = "method" > < a class = "src rightside" href = "../src/byteorder/lib.rs.html#993" > source< / a > < h4 class = "code-header" > fn < a href = "#tymethod.read_u16_into" class = "fn" > read_u16_into< / a > (src: & [u8], dst: & mut [u16])< / h4 > < / section > < / summary > < div class = "docblock" > < p > Reads unsigned 16 bit integers from < code > src< / code > into < code > dst< / code > .< / p >
< h5 id = "panics-12" > < a href = "#panics-12" > Panics< / a > < / h5 >
< p > Panics when < code > src.len() != 2*dst.len()< / code > .< / p >
< h5 id = "examples-12" > < a href = "#examples-12" > Examples< / a > < / h5 >
< p > Write and read < code > u16< / code > numbers in little endian order:< / p >
< div class = "example-wrap" > < pre class = "rust rust-example-rendered" > < code > < span class = "kw" > use < / span > byteorder::{ByteOrder, LittleEndian};
< span class = "kw" > let < / span > < span class = "kw-2" > mut < / span > bytes = [< span class = "number" > 0< / span > ; < span class = "number" > 8< / span > ];
< span class = "kw" > let < / span > numbers_given = [< span class = "number" > 1< / span > , < span class = "number" > 2< / span > , < span class = "number" > 0xf00f< / span > , < span class = "number" > 0xffee< / span > ];
LittleEndian::write_u16_into(< span class = "kw-2" > & < / span > numbers_given, < span class = "kw-2" > & mut < / span > bytes);
< span class = "kw" > let < / span > < span class = "kw-2" > mut < / span > numbers_got = [< span class = "number" > 0< / span > ; < span class = "number" > 4< / span > ];
LittleEndian::read_u16_into(< span class = "kw-2" > & < / span > bytes, < span class = "kw-2" > & mut < / span > numbers_got);
< span class = "macro" > assert_eq!< / span > (numbers_given, numbers_got);< / code > < / pre > < / div >
< / div > < / details > < details class = "toggle method-toggle" open > < summary > < section id = "tymethod.read_u32_into" class = "method" > < a class = "src rightside" href = "../src/byteorder/lib.rs.html#1016" > source< / a > < h4 class = "code-header" > fn < a href = "#tymethod.read_u32_into" class = "fn" > read_u32_into< / a > (src: & [u8], dst: & mut [u32])< / h4 > < / section > < / summary > < div class = "docblock" > < p > Reads unsigned 32 bit integers from < code > src< / code > into < code > dst< / code > .< / p >
< h5 id = "panics-13" > < a href = "#panics-13" > Panics< / a > < / h5 >
< p > Panics when < code > src.len() != 4*dst.len()< / code > .< / p >
< h5 id = "examples-13" > < a href = "#examples-13" > Examples< / a > < / h5 >
< p > Write and read < code > u32< / code > numbers in little endian order:< / p >
< div class = "example-wrap" > < pre class = "rust rust-example-rendered" > < code > < span class = "kw" > use < / span > byteorder::{ByteOrder, LittleEndian};
< span class = "kw" > let < / span > < span class = "kw-2" > mut < / span > bytes = [< span class = "number" > 0< / span > ; < span class = "number" > 16< / span > ];
< span class = "kw" > let < / span > numbers_given = [< span class = "number" > 1< / span > , < span class = "number" > 2< / span > , < span class = "number" > 0xf00f< / span > , < span class = "number" > 0xffee< / span > ];
LittleEndian::write_u32_into(< span class = "kw-2" > & < / span > numbers_given, < span class = "kw-2" > & mut < / span > bytes);
< span class = "kw" > let < / span > < span class = "kw-2" > mut < / span > numbers_got = [< span class = "number" > 0< / span > ; < span class = "number" > 4< / span > ];
LittleEndian::read_u32_into(< span class = "kw-2" > & < / span > bytes, < span class = "kw-2" > & mut < / span > numbers_got);
< span class = "macro" > assert_eq!< / span > (numbers_given, numbers_got);< / code > < / pre > < / div >
< / div > < / details > < details class = "toggle method-toggle" open > < summary > < section id = "tymethod.read_u64_into" class = "method" > < a class = "src rightside" href = "../src/byteorder/lib.rs.html#1039" > source< / a > < h4 class = "code-header" > fn < a href = "#tymethod.read_u64_into" class = "fn" > read_u64_into< / a > (src: & [u8], dst: & mut [u64])< / h4 > < / section > < / summary > < div class = "docblock" > < p > Reads unsigned 64 bit integers from < code > src< / code > into < code > dst< / code > .< / p >
< h5 id = "panics-14" > < a href = "#panics-14" > Panics< / a > < / h5 >
< p > Panics when < code > src.len() != 8*dst.len()< / code > .< / p >
< h5 id = "examples-14" > < a href = "#examples-14" > Examples< / a > < / h5 >
< p > Write and read < code > u64< / code > numbers in little endian order:< / p >
< div class = "example-wrap" > < pre class = "rust rust-example-rendered" > < code > < span class = "kw" > use < / span > byteorder::{ByteOrder, LittleEndian};
< span class = "kw" > let < / span > < span class = "kw-2" > mut < / span > bytes = [< span class = "number" > 0< / span > ; < span class = "number" > 32< / span > ];
< span class = "kw" > let < / span > numbers_given = [< span class = "number" > 1< / span > , < span class = "number" > 2< / span > , < span class = "number" > 0xf00f< / span > , < span class = "number" > 0xffee< / span > ];
LittleEndian::write_u64_into(< span class = "kw-2" > & < / span > numbers_given, < span class = "kw-2" > & mut < / span > bytes);
< span class = "kw" > let < / span > < span class = "kw-2" > mut < / span > numbers_got = [< span class = "number" > 0< / span > ; < span class = "number" > 4< / span > ];
LittleEndian::read_u64_into(< span class = "kw-2" > & < / span > bytes, < span class = "kw-2" > & mut < / span > numbers_got);
< span class = "macro" > assert_eq!< / span > (numbers_given, numbers_got);< / code > < / pre > < / div >
< / div > < / details > < details class = "toggle method-toggle" open > < summary > < section id = "tymethod.read_u128_into" class = "method" > < a class = "src rightside" href = "../src/byteorder/lib.rs.html#1062" > source< / a > < h4 class = "code-header" > fn < a href = "#tymethod.read_u128_into" class = "fn" > read_u128_into< / a > (src: & [u8], dst: & mut [u128])< / h4 > < / section > < / summary > < div class = "docblock" > < p > Reads unsigned 128 bit integers from < code > src< / code > into < code > dst< / code > .< / p >
< h5 id = "panics-15" > < a href = "#panics-15" > Panics< / a > < / h5 >
< p > Panics when < code > src.len() != 16*dst.len()< / code > .< / p >
< h5 id = "examples-15" > < a href = "#examples-15" > Examples< / a > < / h5 >
< p > Write and read < code > u128< / code > numbers in little endian order:< / p >
< div class = "example-wrap" > < pre class = "rust rust-example-rendered" > < code > < span class = "kw" > use < / span > byteorder::{ByteOrder, LittleEndian};
< span class = "kw" > let < / span > < span class = "kw-2" > mut < / span > bytes = [< span class = "number" > 0< / span > ; < span class = "number" > 64< / span > ];
< span class = "kw" > let < / span > numbers_given = [< span class = "number" > 1< / span > , < span class = "number" > 2< / span > , < span class = "number" > 0xf00f< / span > , < span class = "number" > 0xffee< / span > ];
LittleEndian::write_u128_into(< span class = "kw-2" > & < / span > numbers_given, < span class = "kw-2" > & mut < / span > bytes);
< span class = "kw" > let < / span > < span class = "kw-2" > mut < / span > numbers_got = [< span class = "number" > 0< / span > ; < span class = "number" > 4< / span > ];
LittleEndian::read_u128_into(< span class = "kw-2" > & < / span > bytes, < span class = "kw-2" > & mut < / span > numbers_got);
< span class = "macro" > assert_eq!< / span > (numbers_given, numbers_got);< / code > < / pre > < / div >
< / div > < / details > < details class = "toggle method-toggle" open > < summary > < section id = "tymethod.write_u16_into" class = "method" > < a class = "src rightside" href = "../src/byteorder/lib.rs.html#1324" > source< / a > < h4 class = "code-header" > fn < a href = "#tymethod.write_u16_into" class = "fn" > write_u16_into< / a > (src: & [u16], dst: & mut [u8])< / h4 > < / section > < / summary > < div class = "docblock" > < p > Writes unsigned 16 bit integers from < code > src< / code > into < code > dst< / code > .< / p >
< h5 id = "panics-16" > < a href = "#panics-16" > Panics< / a > < / h5 >
< p > Panics when < code > dst.len() != 2*src.len()< / code > .< / p >
< h5 id = "examples-16" > < a href = "#examples-16" > Examples< / a > < / h5 >
< p > Write and read < code > u16< / code > numbers in little endian order:< / p >
< div class = "example-wrap" > < pre class = "rust rust-example-rendered" > < code > < span class = "kw" > use < / span > byteorder::{ByteOrder, LittleEndian};
< span class = "kw" > let < / span > < span class = "kw-2" > mut < / span > bytes = [< span class = "number" > 0< / span > ; < span class = "number" > 8< / span > ];
< span class = "kw" > let < / span > numbers_given = [< span class = "number" > 1< / span > , < span class = "number" > 2< / span > , < span class = "number" > 0xf00f< / span > , < span class = "number" > 0xffee< / span > ];
LittleEndian::write_u16_into(< span class = "kw-2" > & < / span > numbers_given, < span class = "kw-2" > & mut < / span > bytes);
< span class = "kw" > let < / span > < span class = "kw-2" > mut < / span > numbers_got = [< span class = "number" > 0< / span > ; < span class = "number" > 4< / span > ];
LittleEndian::read_u16_into(< span class = "kw-2" > & < / span > bytes, < span class = "kw-2" > & mut < / span > numbers_got);
< span class = "macro" > assert_eq!< / span > (numbers_given, numbers_got);< / code > < / pre > < / div >
< / div > < / details > < details class = "toggle method-toggle" open > < summary > < section id = "tymethod.write_u32_into" class = "method" > < a class = "src rightside" href = "../src/byteorder/lib.rs.html#1347" > source< / a > < h4 class = "code-header" > fn < a href = "#tymethod.write_u32_into" class = "fn" > write_u32_into< / a > (src: & [u32], dst: & mut [u8])< / h4 > < / section > < / summary > < div class = "docblock" > < p > Writes unsigned 32 bit integers from < code > src< / code > into < code > dst< / code > .< / p >
< h5 id = "panics-17" > < a href = "#panics-17" > Panics< / a > < / h5 >
< p > Panics when < code > dst.len() != 4*src.len()< / code > .< / p >
< h5 id = "examples-17" > < a href = "#examples-17" > Examples< / a > < / h5 >
< p > Write and read < code > u32< / code > numbers in little endian order:< / p >
< div class = "example-wrap" > < pre class = "rust rust-example-rendered" > < code > < span class = "kw" > use < / span > byteorder::{ByteOrder, LittleEndian};
< span class = "kw" > let < / span > < span class = "kw-2" > mut < / span > bytes = [< span class = "number" > 0< / span > ; < span class = "number" > 16< / span > ];
< span class = "kw" > let < / span > numbers_given = [< span class = "number" > 1< / span > , < span class = "number" > 2< / span > , < span class = "number" > 0xf00f< / span > , < span class = "number" > 0xffee< / span > ];
LittleEndian::write_u32_into(< span class = "kw-2" > & < / span > numbers_given, < span class = "kw-2" > & mut < / span > bytes);
< span class = "kw" > let < / span > < span class = "kw-2" > mut < / span > numbers_got = [< span class = "number" > 0< / span > ; < span class = "number" > 4< / span > ];
LittleEndian::read_u32_into(< span class = "kw-2" > & < / span > bytes, < span class = "kw-2" > & mut < / span > numbers_got);
< span class = "macro" > assert_eq!< / span > (numbers_given, numbers_got);< / code > < / pre > < / div >
< / div > < / details > < details class = "toggle method-toggle" open > < summary > < section id = "tymethod.write_u64_into" class = "method" > < a class = "src rightside" href = "../src/byteorder/lib.rs.html#1370" > source< / a > < h4 class = "code-header" > fn < a href = "#tymethod.write_u64_into" class = "fn" > write_u64_into< / a > (src: & [u64], dst: & mut [u8])< / h4 > < / section > < / summary > < div class = "docblock" > < p > Writes unsigned 64 bit integers from < code > src< / code > into < code > dst< / code > .< / p >
< h5 id = "panics-18" > < a href = "#panics-18" > Panics< / a > < / h5 >
< p > Panics when < code > dst.len() != 8*src.len()< / code > .< / p >
< h5 id = "examples-18" > < a href = "#examples-18" > Examples< / a > < / h5 >
< p > Write and read < code > u64< / code > numbers in little endian order:< / p >
< div class = "example-wrap" > < pre class = "rust rust-example-rendered" > < code > < span class = "kw" > use < / span > byteorder::{ByteOrder, LittleEndian};
< span class = "kw" > let < / span > < span class = "kw-2" > mut < / span > bytes = [< span class = "number" > 0< / span > ; < span class = "number" > 32< / span > ];
< span class = "kw" > let < / span > numbers_given = [< span class = "number" > 1< / span > , < span class = "number" > 2< / span > , < span class = "number" > 0xf00f< / span > , < span class = "number" > 0xffee< / span > ];
LittleEndian::write_u64_into(< span class = "kw-2" > & < / span > numbers_given, < span class = "kw-2" > & mut < / span > bytes);
< span class = "kw" > let < / span > < span class = "kw-2" > mut < / span > numbers_got = [< span class = "number" > 0< / span > ; < span class = "number" > 4< / span > ];
LittleEndian::read_u64_into(< span class = "kw-2" > & < / span > bytes, < span class = "kw-2" > & mut < / span > numbers_got);
< span class = "macro" > assert_eq!< / span > (numbers_given, numbers_got);< / code > < / pre > < / div >
< / div > < / details > < details class = "toggle method-toggle" open > < summary > < section id = "tymethod.write_u128_into" class = "method" > < a class = "src rightside" href = "../src/byteorder/lib.rs.html#1393" > source< / a > < h4 class = "code-header" > fn < a href = "#tymethod.write_u128_into" class = "fn" > write_u128_into< / a > (src: & [u128], dst: & mut [u8])< / h4 > < / section > < / summary > < div class = "docblock" > < p > Writes unsigned 128 bit integers from < code > src< / code > into < code > dst< / code > .< / p >
< h5 id = "panics-19" > < a href = "#panics-19" > Panics< / a > < / h5 >
< p > Panics when < code > dst.len() != 16*src.len()< / code > .< / p >
< h5 id = "examples-19" > < a href = "#examples-19" > Examples< / a > < / h5 >
< p > Write and read < code > u128< / code > numbers in little endian order:< / p >
< div class = "example-wrap" > < pre class = "rust rust-example-rendered" > < code > < span class = "kw" > use < / span > byteorder::{ByteOrder, LittleEndian};
< span class = "kw" > let < / span > < span class = "kw-2" > mut < / span > bytes = [< span class = "number" > 0< / span > ; < span class = "number" > 64< / span > ];
< span class = "kw" > let < / span > numbers_given = [< span class = "number" > 1< / span > , < span class = "number" > 2< / span > , < span class = "number" > 0xf00f< / span > , < span class = "number" > 0xffee< / span > ];
LittleEndian::write_u128_into(< span class = "kw-2" > & < / span > numbers_given, < span class = "kw-2" > & mut < / span > bytes);
< span class = "kw" > let < / span > < span class = "kw-2" > mut < / span > numbers_got = [< span class = "number" > 0< / span > ; < span class = "number" > 4< / span > ];
LittleEndian::read_u128_into(< span class = "kw-2" > & < / span > bytes, < span class = "kw-2" > & mut < / span > numbers_got);
< span class = "macro" > assert_eq!< / span > (numbers_given, numbers_got);< / code > < / pre > < / div >
< / div > < / details > < details class = "toggle method-toggle" open > < summary > < section id = "tymethod.from_slice_u16" class = "method" > < a class = "src rightside" href = "../src/byteorder/lib.rs.html#1616" > source< / a > < h4 class = "code-header" > fn < a href = "#tymethod.from_slice_u16" class = "fn" > from_slice_u16< / a > (numbers: & mut [u16])< / h4 > < / section > < / summary > < div class = "docblock" > < p > Converts the given slice of unsigned 16 bit integers to a particular
endianness.< / p >
< p > If the endianness matches the endianness of the host platform, then
this is a no-op.< / p >
< h5 id = "examples-20" > < a href = "#examples-20" > Examples< / a > < / h5 >
< p > Convert the host platform’ < / p >
< div class = "example-wrap" > < pre class = "rust rust-example-rendered" > < code > < span class = "kw" > use < / span > byteorder::{ByteOrder, BigEndian};
< span class = "kw" > let < / span > < span class = "kw-2" > mut < / span > numbers = [< span class = "number" > 5< / span > , < span class = "number" > 65000< / span > ];
BigEndian::from_slice_u16(< span class = "kw-2" > & mut < / span > numbers);
< span class = "macro" > assert_eq!< / span > (numbers, [< span class = "number" > 5u16< / span > .to_be(), < span class = "number" > 65000u16< / span > .to_be()]);< / code > < / pre > < / div >
< / div > < / details > < details class = "toggle method-toggle" open > < summary > < section id = "tymethod.from_slice_u32" class = "method" > < a class = "src rightside" href = "../src/byteorder/lib.rs.html#1635" > source< / a > < h4 class = "code-header" > fn < a href = "#tymethod.from_slice_u32" class = "fn" > from_slice_u32< / a > (numbers: & mut [u32])< / h4 > < / section > < / summary > < div class = "docblock" > < p > Converts the given slice of unsigned 32 bit integers to a particular
endianness.< / p >
< p > If the endianness matches the endianness of the host platform, then
this is a no-op.< / p >
< h5 id = "examples-21" > < a href = "#examples-21" > Examples< / a > < / h5 >
< p > Convert the host platform’ < / p >
< div class = "example-wrap" > < pre class = "rust rust-example-rendered" > < code > < span class = "kw" > use < / span > byteorder::{ByteOrder, BigEndian};
< span class = "kw" > let < / span > < span class = "kw-2" > mut < / span > numbers = [< span class = "number" > 5< / span > , < span class = "number" > 65000< / span > ];
BigEndian::from_slice_u32(< span class = "kw-2" > & mut < / span > numbers);
< span class = "macro" > assert_eq!< / span > (numbers, [< span class = "number" > 5u32< / span > .to_be(), < span class = "number" > 65000u32< / span > .to_be()]);< / code > < / pre > < / div >
< / div > < / details > < details class = "toggle method-toggle" open > < summary > < section id = "tymethod.from_slice_u64" class = "method" > < a class = "src rightside" href = "../src/byteorder/lib.rs.html#1654" > source< / a > < h4 class = "code-header" > fn < a href = "#tymethod.from_slice_u64" class = "fn" > from_slice_u64< / a > (numbers: & mut [u64])< / h4 > < / section > < / summary > < div class = "docblock" > < p > Converts the given slice of unsigned 64 bit integers to a particular
endianness.< / p >
< p > If the endianness matches the endianness of the host platform, then
this is a no-op.< / p >
< h5 id = "examples-22" > < a href = "#examples-22" > Examples< / a > < / h5 >
< p > Convert the host platform’ < / p >
< div class = "example-wrap" > < pre class = "rust rust-example-rendered" > < code > < span class = "kw" > use < / span > byteorder::{ByteOrder, BigEndian};
< span class = "kw" > let < / span > < span class = "kw-2" > mut < / span > numbers = [< span class = "number" > 5< / span > , < span class = "number" > 65000< / span > ];
BigEndian::from_slice_u64(< span class = "kw-2" > & mut < / span > numbers);
< span class = "macro" > assert_eq!< / span > (numbers, [< span class = "number" > 5u64< / span > .to_be(), < span class = "number" > 65000u64< / span > .to_be()]);< / code > < / pre > < / div >
< / div > < / details > < details class = "toggle method-toggle" open > < summary > < section id = "tymethod.from_slice_u128" class = "method" > < a class = "src rightside" href = "../src/byteorder/lib.rs.html#1673" > source< / a > < h4 class = "code-header" > fn < a href = "#tymethod.from_slice_u128" class = "fn" > from_slice_u128< / a > (numbers: & mut [u128])< / h4 > < / section > < / summary > < div class = "docblock" > < p > Converts the given slice of unsigned 128 bit integers to a particular
endianness.< / p >
< p > If the endianness matches the endianness of the host platform, then
this is a no-op.< / p >
< h5 id = "examples-23" > < a href = "#examples-23" > Examples< / a > < / h5 >
< p > Convert the host platform’ < / p >
< div class = "example-wrap" > < pre class = "rust rust-example-rendered" > < code > < span class = "kw" > use < / span > byteorder::{ByteOrder, BigEndian};
< span class = "kw" > let < / span > < span class = "kw-2" > mut < / span > numbers = [< span class = "number" > 5< / span > , < span class = "number" > 65000< / span > ];
BigEndian::from_slice_u128(< span class = "kw-2" > & mut < / span > numbers);
< span class = "macro" > assert_eq!< / span > (numbers, [< span class = "number" > 5u128< / span > .to_be(), < span class = "number" > 65000u128< / span > .to_be()]);< / code > < / pre > < / div >
< / div > < / details > < details class = "toggle method-toggle" open > < summary > < section id = "tymethod.from_slice_f32" class = "method" > < a class = "src rightside" href = "../src/byteorder/lib.rs.html#1780" > source< / a > < h4 class = "code-header" > fn < a href = "#tymethod.from_slice_f32" class = "fn" > from_slice_f32< / a > (numbers: & mut [f32])< / h4 > < / section > < / summary > < div class = "docblock" > < p > Converts the given slice of IEEE754 single-precision (4 bytes) floating
point numbers to a particular endianness.< / p >
< p > If the endianness matches the endianness of the host platform, then
this is a no-op.< / p >
< / div > < / details > < details class = "toggle method-toggle" open > < summary > < section id = "tymethod.from_slice_f64" class = "method" > < a class = "src rightside" href = "../src/byteorder/lib.rs.html#1787" > source< / a > < h4 class = "code-header" > fn < a href = "#tymethod.from_slice_f64" class = "fn" > from_slice_f64< / a > (numbers: & mut [f64])< / h4 > < / section > < / summary > < div class = "docblock" > < p > Converts the given slice of IEEE754 double-precision (8 bytes) floating
point numbers to a particular endianness.< / p >
< p > If the endianness matches the endianness of the host platform, then
this is a no-op.< / p >
< / div > < / details > < / div > < h2 id = "provided-methods" class = "small-section-header" > Provided Methods< a href = "#provided-methods" class = "anchor" > §< / a > < / h2 > < div class = "methods" > < details class = "toggle method-toggle" open > < summary > < section id = "method.read_u24" class = "method" > < a class = "src rightside" href = "../src/byteorder/lib.rs.html#244-246" > source< / a > < h4 class = "code-header" > fn < a href = "#method.read_u24" class = "fn" > read_u24< / a > (buf: & [u8]) -> u32< / h4 > < / section > < / summary > < div class = "docblock" > < p > Reads an unsigned 24 bit integer from < code > buf< / code > , stored in u32.< / p >
< h5 id = "panics-20" > < a href = "#panics-20" > Panics< / a > < / h5 >
< p > Panics when < code > buf.len() < 3< / code > .< / p >
< h5 id = "examples-24" > < a href = "#examples-24" > Examples< / a > < / h5 >
< p > Write and read 24 bit < code > u32< / code > numbers in little endian order:< / p >
< div class = "example-wrap" > < pre class = "rust rust-example-rendered" > < code > < span class = "kw" > use < / span > byteorder::{ByteOrder, LittleEndian};
< span class = "kw" > let < / span > < span class = "kw-2" > mut < / span > buf = [< span class = "number" > 0< / span > ; < span class = "number" > 3< / span > ];
LittleEndian::write_u24(< span class = "kw-2" > & mut < / span > buf, < span class = "number" > 1_000_000< / span > );
< span class = "macro" > assert_eq!< / span > (< span class = "number" > 1_000_000< / span > , LittleEndian::read_u24(< span class = "kw-2" > & < / span > buf));< / code > < / pre > < / div >
< / div > < / details > < details class = "toggle method-toggle" open > < summary > < section id = "method.read_u48" class = "method" > < a class = "src rightside" href = "../src/byteorder/lib.rs.html#284-286" > source< / a > < h4 class = "code-header" > fn < a href = "#method.read_u48" class = "fn" > read_u48< / a > (buf: & [u8]) -> u64< / h4 > < / section > < / summary > < div class = "docblock" > < p > Reads an unsigned 48 bit integer from < code > buf< / code > , stored in u64.< / p >
< h5 id = "panics-21" > < a href = "#panics-21" > Panics< / a > < / h5 >
< p > Panics when < code > buf.len() < 6< / code > .< / p >
< h5 id = "examples-25" > < a href = "#examples-25" > Examples< / a > < / h5 >
< p > Write and read 48 bit < code > u64< / code > numbers in little endian order:< / p >
< div class = "example-wrap" > < pre class = "rust rust-example-rendered" > < code > < span class = "kw" > use < / span > byteorder::{ByteOrder, LittleEndian};
< span class = "kw" > let < / span > < span class = "kw-2" > mut < / span > buf = [< span class = "number" > 0< / span > ; < span class = "number" > 6< / span > ];
LittleEndian::write_u48(< span class = "kw-2" > & mut < / span > buf, < span class = "number" > 1_000_000_000_000< / span > );
< span class = "macro" > assert_eq!< / span > (< span class = "number" > 1_000_000_000_000< / span > , LittleEndian::read_u48(< span class = "kw-2" > & < / span > buf));< / code > < / pre > < / div >
< / div > < / details > < details class = "toggle method-toggle" open > < summary > < section id = "method.write_u24" class = "method" > < a class = "src rightside" href = "../src/byteorder/lib.rs.html#402-404" > source< / a > < h4 class = "code-header" > fn < a href = "#method.write_u24" class = "fn" > write_u24< / a > (buf: & mut [u8], n: u32)< / h4 > < / section > < / summary > < div class = "docblock" > < p > Writes an unsigned 24 bit integer < code > n< / code > to < code > buf< / code > , stored in u32.< / p >
< h5 id = "panics-22" > < a href = "#panics-22" > Panics< / a > < / h5 >
< p > Panics when < code > buf.len() < 3< / code > .< / p >
< h5 id = "examples-26" > < a href = "#examples-26" > Examples< / a > < / h5 >
< p > Write and read 24 bit < code > u32< / code > numbers in little endian order:< / p >
< div class = "example-wrap" > < pre class = "rust rust-example-rendered" > < code > < span class = "kw" > use < / span > byteorder::{ByteOrder, LittleEndian};
< span class = "kw" > let < / span > < span class = "kw-2" > mut < / span > buf = [< span class = "number" > 0< / span > ; < span class = "number" > 3< / span > ];
LittleEndian::write_u24(< span class = "kw-2" > & mut < / span > buf, < span class = "number" > 1_000_000< / span > );
< span class = "macro" > assert_eq!< / span > (< span class = "number" > 1_000_000< / span > , LittleEndian::read_u24(< span class = "kw-2" > & < / span > buf));< / code > < / pre > < / div >
< / div > < / details > < details class = "toggle method-toggle" open > < summary > < section id = "method.write_u48" class = "method" > < a class = "src rightside" href = "../src/byteorder/lib.rs.html#442-444" > source< / a > < h4 class = "code-header" > fn < a href = "#method.write_u48" class = "fn" > write_u48< / a > (buf: & mut [u8], n: u64)< / h4 > < / section > < / summary > < div class = "docblock" > < p > Writes an unsigned 48 bit integer < code > n< / code > to < code > buf< / code > , stored in u64.< / p >
< h5 id = "panics-23" > < a href = "#panics-23" > Panics< / a > < / h5 >
< p > Panics when < code > buf.len() < 6< / code > .< / p >
< h5 id = "examples-27" > < a href = "#examples-27" > Examples< / a > < / h5 >
< p > Write and read 48 bit < code > u64< / code > numbers in little endian order:< / p >
< div class = "example-wrap" > < pre class = "rust rust-example-rendered" > < code > < span class = "kw" > use < / span > byteorder::{ByteOrder, LittleEndian};
< span class = "kw" > let < / span > < span class = "kw-2" > mut < / span > buf = [< span class = "number" > 0< / span > ; < span class = "number" > 6< / span > ];
LittleEndian::write_u48(< span class = "kw-2" > & mut < / span > buf, < span class = "number" > 1_000_000_000_000< / span > );
< span class = "macro" > assert_eq!< / span > (< span class = "number" > 1_000_000_000_000< / span > , LittleEndian::read_u48(< span class = "kw-2" > & < / span > buf));< / code > < / pre > < / div >
< / div > < / details > < details class = "toggle method-toggle" open > < summary > < section id = "method.read_i16" class = "method" > < a class = "src rightside" href = "../src/byteorder/lib.rs.html#542-544" > source< / a > < h4 class = "code-header" > fn < a href = "#method.read_i16" class = "fn" > read_i16< / a > (buf: & [u8]) -> i16< / h4 > < / section > < / summary > < div class = "docblock" > < p > Reads a signed 16 bit integer from < code > buf< / code > .< / p >
< h5 id = "panics-24" > < a href = "#panics-24" > Panics< / a > < / h5 >
< p > Panics when < code > buf.len() < 2< / code > .< / p >
< h5 id = "examples-28" > < a href = "#examples-28" > Examples< / a > < / h5 >
< p > Write and read < code > i16< / code > numbers in little endian order:< / p >
< div class = "example-wrap" > < pre class = "rust rust-example-rendered" > < code > < span class = "kw" > use < / span > byteorder::{ByteOrder, LittleEndian};
< span class = "kw" > let < / span > < span class = "kw-2" > mut < / span > buf = [< span class = "number" > 0< / span > ; < span class = "number" > 2< / span > ];
LittleEndian::write_i16(< span class = "kw-2" > & mut < / span > buf, -< span class = "number" > 1_000< / span > );
< span class = "macro" > assert_eq!< / span > (-< span class = "number" > 1_000< / span > , LittleEndian::read_i16(< span class = "kw-2" > & < / span > buf));< / code > < / pre > < / div >
< / div > < / details > < details class = "toggle method-toggle" open > < summary > < section id = "method.read_i24" class = "method" > < a class = "src rightside" href = "../src/byteorder/lib.rs.html#564-566" > source< / a > < h4 class = "code-header" > fn < a href = "#method.read_i24" class = "fn" > read_i24< / a > (buf: & [u8]) -> i32< / h4 > < / section > < / summary > < div class = "docblock" > < p > Reads a signed 24 bit integer from < code > buf< / code > , stored in i32.< / p >
< h5 id = "panics-25" > < a href = "#panics-25" > Panics< / a > < / h5 >
< p > Panics when < code > buf.len() < 3< / code > .< / p >
< h5 id = "examples-29" > < a href = "#examples-29" > Examples< / a > < / h5 >
< p > Write and read 24 bit < code > i32< / code > numbers in little endian order:< / p >
< div class = "example-wrap" > < pre class = "rust rust-example-rendered" > < code > < span class = "kw" > use < / span > byteorder::{ByteOrder, LittleEndian};
< span class = "kw" > let < / span > < span class = "kw-2" > mut < / span > buf = [< span class = "number" > 0< / span > ; < span class = "number" > 3< / span > ];
LittleEndian::write_i24(< span class = "kw-2" > & mut < / span > buf, -< span class = "number" > 1_000_000< / span > );
< span class = "macro" > assert_eq!< / span > (-< span class = "number" > 1_000_000< / span > , LittleEndian::read_i24(< span class = "kw-2" > & < / span > buf));< / code > < / pre > < / div >
< / div > < / details > < details class = "toggle method-toggle" open > < summary > < section id = "method.read_i32" class = "method" > < a class = "src rightside" href = "../src/byteorder/lib.rs.html#586-588" > source< / a > < h4 class = "code-header" > fn < a href = "#method.read_i32" class = "fn" > read_i32< / a > (buf: & [u8]) -> i32< / h4 > < / section > < / summary > < div class = "docblock" > < p > Reads a signed 32 bit integer from < code > buf< / code > .< / p >
< h5 id = "panics-26" > < a href = "#panics-26" > Panics< / a > < / h5 >
< p > Panics when < code > buf.len() < 4< / code > .< / p >
< h5 id = "examples-30" > < a href = "#examples-30" > Examples< / a > < / h5 >
< p > Write and read < code > i32< / code > numbers in little endian order:< / p >
< div class = "example-wrap" > < pre class = "rust rust-example-rendered" > < code > < span class = "kw" > use < / span > byteorder::{ByteOrder, LittleEndian};
< span class = "kw" > let < / span > < span class = "kw-2" > mut < / span > buf = [< span class = "number" > 0< / span > ; < span class = "number" > 4< / span > ];
LittleEndian::write_i32(< span class = "kw-2" > & mut < / span > buf, -< span class = "number" > 1_000_000< / span > );
< span class = "macro" > assert_eq!< / span > (-< span class = "number" > 1_000_000< / span > , LittleEndian::read_i32(< span class = "kw-2" > & < / span > buf));< / code > < / pre > < / div >
< / div > < / details > < details class = "toggle method-toggle" open > < summary > < section id = "method.read_i48" class = "method" > < a class = "src rightside" href = "../src/byteorder/lib.rs.html#608-610" > source< / a > < h4 class = "code-header" > fn < a href = "#method.read_i48" class = "fn" > read_i48< / a > (buf: & [u8]) -> i64< / h4 > < / section > < / summary > < div class = "docblock" > < p > Reads a signed 48 bit integer from < code > buf< / code > , stored in i64.< / p >
< h5 id = "panics-27" > < a href = "#panics-27" > Panics< / a > < / h5 >
< p > Panics when < code > buf.len() < 6< / code > .< / p >
< h5 id = "examples-31" > < a href = "#examples-31" > Examples< / a > < / h5 >
< p > Write and read 48 bit < code > i64< / code > numbers in little endian order:< / p >
< div class = "example-wrap" > < pre class = "rust rust-example-rendered" > < code > < span class = "kw" > use < / span > byteorder::{ByteOrder, LittleEndian};
< span class = "kw" > let < / span > < span class = "kw-2" > mut < / span > buf = [< span class = "number" > 0< / span > ; < span class = "number" > 6< / span > ];
LittleEndian::write_i48(< span class = "kw-2" > & mut < / span > buf, -< span class = "number" > 1_000_000_000_000< / span > );
< span class = "macro" > assert_eq!< / span > (-< span class = "number" > 1_000_000_000_000< / span > , LittleEndian::read_i48(< span class = "kw-2" > & < / span > buf));< / code > < / pre > < / div >
< / div > < / details > < details class = "toggle method-toggle" open > < summary > < section id = "method.read_i64" class = "method" > < a class = "src rightside" href = "../src/byteorder/lib.rs.html#630-632" > source< / a > < h4 class = "code-header" > fn < a href = "#method.read_i64" class = "fn" > read_i64< / a > (buf: & [u8]) -> i64< / h4 > < / section > < / summary > < div class = "docblock" > < p > Reads a signed 64 bit integer from < code > buf< / code > .< / p >
< h5 id = "panics-28" > < a href = "#panics-28" > Panics< / a > < / h5 >
< p > Panics when < code > buf.len() < 8< / code > .< / p >
< h5 id = "examples-32" > < a href = "#examples-32" > Examples< / a > < / h5 >
< p > Write and read < code > i64< / code > numbers in little endian order:< / p >
< div class = "example-wrap" > < pre class = "rust rust-example-rendered" > < code > < span class = "kw" > use < / span > byteorder::{ByteOrder, LittleEndian};
< span class = "kw" > let < / span > < span class = "kw-2" > mut < / span > buf = [< span class = "number" > 0< / span > ; < span class = "number" > 8< / span > ];
LittleEndian::write_i64(< span class = "kw-2" > & mut < / span > buf, -< span class = "number" > 1_000_000_000< / span > );
< span class = "macro" > assert_eq!< / span > (-< span class = "number" > 1_000_000_000< / span > , LittleEndian::read_i64(< span class = "kw-2" > & < / span > buf));< / code > < / pre > < / div >
< / div > < / details > < details class = "toggle method-toggle" open > < summary > < section id = "method.read_i128" class = "method" > < a class = "src rightside" href = "../src/byteorder/lib.rs.html#652-654" > source< / a > < h4 class = "code-header" > fn < a href = "#method.read_i128" class = "fn" > read_i128< / a > (buf: & [u8]) -> i128< / h4 > < / section > < / summary > < div class = "docblock" > < p > Reads a signed 128 bit integer from < code > buf< / code > .< / p >
< h5 id = "panics-29" > < a href = "#panics-29" > Panics< / a > < / h5 >
< p > Panics when < code > buf.len() < 16< / code > .< / p >
< h5 id = "examples-33" > < a href = "#examples-33" > Examples< / a > < / h5 >
< p > Write and read < code > i128< / code > numbers in little endian order:< / p >
< div class = "example-wrap" > < pre class = "rust rust-example-rendered" > < code > < span class = "kw" > use < / span > byteorder::{ByteOrder, LittleEndian};
< span class = "kw" > let < / span > < span class = "kw-2" > mut < / span > buf = [< span class = "number" > 0< / span > ; < span class = "number" > 16< / span > ];
LittleEndian::write_i128(< span class = "kw-2" > & mut < / span > buf, -< span class = "number" > 1_000_000_000< / span > );
< span class = "macro" > assert_eq!< / span > (-< span class = "number" > 1_000_000_000< / span > , LittleEndian::read_i128(< span class = "kw-2" > & < / span > buf));< / code > < / pre > < / div >
< / div > < / details > < details class = "toggle method-toggle" open > < summary > < section id = "method.read_int" class = "method" > < a class = "src rightside" href = "../src/byteorder/lib.rs.html#675-677" > source< / a > < h4 class = "code-header" > fn < a href = "#method.read_int" class = "fn" > read_int< / a > (buf: & [u8], nbytes: usize) -> i64< / h4 > < / section > < / summary > < div class = "docblock" > < p > Reads a signed n-bytes integer from < code > buf< / code > .< / p >
< h5 id = "panics-30" > < a href = "#panics-30" > Panics< / a > < / h5 >
< p > Panics when < code > nbytes < 1< / code > or < code > nbytes > 8< / code > or
< code > buf.len() < nbytes< / code > < / p >
< h5 id = "examples-34" > < a href = "#examples-34" > Examples< / a > < / h5 >
< p > Write and read n-length signed numbers in little endian order:< / p >
< div class = "example-wrap" > < pre class = "rust rust-example-rendered" > < code > < span class = "kw" > use < / span > byteorder::{ByteOrder, LittleEndian};
< span class = "kw" > let < / span > < span class = "kw-2" > mut < / span > buf = [< span class = "number" > 0< / span > ; < span class = "number" > 3< / span > ];
LittleEndian::write_int(< span class = "kw-2" > & mut < / span > buf, -< span class = "number" > 1_000< / span > , < span class = "number" > 3< / span > );
< span class = "macro" > assert_eq!< / span > (-< span class = "number" > 1_000< / span > , LittleEndian::read_int(< span class = "kw-2" > & < / span > buf, < span class = "number" > 3< / span > ));< / code > < / pre > < / div >
< / div > < / details > < details class = "toggle method-toggle" open > < summary > < section id = "method.read_int128" class = "method" > < a class = "src rightside" href = "../src/byteorder/lib.rs.html#698-700" > source< / a > < h4 class = "code-header" > fn < a href = "#method.read_int128" class = "fn" > read_int128< / a > (buf: & [u8], nbytes: usize) -> i128< / h4 > < / section > < / summary > < div class = "docblock" > < p > Reads a signed n-bytes integer from < code > buf< / code > .< / p >
< h5 id = "panics-31" > < a href = "#panics-31" > Panics< / a > < / h5 >
< p > Panics when < code > nbytes < 1< / code > or < code > nbytes > 16< / code > or
< code > buf.len() < nbytes< / code > < / p >
< h5 id = "examples-35" > < a href = "#examples-35" > Examples< / a > < / h5 >
< p > Write and read n-length signed numbers in little endian order:< / p >
< div class = "example-wrap" > < pre class = "rust rust-example-rendered" > < code > < span class = "kw" > use < / span > byteorder::{ByteOrder, LittleEndian};
< span class = "kw" > let < / span > < span class = "kw-2" > mut < / span > buf = [< span class = "number" > 0< / span > ; < span class = "number" > 3< / span > ];
LittleEndian::write_int128(< span class = "kw-2" > & mut < / span > buf, -< span class = "number" > 1_000< / span > , < span class = "number" > 3< / span > );
< span class = "macro" > assert_eq!< / span > (-< span class = "number" > 1_000< / span > , LittleEndian::read_int128(< span class = "kw-2" > & < / span > buf, < span class = "number" > 3< / span > ));< / code > < / pre > < / div >
< / div > < / details > < details class = "toggle method-toggle" open > < summary > < section id = "method.read_f32" class = "method" > < a class = "src rightside" href = "../src/byteorder/lib.rs.html#721-723" > source< / a > < h4 class = "code-header" > fn < a href = "#method.read_f32" class = "fn" > read_f32< / a > (buf: & [u8]) -> f32< / h4 > < / section > < / summary > < div class = "docblock" > < p > Reads a IEEE754 single-precision (4 bytes) floating point number.< / p >
< h5 id = "panics-32" > < a href = "#panics-32" > Panics< / a > < / h5 >
< p > Panics when < code > buf.len() < 4< / code > .< / p >
< h5 id = "examples-36" > < a href = "#examples-36" > Examples< / a > < / h5 >
< p > Write and read < code > f32< / code > numbers in little endian order:< / p >
< div class = "example-wrap" > < pre class = "rust rust-example-rendered" > < code > < span class = "kw" > use < / span > byteorder::{ByteOrder, LittleEndian};
< span class = "kw" > let < / span > e = < span class = "number" > 2.71828< / span > ;
< span class = "kw" > let < / span > < span class = "kw-2" > mut < / span > buf = [< span class = "number" > 0< / span > ; < span class = "number" > 4< / span > ];
LittleEndian::write_f32(< span class = "kw-2" > & mut < / span > buf, e);
< span class = "macro" > assert_eq!< / span > (e, LittleEndian::read_f32(< span class = "kw-2" > & < / span > buf));< / code > < / pre > < / div >
< / div > < / details > < details class = "toggle method-toggle" open > < summary > < section id = "method.read_f64" class = "method" > < a class = "src rightside" href = "../src/byteorder/lib.rs.html#744-746" > source< / a > < h4 class = "code-header" > fn < a href = "#method.read_f64" class = "fn" > read_f64< / a > (buf: & [u8]) -> f64< / h4 > < / section > < / summary > < div class = "docblock" > < p > Reads a IEEE754 double-precision (8 bytes) floating point number.< / p >
< h5 id = "panics-33" > < a href = "#panics-33" > Panics< / a > < / h5 >
< p > Panics when < code > buf.len() < 8< / code > .< / p >
< h5 id = "examples-37" > < a href = "#examples-37" > Examples< / a > < / h5 >
< p > Write and read < code > f64< / code > numbers in little endian order:< / p >
< div class = "example-wrap" > < pre class = "rust rust-example-rendered" > < code > < span class = "kw" > use < / span > byteorder::{ByteOrder, LittleEndian};
< span class = "kw" > let < / span > phi = < span class = "number" > 1.6180339887< / span > ;
< span class = "kw" > let < / span > < span class = "kw-2" > mut < / span > buf = [< span class = "number" > 0< / span > ; < span class = "number" > 8< / span > ];
LittleEndian::write_f64(< span class = "kw-2" > & mut < / span > buf, phi);
< span class = "macro" > assert_eq!< / span > (phi, LittleEndian::read_f64(< span class = "kw-2" > & < / span > buf));< / code > < / pre > < / div >
< / div > < / details > < details class = "toggle method-toggle" open > < summary > < section id = "method.write_i16" class = "method" > < a class = "src rightside" href = "../src/byteorder/lib.rs.html#766-768" > source< / a > < h4 class = "code-header" > fn < a href = "#method.write_i16" class = "fn" > write_i16< / a > (buf: & mut [u8], n: i16)< / h4 > < / section > < / summary > < div class = "docblock" > < p > Writes a signed 16 bit integer < code > n< / code > to < code > buf< / code > .< / p >
< h5 id = "panics-34" > < a href = "#panics-34" > Panics< / a > < / h5 >
< p > Panics when < code > buf.len() < 2< / code > .< / p >
< h5 id = "examples-38" > < a href = "#examples-38" > Examples< / a > < / h5 >
< p > Write and read < code > i16< / code > numbers in little endian order:< / p >
< div class = "example-wrap" > < pre class = "rust rust-example-rendered" > < code > < span class = "kw" > use < / span > byteorder::{ByteOrder, LittleEndian};
< span class = "kw" > let < / span > < span class = "kw-2" > mut < / span > buf = [< span class = "number" > 0< / span > ; < span class = "number" > 2< / span > ];
LittleEndian::write_i16(< span class = "kw-2" > & mut < / span > buf, -< span class = "number" > 1_000< / span > );
< span class = "macro" > assert_eq!< / span > (-< span class = "number" > 1_000< / span > , LittleEndian::read_i16(< span class = "kw-2" > & < / span > buf));< / code > < / pre > < / div >
< / div > < / details > < details class = "toggle method-toggle" open > < summary > < section id = "method.write_i24" class = "method" > < a class = "src rightside" href = "../src/byteorder/lib.rs.html#788-790" > source< / a > < h4 class = "code-header" > fn < a href = "#method.write_i24" class = "fn" > write_i24< / a > (buf: & mut [u8], n: i32)< / h4 > < / section > < / summary > < div class = "docblock" > < p > Writes a signed 24 bit integer < code > n< / code > to < code > buf< / code > , stored in i32.< / p >
< h5 id = "panics-35" > < a href = "#panics-35" > Panics< / a > < / h5 >
< p > Panics when < code > buf.len() < 3< / code > .< / p >
< h5 id = "examples-39" > < a href = "#examples-39" > Examples< / a > < / h5 >
< p > Write and read 24 bit < code > i32< / code > numbers in little endian order:< / p >
< div class = "example-wrap" > < pre class = "rust rust-example-rendered" > < code > < span class = "kw" > use < / span > byteorder::{ByteOrder, LittleEndian};
< span class = "kw" > let < / span > < span class = "kw-2" > mut < / span > buf = [< span class = "number" > 0< / span > ; < span class = "number" > 3< / span > ];
LittleEndian::write_i24(< span class = "kw-2" > & mut < / span > buf, -< span class = "number" > 1_000_000< / span > );
< span class = "macro" > assert_eq!< / span > (-< span class = "number" > 1_000_000< / span > , LittleEndian::read_i24(< span class = "kw-2" > & < / span > buf));< / code > < / pre > < / div >
< / div > < / details > < details class = "toggle method-toggle" open > < summary > < section id = "method.write_i32" class = "method" > < a class = "src rightside" href = "../src/byteorder/lib.rs.html#810-812" > source< / a > < h4 class = "code-header" > fn < a href = "#method.write_i32" class = "fn" > write_i32< / a > (buf: & mut [u8], n: i32)< / h4 > < / section > < / summary > < div class = "docblock" > < p > Writes a signed 32 bit integer < code > n< / code > to < code > buf< / code > .< / p >
< h5 id = "panics-36" > < a href = "#panics-36" > Panics< / a > < / h5 >
< p > Panics when < code > buf.len() < 4< / code > .< / p >
< h5 id = "examples-40" > < a href = "#examples-40" > Examples< / a > < / h5 >
< p > Write and read < code > i32< / code > numbers in little endian order:< / p >
< div class = "example-wrap" > < pre class = "rust rust-example-rendered" > < code > < span class = "kw" > use < / span > byteorder::{ByteOrder, LittleEndian};
< span class = "kw" > let < / span > < span class = "kw-2" > mut < / span > buf = [< span class = "number" > 0< / span > ; < span class = "number" > 4< / span > ];
LittleEndian::write_i32(< span class = "kw-2" > & mut < / span > buf, -< span class = "number" > 1_000_000< / span > );
< span class = "macro" > assert_eq!< / span > (-< span class = "number" > 1_000_000< / span > , LittleEndian::read_i32(< span class = "kw-2" > & < / span > buf));< / code > < / pre > < / div >
< / div > < / details > < details class = "toggle method-toggle" open > < summary > < section id = "method.write_i48" class = "method" > < a class = "src rightside" href = "../src/byteorder/lib.rs.html#832-834" > source< / a > < h4 class = "code-header" > fn < a href = "#method.write_i48" class = "fn" > write_i48< / a > (buf: & mut [u8], n: i64)< / h4 > < / section > < / summary > < div class = "docblock" > < p > Writes a signed 48 bit integer < code > n< / code > to < code > buf< / code > , stored in i64.< / p >
< h5 id = "panics-37" > < a href = "#panics-37" > Panics< / a > < / h5 >
< p > Panics when < code > buf.len() < 6< / code > .< / p >
< h5 id = "examples-41" > < a href = "#examples-41" > Examples< / a > < / h5 >
< p > Write and read 48 bit < code > i64< / code > numbers in little endian order:< / p >
< div class = "example-wrap" > < pre class = "rust rust-example-rendered" > < code > < span class = "kw" > use < / span > byteorder::{ByteOrder, LittleEndian};
< span class = "kw" > let < / span > < span class = "kw-2" > mut < / span > buf = [< span class = "number" > 0< / span > ; < span class = "number" > 6< / span > ];
LittleEndian::write_i48(< span class = "kw-2" > & mut < / span > buf, -< span class = "number" > 1_000_000_000_000< / span > );
< span class = "macro" > assert_eq!< / span > (-< span class = "number" > 1_000_000_000_000< / span > , LittleEndian::read_i48(< span class = "kw-2" > & < / span > buf));< / code > < / pre > < / div >
< / div > < / details > < details class = "toggle method-toggle" open > < summary > < section id = "method.write_i64" class = "method" > < a class = "src rightside" href = "../src/byteorder/lib.rs.html#854-856" > source< / a > < h4 class = "code-header" > fn < a href = "#method.write_i64" class = "fn" > write_i64< / a > (buf: & mut [u8], n: i64)< / h4 > < / section > < / summary > < div class = "docblock" > < p > Writes a signed 64 bit integer < code > n< / code > to < code > buf< / code > .< / p >
< h5 id = "panics-38" > < a href = "#panics-38" > Panics< / a > < / h5 >
< p > Panics when < code > buf.len() < 8< / code > .< / p >
< h5 id = "examples-42" > < a href = "#examples-42" > Examples< / a > < / h5 >
< p > Write and read < code > i64< / code > numbers in little endian order:< / p >
< div class = "example-wrap" > < pre class = "rust rust-example-rendered" > < code > < span class = "kw" > use < / span > byteorder::{ByteOrder, LittleEndian};
< span class = "kw" > let < / span > < span class = "kw-2" > mut < / span > buf = [< span class = "number" > 0< / span > ; < span class = "number" > 8< / span > ];
LittleEndian::write_i64(< span class = "kw-2" > & mut < / span > buf, -< span class = "number" > 1_000_000_000< / span > );
< span class = "macro" > assert_eq!< / span > (-< span class = "number" > 1_000_000_000< / span > , LittleEndian::read_i64(< span class = "kw-2" > & < / span > buf));< / code > < / pre > < / div >
< / div > < / details > < details class = "toggle method-toggle" open > < summary > < section id = "method.write_i128" class = "method" > < a class = "src rightside" href = "../src/byteorder/lib.rs.html#876-878" > source< / a > < h4 class = "code-header" > fn < a href = "#method.write_i128" class = "fn" > write_i128< / a > (buf: & mut [u8], n: i128)< / h4 > < / section > < / summary > < div class = "docblock" > < p > Writes a signed 128 bit integer < code > n< / code > to < code > buf< / code > .< / p >
< h5 id = "panics-39" > < a href = "#panics-39" > Panics< / a > < / h5 >
< p > Panics when < code > buf.len() < 16< / code > .< / p >
< h5 id = "examples-43" > < a href = "#examples-43" > Examples< / a > < / h5 >
< p > Write and read n-byte < code > i128< / code > numbers in little endian order:< / p >
< div class = "example-wrap" > < pre class = "rust rust-example-rendered" > < code > < span class = "kw" > use < / span > byteorder::{ByteOrder, LittleEndian};
< span class = "kw" > let < / span > < span class = "kw-2" > mut < / span > buf = [< span class = "number" > 0< / span > ; < span class = "number" > 16< / span > ];
LittleEndian::write_i128(< span class = "kw-2" > & mut < / span > buf, -< span class = "number" > 1_000_000_000< / span > );
< span class = "macro" > assert_eq!< / span > (-< span class = "number" > 1_000_000_000< / span > , LittleEndian::read_i128(< span class = "kw-2" > & < / span > buf));< / code > < / pre > < / div >
< / div > < / details > < details class = "toggle method-toggle" open > < summary > < section id = "method.write_int" class = "method" > < a class = "src rightside" href = "../src/byteorder/lib.rs.html#899-901" > source< / a > < h4 class = "code-header" > fn < a href = "#method.write_int" class = "fn" > write_int< / a > (buf: & mut [u8], n: i64, nbytes: usize)< / h4 > < / section > < / summary > < div class = "docblock" > < p > Writes a signed integer < code > n< / code > to < code > buf< / code > using only < code > nbytes< / code > .< / p >
< h5 id = "panics-40" > < a href = "#panics-40" > Panics< / a > < / h5 >
< p > If < code > n< / code > is not representable in < code > nbytes< / code > , or if < code > nbytes< / code > is < code > > 8< / code > , then
this method panics.< / p >
< h5 id = "examples-44" > < a href = "#examples-44" > Examples< / a > < / h5 >
< p > Write and read an n-byte number in little endian order:< / p >
< div class = "example-wrap" > < pre class = "rust rust-example-rendered" > < code > < span class = "kw" > use < / span > byteorder::{ByteOrder, LittleEndian};
< span class = "kw" > let < / span > < span class = "kw-2" > mut < / span > buf = [< span class = "number" > 0< / span > ; < span class = "number" > 3< / span > ];
LittleEndian::write_int(< span class = "kw-2" > & mut < / span > buf, -< span class = "number" > 1_000< / span > , < span class = "number" > 3< / span > );
< span class = "macro" > assert_eq!< / span > (-< span class = "number" > 1_000< / span > , LittleEndian::read_int(< span class = "kw-2" > & < / span > buf, < span class = "number" > 3< / span > ));< / code > < / pre > < / div >
< / div > < / details > < details class = "toggle method-toggle" open > < summary > < section id = "method.write_int128" class = "method" > < a class = "src rightside" href = "../src/byteorder/lib.rs.html#922-924" > source< / a > < h4 class = "code-header" > fn < a href = "#method.write_int128" class = "fn" > write_int128< / a > (buf: & mut [u8], n: i128, nbytes: usize)< / h4 > < / section > < / summary > < div class = "docblock" > < p > Writes a signed integer < code > n< / code > to < code > buf< / code > using only < code > nbytes< / code > .< / p >
< h5 id = "panics-41" > < a href = "#panics-41" > Panics< / a > < / h5 >
< p > If < code > n< / code > is not representable in < code > nbytes< / code > , or if < code > nbytes< / code > is < code > > 16< / code > , then
this method panics.< / p >
< h5 id = "examples-45" > < a href = "#examples-45" > Examples< / a > < / h5 >
< p > Write and read n-length signed numbers in little endian order:< / p >
< div class = "example-wrap" > < pre class = "rust rust-example-rendered" > < code > < span class = "kw" > use < / span > byteorder::{ByteOrder, LittleEndian};
< span class = "kw" > let < / span > < span class = "kw-2" > mut < / span > buf = [< span class = "number" > 0< / span > ; < span class = "number" > 3< / span > ];
LittleEndian::write_int128(< span class = "kw-2" > & mut < / span > buf, -< span class = "number" > 1_000< / span > , < span class = "number" > 3< / span > );
< span class = "macro" > assert_eq!< / span > (-< span class = "number" > 1_000< / span > , LittleEndian::read_int128(< span class = "kw-2" > & < / span > buf, < span class = "number" > 3< / span > ));< / code > < / pre > < / div >
< / div > < / details > < details class = "toggle method-toggle" open > < summary > < section id = "method.write_f32" class = "method" > < a class = "src rightside" href = "../src/byteorder/lib.rs.html#945-947" > source< / a > < h4 class = "code-header" > fn < a href = "#method.write_f32" class = "fn" > write_f32< / a > (buf: & mut [u8], n: f32)< / h4 > < / section > < / summary > < div class = "docblock" > < p > Writes a IEEE754 single-precision (4 bytes) floating point number.< / p >
< h5 id = "panics-42" > < a href = "#panics-42" > Panics< / a > < / h5 >
< p > Panics when < code > buf.len() < 4< / code > .< / p >
< h5 id = "examples-46" > < a href = "#examples-46" > Examples< / a > < / h5 >
< p > Write and read < code > f32< / code > numbers in little endian order:< / p >
< div class = "example-wrap" > < pre class = "rust rust-example-rendered" > < code > < span class = "kw" > use < / span > byteorder::{ByteOrder, LittleEndian};
< span class = "kw" > let < / span > e = < span class = "number" > 2.71828< / span > ;
< span class = "kw" > let < / span > < span class = "kw-2" > mut < / span > buf = [< span class = "number" > 0< / span > ; < span class = "number" > 4< / span > ];
LittleEndian::write_f32(< span class = "kw-2" > & mut < / span > buf, e);
< span class = "macro" > assert_eq!< / span > (e, LittleEndian::read_f32(< span class = "kw-2" > & < / span > buf));< / code > < / pre > < / div >
< / div > < / details > < details class = "toggle method-toggle" open > < summary > < section id = "method.write_f64" class = "method" > < a class = "src rightside" href = "../src/byteorder/lib.rs.html#968-970" > source< / a > < h4 class = "code-header" > fn < a href = "#method.write_f64" class = "fn" > write_f64< / a > (buf: & mut [u8], n: f64)< / h4 > < / section > < / summary > < div class = "docblock" > < p > Writes a IEEE754 double-precision (8 bytes) floating point number.< / p >
< h5 id = "panics-43" > < a href = "#panics-43" > Panics< / a > < / h5 >
< p > Panics when < code > buf.len() < 8< / code > .< / p >
< h5 id = "examples-47" > < a href = "#examples-47" > Examples< / a > < / h5 >
< p > Write and read < code > f64< / code > numbers in little endian order:< / p >
< div class = "example-wrap" > < pre class = "rust rust-example-rendered" > < code > < span class = "kw" > use < / span > byteorder::{ByteOrder, LittleEndian};
< span class = "kw" > let < / span > phi = < span class = "number" > 1.6180339887< / span > ;
< span class = "kw" > let < / span > < span class = "kw-2" > mut < / span > buf = [< span class = "number" > 0< / span > ; < span class = "number" > 8< / span > ];
LittleEndian::write_f64(< span class = "kw-2" > & mut < / span > buf, phi);
< span class = "macro" > assert_eq!< / span > (phi, LittleEndian::read_f64(< span class = "kw-2" > & < / span > buf));< / code > < / pre > < / div >
< / div > < / details > < details class = "toggle method-toggle" open > < summary > < section id = "method.read_i16_into" class = "method" > < a class = "src rightside" href = "../src/byteorder/lib.rs.html#1086-1091" > source< / a > < h4 class = "code-header" > fn < a href = "#method.read_i16_into" class = "fn" > read_i16_into< / a > (src: & [u8], dst: & mut [i16])< / h4 > < / section > < / summary > < div class = "docblock" > < p > Reads signed 16 bit integers from < code > src< / code > to < code > dst< / code > .< / p >
< h5 id = "panics-44" > < a href = "#panics-44" > Panics< / a > < / h5 >
< p > Panics when < code > buf.len() != 2*dst.len()< / code > .< / p >
< h5 id = "examples-48" > < a href = "#examples-48" > Examples< / a > < / h5 >
< p > Write and read < code > i16< / code > numbers in little endian order:< / p >
< div class = "example-wrap" > < pre class = "rust rust-example-rendered" > < code > < span class = "kw" > use < / span > byteorder::{ByteOrder, LittleEndian};
< span class = "kw" > let < / span > < span class = "kw-2" > mut < / span > bytes = [< span class = "number" > 0< / span > ; < span class = "number" > 8< / span > ];
< span class = "kw" > let < / span > numbers_given = [< span class = "number" > 1< / span > , < span class = "number" > 2< / span > , < span class = "number" > 0x0f< / span > , < span class = "number" > 0xee< / span > ];
LittleEndian::write_i16_into(< span class = "kw-2" > & < / span > numbers_given, < span class = "kw-2" > & mut < / span > bytes);
< span class = "kw" > let < / span > < span class = "kw-2" > mut < / span > numbers_got = [< span class = "number" > 0< / span > ; < span class = "number" > 4< / span > ];
LittleEndian::read_i16_into(< span class = "kw-2" > & < / span > bytes, < span class = "kw-2" > & mut < / span > numbers_got);
< span class = "macro" > assert_eq!< / span > (numbers_given, numbers_got);< / code > < / pre > < / div >
< / div > < / details > < details class = "toggle method-toggle" open > < summary > < section id = "method.read_i32_into" class = "method" > < a class = "src rightside" href = "../src/byteorder/lib.rs.html#1115-1120" > source< / a > < h4 class = "code-header" > fn < a href = "#method.read_i32_into" class = "fn" > read_i32_into< / a > (src: & [u8], dst: & mut [i32])< / h4 > < / section > < / summary > < div class = "docblock" > < p > Reads signed 32 bit integers from < code > src< / code > into < code > dst< / code > .< / p >
< h5 id = "panics-45" > < a href = "#panics-45" > Panics< / a > < / h5 >
< p > Panics when < code > src.len() != 4*dst.len()< / code > .< / p >
< h5 id = "examples-49" > < a href = "#examples-49" > Examples< / a > < / h5 >
< p > Write and read < code > i32< / code > numbers in little endian order:< / p >
< div class = "example-wrap" > < pre class = "rust rust-example-rendered" > < code > < span class = "kw" > use < / span > byteorder::{ByteOrder, LittleEndian};
< span class = "kw" > let < / span > < span class = "kw-2" > mut < / span > bytes = [< span class = "number" > 0< / span > ; < span class = "number" > 16< / span > ];
< span class = "kw" > let < / span > numbers_given = [< span class = "number" > 1< / span > , < span class = "number" > 2< / span > , < span class = "number" > 0xf00f< / span > , < span class = "number" > 0xffee< / span > ];
LittleEndian::write_i32_into(< span class = "kw-2" > & < / span > numbers_given, < span class = "kw-2" > & mut < / span > bytes);
< span class = "kw" > let < / span > < span class = "kw-2" > mut < / span > numbers_got = [< span class = "number" > 0< / span > ; < span class = "number" > 4< / span > ];
LittleEndian::read_i32_into(< span class = "kw-2" > & < / span > bytes, < span class = "kw-2" > & mut < / span > numbers_got);
< span class = "macro" > assert_eq!< / span > (numbers_given, numbers_got);< / code > < / pre > < / div >
< / div > < / details > < details class = "toggle method-toggle" open > < summary > < section id = "method.read_i64_into" class = "method" > < a class = "src rightside" href = "../src/byteorder/lib.rs.html#1144-1149" > source< / a > < h4 class = "code-header" > fn < a href = "#method.read_i64_into" class = "fn" > read_i64_into< / a > (src: & [u8], dst: & mut [i64])< / h4 > < / section > < / summary > < div class = "docblock" > < p > Reads signed 64 bit integers from < code > src< / code > into < code > dst< / code > .< / p >
< h5 id = "panics-46" > < a href = "#panics-46" > Panics< / a > < / h5 >
< p > Panics when < code > src.len() != 8*dst.len()< / code > .< / p >
< h5 id = "examples-50" > < a href = "#examples-50" > Examples< / a > < / h5 >
< p > Write and read < code > i64< / code > numbers in little endian order:< / p >
< div class = "example-wrap" > < pre class = "rust rust-example-rendered" > < code > < span class = "kw" > use < / span > byteorder::{ByteOrder, LittleEndian};
< span class = "kw" > let < / span > < span class = "kw-2" > mut < / span > bytes = [< span class = "number" > 0< / span > ; < span class = "number" > 32< / span > ];
< span class = "kw" > let < / span > numbers_given = [< span class = "number" > 1< / span > , < span class = "number" > 2< / span > , < span class = "number" > 0xf00f< / span > , < span class = "number" > 0xffee< / span > ];
LittleEndian::write_i64_into(< span class = "kw-2" > & < / span > numbers_given, < span class = "kw-2" > & mut < / span > bytes);
< span class = "kw" > let < / span > < span class = "kw-2" > mut < / span > numbers_got = [< span class = "number" > 0< / span > ; < span class = "number" > 4< / span > ];
LittleEndian::read_i64_into(< span class = "kw-2" > & < / span > bytes, < span class = "kw-2" > & mut < / span > numbers_got);
< span class = "macro" > assert_eq!< / span > (numbers_given, numbers_got);< / code > < / pre > < / div >
< / div > < / details > < details class = "toggle method-toggle" open > < summary > < section id = "method.read_i128_into" class = "method" > < a class = "src rightside" href = "../src/byteorder/lib.rs.html#1173-1178" > source< / a > < h4 class = "code-header" > fn < a href = "#method.read_i128_into" class = "fn" > read_i128_into< / a > (src: & [u8], dst: & mut [i128])< / h4 > < / section > < / summary > < div class = "docblock" > < p > Reads signed 128 bit integers from < code > src< / code > into < code > dst< / code > .< / p >
< h5 id = "panics-47" > < a href = "#panics-47" > Panics< / a > < / h5 >
< p > Panics when < code > src.len() != 16*dst.len()< / code > .< / p >
< h5 id = "examples-51" > < a href = "#examples-51" > Examples< / a > < / h5 >
< p > Write and read < code > i128< / code > numbers in little endian order:< / p >
< div class = "example-wrap" > < pre class = "rust rust-example-rendered" > < code > < span class = "kw" > use < / span > byteorder::{ByteOrder, LittleEndian};
< span class = "kw" > let < / span > < span class = "kw-2" > mut < / span > bytes = [< span class = "number" > 0< / span > ; < span class = "number" > 64< / span > ];
< span class = "kw" > let < / span > numbers_given = [< span class = "number" > 1< / span > , < span class = "number" > 2< / span > , < span class = "number" > 0xf00f< / span > , < span class = "number" > 0xffee< / span > ];
LittleEndian::write_i128_into(< span class = "kw-2" > & < / span > numbers_given, < span class = "kw-2" > & mut < / span > bytes);
< span class = "kw" > let < / span > < span class = "kw-2" > mut < / span > numbers_got = [< span class = "number" > 0< / span > ; < span class = "number" > 4< / span > ];
LittleEndian::read_i128_into(< span class = "kw-2" > & < / span > bytes, < span class = "kw-2" > & mut < / span > numbers_got);
< span class = "macro" > assert_eq!< / span > (numbers_given, numbers_got);< / code > < / pre > < / div >
< / div > < / details > < details class = "toggle method-toggle" open > < summary > < section id = "method.read_f32_into" class = "method" > < a class = "src rightside" href = "../src/byteorder/lib.rs.html#1203-1208" > source< / a > < h4 class = "code-header" > fn < a href = "#method.read_f32_into" class = "fn" > read_f32_into< / a > (src: & [u8], dst: & mut [f32])< / h4 > < / section > < / summary > < div class = "docblock" > < p > Reads IEEE754 single-precision (4 bytes) floating point numbers from
< code > src< / code > into < code > dst< / code > .< / p >
< h5 id = "panics-48" > < a href = "#panics-48" > Panics< / a > < / h5 >
< p > Panics when < code > src.len() != 4*dst.len()< / code > .< / p >
< h5 id = "examples-52" > < a href = "#examples-52" > Examples< / a > < / h5 >
< p > Write and read < code > f32< / code > numbers in little endian order:< / p >
< div class = "example-wrap" > < pre class = "rust rust-example-rendered" > < code > < span class = "kw" > use < / span > byteorder::{ByteOrder, LittleEndian};
< span class = "kw" > let < / span > < span class = "kw-2" > mut < / span > bytes = [< span class = "number" > 0< / span > ; < span class = "number" > 16< / span > ];
< span class = "kw" > let < / span > numbers_given = [< span class = "number" > 1.0< / span > , < span class = "number" > 2.0< / span > , < span class = "number" > 31.312e31< / span > , -< span class = "number" > 11.32e19< / span > ];
LittleEndian::write_f32_into(< span class = "kw-2" > & < / span > numbers_given, < span class = "kw-2" > & mut < / span > bytes);
< span class = "kw" > let < / span > < span class = "kw-2" > mut < / span > numbers_got = [< span class = "number" > 0.0< / span > ; < span class = "number" > 4< / span > ];
LittleEndian::read_f32_into(< span class = "kw-2" > & < / span > bytes, < span class = "kw-2" > & mut < / span > numbers_got);
< span class = "macro" > assert_eq!< / span > (numbers_given, numbers_got);< / code > < / pre > < / div >
< / div > < / details > < details class = "toggle method-toggle" open > < summary > < section id = "method.read_f32_into_unchecked" class = "method" > < a class = "src rightside" href = "../src/byteorder/lib.rs.html#1237-1239" > source< / a > < h4 class = "code-header" > fn < a href = "#method.read_f32_into_unchecked" class = "fn" > read_f32_into_unchecked< / a > (src: & [u8], dst: & mut [f32])< / h4 > < / section > < / summary > < span class = "item-info" > < div class = "stab deprecated" > < span class = "emoji" > 👎< / span > < span > Deprecated since 1.3.0: please use < code > read_f32_into< / code > instead< / span > < / div > < / span > < div class = "docblock" > < p > < strong > DEPRECATED< / strong > .< / p >
< p > This method is deprecated. Use < code > read_f32_into< / code > instead.
Reads IEEE754 single-precision (4 bytes) floating point numbers from
< code > src< / code > into < code > dst< / code > .< / p >
< h5 id = "panics-49" > < a href = "#panics-49" > Panics< / a > < / h5 >
< p > Panics when < code > src.len() != 4*dst.len()< / code > .< / p >
< h5 id = "examples-53" > < a href = "#examples-53" > Examples< / a > < / h5 >
< p > Write and read < code > f32< / code > numbers in little endian order:< / p >
< div class = "example-wrap" > < pre class = "rust rust-example-rendered" > < code > < span class = "kw" > use < / span > byteorder::{ByteOrder, LittleEndian};
< span class = "kw" > let < / span > < span class = "kw-2" > mut < / span > bytes = [< span class = "number" > 0< / span > ; < span class = "number" > 16< / span > ];
< span class = "kw" > let < / span > numbers_given = [< span class = "number" > 1.0< / span > , < span class = "number" > 2.0< / span > , < span class = "number" > 31.312e31< / span > , -< span class = "number" > 11.32e19< / span > ];
LittleEndian::write_f32_into(< span class = "kw-2" > & < / span > numbers_given, < span class = "kw-2" > & mut < / span > bytes);
< span class = "kw" > let < / span > < span class = "kw-2" > mut < / span > numbers_got = [< span class = "number" > 0.0< / span > ; < span class = "number" > 4< / span > ];
LittleEndian::read_f32_into_unchecked(< span class = "kw-2" > & < / span > bytes, < span class = "kw-2" > & mut < / span > numbers_got);
< span class = "macro" > assert_eq!< / span > (numbers_given, numbers_got);< / code > < / pre > < / div >
< / div > < / details > < details class = "toggle method-toggle" open > < summary > < section id = "method.read_f64_into" class = "method" > < a class = "src rightside" href = "../src/byteorder/lib.rs.html#1264-1269" > source< / a > < h4 class = "code-header" > fn < a href = "#method.read_f64_into" class = "fn" > read_f64_into< / a > (src: & [u8], dst: & mut [f64])< / h4 > < / section > < / summary > < div class = "docblock" > < p > Reads IEEE754 single-precision (4 bytes) floating point numbers from
< code > src< / code > into < code > dst< / code > .< / p >
< h5 id = "panics-50" > < a href = "#panics-50" > Panics< / a > < / h5 >
< p > Panics when < code > src.len() != 8*dst.len()< / code > .< / p >
< h5 id = "examples-54" > < a href = "#examples-54" > Examples< / a > < / h5 >
< p > Write and read < code > f64< / code > numbers in little endian order:< / p >
< div class = "example-wrap" > < pre class = "rust rust-example-rendered" > < code > < span class = "kw" > use < / span > byteorder::{ByteOrder, LittleEndian};
< span class = "kw" > let < / span > < span class = "kw-2" > mut < / span > bytes = [< span class = "number" > 0< / span > ; < span class = "number" > 32< / span > ];
< span class = "kw" > let < / span > numbers_given = [< span class = "number" > 1.0< / span > , < span class = "number" > 2.0< / span > , < span class = "number" > 31.312e211< / span > , -< span class = "number" > 11.32e91< / span > ];
LittleEndian::write_f64_into(< span class = "kw-2" > & < / span > numbers_given, < span class = "kw-2" > & mut < / span > bytes);
< span class = "kw" > let < / span > < span class = "kw-2" > mut < / span > numbers_got = [< span class = "number" > 0.0< / span > ; < span class = "number" > 4< / span > ];
LittleEndian::read_f64_into(< span class = "kw-2" > & < / span > bytes, < span class = "kw-2" > & mut < / span > numbers_got);
< span class = "macro" > assert_eq!< / span > (numbers_given, numbers_got);< / code > < / pre > < / div >
< / div > < / details > < details class = "toggle method-toggle" open > < summary > < section id = "method.read_f64_into_unchecked" class = "method" > < a class = "src rightside" href = "../src/byteorder/lib.rs.html#1299-1301" > source< / a > < h4 class = "code-header" > fn < a href = "#method.read_f64_into_unchecked" class = "fn" > read_f64_into_unchecked< / a > (src: & [u8], dst: & mut [f64])< / h4 > < / section > < / summary > < span class = "item-info" > < div class = "stab deprecated" > < span class = "emoji" > 👎< / span > < span > Deprecated since 1.3.0: please use < code > read_f64_into< / code > instead< / span > < / div > < / span > < div class = "docblock" > < p > < strong > DEPRECATED< / strong > .< / p >
< p > This method is deprecated. Use < code > read_f64_into< / code > instead.< / p >
< p > Reads IEEE754 single-precision (4 bytes) floating point numbers from
< code > src< / code > into < code > dst< / code > .< / p >
< h5 id = "panics-51" > < a href = "#panics-51" > Panics< / a > < / h5 >
< p > Panics when < code > src.len() != 8*dst.len()< / code > .< / p >
< h5 id = "examples-55" > < a href = "#examples-55" > Examples< / a > < / h5 >
< p > Write and read < code > f64< / code > numbers in little endian order:< / p >
< div class = "example-wrap" > < pre class = "rust rust-example-rendered" > < code > < span class = "kw" > use < / span > byteorder::{ByteOrder, LittleEndian};
< span class = "kw" > let < / span > < span class = "kw-2" > mut < / span > bytes = [< span class = "number" > 0< / span > ; < span class = "number" > 32< / span > ];
< span class = "kw" > let < / span > numbers_given = [< span class = "number" > 1.0< / span > , < span class = "number" > 2.0< / span > , < span class = "number" > 31.312e211< / span > , -< span class = "number" > 11.32e91< / span > ];
LittleEndian::write_f64_into(< span class = "kw-2" > & < / span > numbers_given, < span class = "kw-2" > & mut < / span > bytes);
< span class = "kw" > let < / span > < span class = "kw-2" > mut < / span > numbers_got = [< span class = "number" > 0.0< / span > ; < span class = "number" > 4< / span > ];
LittleEndian::read_f64_into_unchecked(< span class = "kw-2" > & < / span > bytes, < span class = "kw-2" > & mut < / span > numbers_got);
< span class = "macro" > assert_eq!< / span > (numbers_given, numbers_got);< / code > < / pre > < / div >
< / div > < / details > < details class = "toggle method-toggle" open > < summary > < section id = "method.write_i8_into" class = "method" > < a class = "src rightside" href = "../src/byteorder/lib.rs.html#1422-1427" > source< / a > < h4 class = "code-header" > fn < a href = "#method.write_i8_into" class = "fn" > write_i8_into< / a > (src: & [i8], dst: & mut [u8])< / h4 > < / section > < / summary > < div class = "docblock" > < p > Writes signed 8 bit integers from < code > src< / code > into < code > dst< / code > .< / p >
< p > Note that since each < code > i8< / code > 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 write from a < code > & [i8]< / code > buffer. (Without this
method, the caller would have to either use < code > unsafe< / code > code or convert
each byte to < code > u8< / code > individually.)< / p >
< h5 id = "panics-52" > < a href = "#panics-52" > Panics< / a > < / h5 >
< p > Panics when < code > buf.len() != src.len()< / code > .< / p >
< h5 id = "examples-56" > < a href = "#examples-56" > Examples< / a > < / h5 >
< p > Write and read < code > i8< / code > numbers in little endian order:< / p >
< div class = "example-wrap" > < pre class = "rust rust-example-rendered" > < code > < span class = "kw" > use < / span > byteorder::{ByteOrder, LittleEndian, ReadBytesExt};
< span class = "kw" > let < / span > < span class = "kw-2" > mut < / span > bytes = [< span class = "number" > 0< / span > ; < span class = "number" > 4< / span > ];
< span class = "kw" > let < / span > numbers_given = [< span class = "number" > 1< / span > , < span class = "number" > 2< / span > , < span class = "number" > 0xf< / span > , < span class = "number" > 0xe< / span > ];
LittleEndian::write_i8_into(< span class = "kw-2" > & < / span > numbers_given, < span class = "kw-2" > & mut < / span > bytes);
< span class = "kw" > let < / span > < span class = "kw-2" > mut < / span > numbers_got = [< span class = "number" > 0< / span > ; < span class = "number" > 4< / span > ];
bytes.as_ref().read_i8_into(< span class = "kw-2" > & mut < / span > numbers_got);
< span class = "macro" > assert_eq!< / span > (numbers_given, numbers_got);< / code > < / pre > < / div >
< / div > < / details > < details class = "toggle method-toggle" open > < summary > < section id = "method.write_i16_into" class = "method" > < a class = "src rightside" href = "../src/byteorder/lib.rs.html#1450-1455" > source< / a > < h4 class = "code-header" > fn < a href = "#method.write_i16_into" class = "fn" > write_i16_into< / a > (src: & [i16], dst: & mut [u8])< / h4 > < / section > < / summary > < div class = "docblock" > < p > Writes signed 16 bit integers from < code > src< / code > into < code > dst< / code > .< / p >
< h5 id = "panics-53" > < a href = "#panics-53" > Panics< / a > < / h5 >
< p > Panics when < code > buf.len() != 2*src.len()< / code > .< / p >
< h5 id = "examples-57" > < a href = "#examples-57" > Examples< / a > < / h5 >
< p > Write and read < code > i16< / code > numbers in little endian order:< / p >
< div class = "example-wrap" > < pre class = "rust rust-example-rendered" > < code > < span class = "kw" > use < / span > byteorder::{ByteOrder, LittleEndian};
< span class = "kw" > let < / span > < span class = "kw-2" > mut < / span > bytes = [< span class = "number" > 0< / span > ; < span class = "number" > 8< / span > ];
< span class = "kw" > let < / span > numbers_given = [< span class = "number" > 1< / span > , < span class = "number" > 2< / span > , < span class = "number" > 0x0f< / span > , < span class = "number" > 0xee< / span > ];
LittleEndian::write_i16_into(< span class = "kw-2" > & < / span > numbers_given, < span class = "kw-2" > & mut < / span > bytes);
< span class = "kw" > let < / span > < span class = "kw-2" > mut < / span > numbers_got = [< span class = "number" > 0< / span > ; < span class = "number" > 4< / span > ];
LittleEndian::read_i16_into(< span class = "kw-2" > & < / span > bytes, < span class = "kw-2" > & mut < / span > numbers_got);
< span class = "macro" > assert_eq!< / span > (numbers_given, numbers_got);< / code > < / pre > < / div >
< / div > < / details > < details class = "toggle method-toggle" open > < summary > < section id = "method.write_i32_into" class = "method" > < a class = "src rightside" href = "../src/byteorder/lib.rs.html#1478-1483" > source< / a > < h4 class = "code-header" > fn < a href = "#method.write_i32_into" class = "fn" > write_i32_into< / a > (src: & [i32], dst: & mut [u8])< / h4 > < / section > < / summary > < div class = "docblock" > < p > Writes signed 32 bit integers from < code > src< / code > into < code > dst< / code > .< / p >
< h5 id = "panics-54" > < a href = "#panics-54" > Panics< / a > < / h5 >
< p > Panics when < code > dst.len() != 4*src.len()< / code > .< / p >
< h5 id = "examples-58" > < a href = "#examples-58" > Examples< / a > < / h5 >
< p > Write and read < code > i32< / code > numbers in little endian order:< / p >
< div class = "example-wrap" > < pre class = "rust rust-example-rendered" > < code > < span class = "kw" > use < / span > byteorder::{ByteOrder, LittleEndian};
< span class = "kw" > let < / span > < span class = "kw-2" > mut < / span > bytes = [< span class = "number" > 0< / span > ; < span class = "number" > 16< / span > ];
< span class = "kw" > let < / span > numbers_given = [< span class = "number" > 1< / span > , < span class = "number" > 2< / span > , < span class = "number" > 0xf00f< / span > , < span class = "number" > 0xffee< / span > ];
LittleEndian::write_i32_into(< span class = "kw-2" > & < / span > numbers_given, < span class = "kw-2" > & mut < / span > bytes);
< span class = "kw" > let < / span > < span class = "kw-2" > mut < / span > numbers_got = [< span class = "number" > 0< / span > ; < span class = "number" > 4< / span > ];
LittleEndian::read_i32_into(< span class = "kw-2" > & < / span > bytes, < span class = "kw-2" > & mut < / span > numbers_got);
< span class = "macro" > assert_eq!< / span > (numbers_given, numbers_got);< / code > < / pre > < / div >
< / div > < / details > < details class = "toggle method-toggle" open > < summary > < section id = "method.write_i64_into" class = "method" > < a class = "src rightside" href = "../src/byteorder/lib.rs.html#1506-1511" > source< / a > < h4 class = "code-header" > fn < a href = "#method.write_i64_into" class = "fn" > write_i64_into< / a > (src: & [i64], dst: & mut [u8])< / h4 > < / section > < / summary > < div class = "docblock" > < p > Writes signed 64 bit integers from < code > src< / code > into < code > dst< / code > .< / p >
< h5 id = "panics-55" > < a href = "#panics-55" > Panics< / a > < / h5 >
< p > Panics when < code > dst.len() != 8*src.len()< / code > .< / p >
< h5 id = "examples-59" > < a href = "#examples-59" > Examples< / a > < / h5 >
< p > Write and read < code > i64< / code > numbers in little endian order:< / p >
< div class = "example-wrap" > < pre class = "rust rust-example-rendered" > < code > < span class = "kw" > use < / span > byteorder::{ByteOrder, LittleEndian};
< span class = "kw" > let < / span > < span class = "kw-2" > mut < / span > bytes = [< span class = "number" > 0< / span > ; < span class = "number" > 32< / span > ];
< span class = "kw" > let < / span > numbers_given = [< span class = "number" > 1< / span > , < span class = "number" > 2< / span > , < span class = "number" > 0xf00f< / span > , < span class = "number" > 0xffee< / span > ];
LittleEndian::write_i64_into(< span class = "kw-2" > & < / span > numbers_given, < span class = "kw-2" > & mut < / span > bytes);
< span class = "kw" > let < / span > < span class = "kw-2" > mut < / span > numbers_got = [< span class = "number" > 0< / span > ; < span class = "number" > 4< / span > ];
LittleEndian::read_i64_into(< span class = "kw-2" > & < / span > bytes, < span class = "kw-2" > & mut < / span > numbers_got);
< span class = "macro" > assert_eq!< / span > (numbers_given, numbers_got);< / code > < / pre > < / div >
< / div > < / details > < details class = "toggle method-toggle" open > < summary > < section id = "method.write_i128_into" class = "method" > < a class = "src rightside" href = "../src/byteorder/lib.rs.html#1534-1539" > source< / a > < h4 class = "code-header" > fn < a href = "#method.write_i128_into" class = "fn" > write_i128_into< / a > (src: & [i128], dst: & mut [u8])< / h4 > < / section > < / summary > < div class = "docblock" > < p > Writes signed 128 bit integers from < code > src< / code > into < code > dst< / code > .< / p >
< h5 id = "panics-56" > < a href = "#panics-56" > Panics< / a > < / h5 >
< p > Panics when < code > dst.len() != 16*src.len()< / code > .< / p >
< h5 id = "examples-60" > < a href = "#examples-60" > Examples< / a > < / h5 >
< p > Write and read < code > i128< / code > numbers in little endian order:< / p >
< div class = "example-wrap" > < pre class = "rust rust-example-rendered" > < code > < span class = "kw" > use < / span > byteorder::{ByteOrder, LittleEndian};
< span class = "kw" > let < / span > < span class = "kw-2" > mut < / span > bytes = [< span class = "number" > 0< / span > ; < span class = "number" > 64< / span > ];
< span class = "kw" > let < / span > numbers_given = [< span class = "number" > 1< / span > , < span class = "number" > 2< / span > , < span class = "number" > 0xf00f< / span > , < span class = "number" > 0xffee< / span > ];
LittleEndian::write_i128_into(< span class = "kw-2" > & < / span > numbers_given, < span class = "kw-2" > & mut < / span > bytes);
< span class = "kw" > let < / span > < span class = "kw-2" > mut < / span > numbers_got = [< span class = "number" > 0< / span > ; < span class = "number" > 4< / span > ];
LittleEndian::read_i128_into(< span class = "kw-2" > & < / span > bytes, < span class = "kw-2" > & mut < / span > numbers_got);
< span class = "macro" > assert_eq!< / span > (numbers_given, numbers_got);< / code > < / pre > < / div >
< / div > < / details > < details class = "toggle method-toggle" open > < summary > < section id = "method.write_f32_into" class = "method" > < a class = "src rightside" href = "../src/byteorder/lib.rs.html#1563-1568" > source< / a > < h4 class = "code-header" > fn < a href = "#method.write_f32_into" class = "fn" > write_f32_into< / a > (src: & [f32], dst: & mut [u8])< / h4 > < / section > < / summary > < div class = "docblock" > < p > Writes IEEE754 single-precision (4 bytes) floating point numbers from
< code > src< / code > into < code > dst< / code > .< / p >
< h5 id = "panics-57" > < a href = "#panics-57" > Panics< / a > < / h5 >
< p > Panics when < code > src.len() != 4*dst.len()< / code > .< / p >
< h5 id = "examples-61" > < a href = "#examples-61" > Examples< / a > < / h5 >
< p > Write and read < code > f32< / code > numbers in little endian order:< / p >
< div class = "example-wrap" > < pre class = "rust rust-example-rendered" > < code > < span class = "kw" > use < / span > byteorder::{ByteOrder, LittleEndian};
< span class = "kw" > let < / span > < span class = "kw-2" > mut < / span > bytes = [< span class = "number" > 0< / span > ; < span class = "number" > 16< / span > ];
< span class = "kw" > let < / span > numbers_given = [< span class = "number" > 1.0< / span > , < span class = "number" > 2.0< / span > , < span class = "number" > 31.312e31< / span > , -< span class = "number" > 11.32e19< / span > ];
LittleEndian::write_f32_into(< span class = "kw-2" > & < / span > numbers_given, < span class = "kw-2" > & mut < / span > bytes);
< span class = "kw" > let < / span > < span class = "kw-2" > mut < / span > numbers_got = [< span class = "number" > 0.0< / span > ; < span class = "number" > 4< / span > ];
LittleEndian::read_f32_into(< span class = "kw-2" > & < / span > bytes, < span class = "kw-2" > & mut < / span > numbers_got);
< span class = "macro" > assert_eq!< / span > (numbers_given, numbers_got);< / code > < / pre > < / div >
< / div > < / details > < details class = "toggle method-toggle" open > < summary > < section id = "method.write_f64_into" class = "method" > < a class = "src rightside" href = "../src/byteorder/lib.rs.html#1592-1597" > source< / a > < h4 class = "code-header" > fn < a href = "#method.write_f64_into" class = "fn" > write_f64_into< / a > (src: & [f64], dst: & mut [u8])< / h4 > < / section > < / summary > < div class = "docblock" > < p > Writes IEEE754 double-precision (8 bytes) floating point numbers from
< code > src< / code > into < code > dst< / code > .< / p >
< h5 id = "panics-58" > < a href = "#panics-58" > Panics< / a > < / h5 >
< p > Panics when < code > src.len() != 8*dst.len()< / code > .< / p >
< h5 id = "examples-62" > < a href = "#examples-62" > Examples< / a > < / h5 >
< p > Write and read < code > f64< / code > numbers in little endian order:< / p >
< div class = "example-wrap" > < pre class = "rust rust-example-rendered" > < code > < span class = "kw" > use < / span > byteorder::{ByteOrder, LittleEndian};
< span class = "kw" > let < / span > < span class = "kw-2" > mut < / span > bytes = [< span class = "number" > 0< / span > ; < span class = "number" > 32< / span > ];
< span class = "kw" > let < / span > numbers_given = [< span class = "number" > 1.0< / span > , < span class = "number" > 2.0< / span > , < span class = "number" > 31.312e211< / span > , -< span class = "number" > 11.32e91< / span > ];
LittleEndian::write_f64_into(< span class = "kw-2" > & < / span > numbers_given, < span class = "kw-2" > & mut < / span > bytes);
< span class = "kw" > let < / span > < span class = "kw-2" > mut < / span > numbers_got = [< span class = "number" > 0.0< / span > ; < span class = "number" > 4< / span > ];
LittleEndian::read_f64_into(< span class = "kw-2" > & < / span > bytes, < span class = "kw-2" > & mut < / span > numbers_got);
< span class = "macro" > assert_eq!< / span > (numbers_given, numbers_got);< / code > < / pre > < / div >
< / div > < / details > < details class = "toggle method-toggle" open > < summary > < section id = "method.from_slice_i16" class = "method" > < a class = "src rightside" href = "../src/byteorder/lib.rs.html#1693-1698" > source< / a > < h4 class = "code-header" > fn < a href = "#method.from_slice_i16" class = "fn" > from_slice_i16< / a > (src: & mut [i16])< / h4 > < / section > < / summary > < div class = "docblock" > < p > Converts the given slice of signed 16 bit integers to a particular
endianness.< / p >
< p > If the endianness matches the endianness of the host platform, then
this is a no-op.< / p >
< h5 id = "examples-63" > < a href = "#examples-63" > Examples< / a > < / h5 >
< p > Convert the host platform’ < / p >
< div class = "example-wrap" > < pre class = "rust rust-example-rendered" > < code > < span class = "kw" > use < / span > byteorder::{ByteOrder, BigEndian};
< span class = "kw" > let < / span > < span class = "kw-2" > mut < / span > numbers = [< span class = "number" > 5< / span > , < span class = "number" > 6500< / span > ];
BigEndian::from_slice_i16(< span class = "kw-2" > & mut < / span > numbers);
< span class = "macro" > assert_eq!< / span > (numbers, [< span class = "number" > 5i16< / span > .to_be(), < span class = "number" > 6500i16< / span > .to_be()]);< / code > < / pre > < / div >
< / div > < / details > < details class = "toggle method-toggle" open > < summary > < section id = "method.from_slice_i32" class = "method" > < a class = "src rightside" href = "../src/byteorder/lib.rs.html#1718-1723" > source< / a > < h4 class = "code-header" > fn < a href = "#method.from_slice_i32" class = "fn" > from_slice_i32< / a > (src: & mut [i32])< / h4 > < / section > < / summary > < div class = "docblock" > < p > Converts the given slice of signed 32 bit integers to a particular
endianness.< / p >
< p > If the endianness matches the endianness of the host platform, then
this is a no-op.< / p >
< h5 id = "examples-64" > < a href = "#examples-64" > Examples< / a > < / h5 >
< p > Convert the host platform’ < / p >
< div class = "example-wrap" > < pre class = "rust rust-example-rendered" > < code > < span class = "kw" > use < / span > byteorder::{ByteOrder, BigEndian};
< span class = "kw" > let < / span > < span class = "kw-2" > mut < / span > numbers = [< span class = "number" > 5< / span > , < span class = "number" > 65000< / span > ];
BigEndian::from_slice_i32(< span class = "kw-2" > & mut < / span > numbers);
< span class = "macro" > assert_eq!< / span > (numbers, [< span class = "number" > 5i32< / span > .to_be(), < span class = "number" > 65000i32< / span > .to_be()]);< / code > < / pre > < / div >
< / div > < / details > < details class = "toggle method-toggle" open > < summary > < section id = "method.from_slice_i64" class = "method" > < a class = "src rightside" href = "../src/byteorder/lib.rs.html#1743-1748" > source< / a > < h4 class = "code-header" > fn < a href = "#method.from_slice_i64" class = "fn" > from_slice_i64< / a > (src: & mut [i64])< / h4 > < / section > < / summary > < div class = "docblock" > < p > Converts the given slice of signed 64 bit integers to a particular
endianness.< / p >
< p > If the endianness matches the endianness of the host platform, then
this is a no-op.< / p >
< h5 id = "examples-65" > < a href = "#examples-65" > Examples< / a > < / h5 >
< p > Convert the host platform’ < / p >
< div class = "example-wrap" > < pre class = "rust rust-example-rendered" > < code > < span class = "kw" > use < / span > byteorder::{ByteOrder, BigEndian};
< span class = "kw" > let < / span > < span class = "kw-2" > mut < / span > numbers = [< span class = "number" > 5< / span > , < span class = "number" > 65000< / span > ];
BigEndian::from_slice_i64(< span class = "kw-2" > & mut < / span > numbers);
< span class = "macro" > assert_eq!< / span > (numbers, [< span class = "number" > 5i64< / span > .to_be(), < span class = "number" > 65000i64< / span > .to_be()]);< / code > < / pre > < / div >
< / div > < / details > < details class = "toggle method-toggle" open > < summary > < section id = "method.from_slice_i128" class = "method" > < a class = "src rightside" href = "../src/byteorder/lib.rs.html#1768-1773" > source< / a > < h4 class = "code-header" > fn < a href = "#method.from_slice_i128" class = "fn" > from_slice_i128< / a > (src: & mut [i128])< / h4 > < / section > < / summary > < div class = "docblock" > < p > Converts the given slice of signed 128 bit integers to a particular
endianness.< / p >
< p > If the endianness matches the endianness of the host platform, then
this is a no-op.< / p >
< h5 id = "examples-66" > < a href = "#examples-66" > Examples< / a > < / h5 >
< p > Convert the host platform’ < / p >
< div class = "example-wrap" > < pre class = "rust rust-example-rendered" > < code > < span class = "kw" > use < / span > byteorder::{ByteOrder, BigEndian};
< span class = "kw" > let < / span > < span class = "kw-2" > mut < / span > numbers = [< span class = "number" > 5< / span > , < span class = "number" > 65000< / span > ];
BigEndian::from_slice_i128(< span class = "kw-2" > & mut < / span > numbers);
< span class = "macro" > assert_eq!< / span > (numbers, [< span class = "number" > 5i128< / span > .to_be(), < span class = "number" > 65000i128< / span > .to_be()]);< / code > < / pre > < / div >
< / div > < / details > < / div > < h2 id = "implementors" class = "small-section-header" > Implementors< a href = "#implementors" class = "anchor" > §< / a > < / h2 > < div id = "implementors-list" > < section id = "impl-ByteOrder-for-BigEndian" class = "impl" > < a class = "src rightside" href = "../src/byteorder/lib.rs.html#1970-2184" > source< / a > < a href = "#impl-ByteOrder-for-BigEndian" class = "anchor" > §< / a > < h3 class = "code-header" > impl < a class = "trait" href = "trait.ByteOrder.html" title = "trait byteorder::ByteOrder" > ByteOrder< / a > for < a class = "enum" href = "enum.BigEndian.html" title = "enum byteorder::BigEndian" > BigEndian< / a > < / h3 > < / section > < section id = "impl-ByteOrder-for-LittleEndian" class = "impl" > < a class = "src rightside" href = "../src/byteorder/lib.rs.html#2186-2384" > source< / a > < a href = "#impl-ByteOrder-for-LittleEndian" class = "anchor" > §< / a > < h3 class = "code-header" > impl < a class = "trait" href = "trait.ByteOrder.html" title = "trait byteorder::ByteOrder" > ByteOrder< / a > for < a class = "enum" href = "enum.LittleEndian.html" title = "enum byteorder::LittleEndian" > LittleEndian< / a > < / h3 > < / section > < / div > < script src = "../implementors/byteorder/trait.ByteOrder.js" async > < / script > < / section > < / div > < / main > < / body > < / html >
