Struct Le

Source

#[repr(transparent)]
pub struct Le<T>(pub T);

Expand description

An integer stored in little-endian byte order.

§Examples

use endian_num::Le;

let n = 0x1Au32;

if cfg!(target_endian = "little") {
    assert_eq!(Le::<u32>::from_ne(n).0, n);
} else {
    assert_eq!(Le::<u32>::from_ne(n).0, n.swap_bytes());
}

pub const fn from_ne(n: u8) -> Le<u8>

Creates a new little-endian integer from a native-endian integer.

On little endian, this is a no-op. On big endian, the bytes are swapped.

§Examples

Basic usage:

use endian_num::Le;

let n = 0x1Au8;

if cfg!(target_endian = "little") {
    assert_eq!(Le::<u8>::from_ne(n).0, n);
} else {
    assert_eq!(Le::<u8>::from_ne(n).0, n.swap_bytes());
}

Source

pub const fn from_be(n: Be<u8>) -> Le<u8>

Creates a new little-endian integer from a big-endian integer.

This always swaps the bytes.

§Examples

use endian_num::{Be, Le};

let n = 0x1Au8;

assert_eq!(Le::<u8>::from_be(Be(n)).0, n.swap_bytes());

Source

pub const fn to_ne(self) -> u8

Returns the integer in native-endian byte order.

On little endian, this is a no-op. On big endian, the bytes are swapped.

§Examples

Basic usage:

use endian_num::Le;

let n = 0x1Au8;

if cfg!(target_endian = "little") {
    assert_eq!(Le(n).to_ne(), n);
} else {
    assert_eq!(Le(n).to_ne(), n.swap_bytes());
}

Source

pub const fn to_be(self) -> Be<u8>

Returns the integer in big-endian byte order.

This always swaps the bytes.

§Examples

Basic usage:

use endian_num::Le;

let n = 0x1Au8;

assert_eq!(Le(n).to_be().0, n.swap_bytes());

Source

pub const fn to_be_bytes(self) -> [u8; 1]

Return the memory representation of this integer as a byte array in big-endian (network) byte order.

§Examples

use endian_num::Le;

let bytes = Le::<u8>::from_ne(0x12).to_be_bytes();
assert_eq!(bytes, [0x12]);

Source

pub const fn to_le_bytes(self) -> [u8; 1]

Return the memory representation of this integer as a byte array in little-endian byte order.

§Examples

use endian_num::Le;

let bytes = Le::<u8>::from_ne(0x12).to_le_bytes();
assert_eq!(bytes, [0x12]);

Source

pub const fn to_ne_bytes(self) -> [u8; 1]

Return the memory representation of this integer as a byte array in native byte order.

As the target platform’s native endianness is used, portable code should use to_be_bytes or to_le_bytes, as appropriate, instead.

§Examples

use endian_num::Le;

let bytes = Le::<u8>::from_ne(0x12).to_ne_bytes();
assert_eq!(
    bytes,
    if cfg!(target_endian = "big") {
        [0x12]
    } else {
        [0x12]
    }
);

Source

pub const fn from_be_bytes(bytes: [u8; 1]) -> Le<u8>

Create a little endian integer value from its representation as a byte array in little endian.

§Examples

use endian_num::Le;

let value = Le::<u8>::from_be_bytes([0x12]);
assert_eq!(value.to_ne(), 0x12);

When starting from a slice rather than an array, fallible conversion APIs can be used:

use endian_num::Le;

fn read_be_u8(input: &mut &[u8]) -> Le<u8> {
    let (int_bytes, rest) = input.split_at(std::mem::size_of::<Le<u8>>());
    *input = rest;
    Le::<u8>::from_be_bytes(int_bytes.try_into().unwrap())
}

Source

pub const fn from_le_bytes(bytes: [u8; 1]) -> Le<u8>

Create a little endian integer value from its representation as a byte array in big endian.

§Examples

use endian_num::Le;

let value = Le::<u8>::from_le_bytes([0x12]);
assert_eq!(value.to_ne(), 0x12);

When starting from a slice rather than an array, fallible conversion APIs can be used:

use endian_num::Le;

fn read_le_u8(input: &mut &[u8]) -> Le<u8> {
    let (int_bytes, rest) = input.split_at(std::mem::size_of::<Le<u8>>());
    *input = rest;
    Le::<u8>::from_le_bytes(int_bytes.try_into().unwrap())
}

Source

pub const fn from_ne_bytes(bytes: [u8; 1]) -> Le<u8>

Create a little endian integer value from its memory representation as a byte array in native endianness.

As the target platform’s native endianness is used, portable code likely wants to use from_be_bytes or from_le_bytes, as appropriate instead.

§Examples

use endian_num::Le;

let value = Le::<u8>::from_ne_bytes(if cfg!(target_endian = "big") {
    [0x12]
} else {
    [0x12]
});
assert_eq!(value.to_ne(), 0x12);

When starting from a slice rather than an array, fallible conversion APIs can be used:

use endian_num::Le;

fn read_ne_u8(input: &mut &[u8]) -> Le<u8> {
    let (int_bytes, rest) = input.split_at(std::mem::size_of::<Le<u8>>());
    *input = rest;
    Le::<u8>::from_ne_bytes(int_bytes.try_into().unwrap())
}

Source

pub const fn rotate_left(self, n: u32) -> Le<u8>

Shifts the bits to the left by a specified amount, n, wrapping the truncated bits to the end of the resulting integer.

Please note this isn’t the same operation as the << shifting operator!

§Examples

Basic usage:

use endian_num::Le;

let n = Le::<u8>::from_ne(0x82);
let m = Le::<u8>::from_ne(0xa);

assert_eq!(n.rotate_left(2), m);

Source

pub const fn rotate_right(self, n: u32) -> Le<u8>

Shifts the bits to the right by a specified amount, n, wrapping the truncated bits to the beginning of the resulting integer.

Please note this isn’t the same operation as the >> shifting operator!

§Examples

Basic usage:

use endian_num::Le;

let n = Le::<u8>::from_ne(0xa);
let m = Le::<u8>::from_ne(0x82);

assert_eq!(n.rotate_right(2), m);

Source

pub const fn swap_bytes(self) -> Le<u8>

Reverses the byte order of the integer.

§Examples

Basic usage:

use endian_num::Le;

let n = Le(0x12u8);
let m = n.swap_bytes();

assert_eq!(m, Le(0x12));

Source

pub const fn reverse_bits(self) -> Le<u8>

Reverses the order of bits in the integer.

The least significant bit becomes the most significant bit, second least-significant bit becomes second most-significant bit, etc.

§Examples

Basic usage:

use endian_num::Le;

let n = Le(0x12u8);
let m = n.reverse_bits();

assert_eq!(m, Le(0x48));
assert_eq!(Le(0), Le(0u8).reverse_bits());

Source

pub const fn pow(self, exp: u32) -> Le<u8>

Raises self to the power of exp, using exponentiation by squaring.

§Examples

Basic usage:

use endian_num::Le;

assert_eq!(Le::<u8>::from_ne(2).pow(5).to_ne(), 32);

Basic usage:

use endian_num::Le;

assert_eq!(Le::<u16>::BITS, u16::BITS);

Source

pub const fn from_ne(n: u16) -> Le<u16>

Creates a new little-endian integer from a native-endian integer.

On little endian, this is a no-op. On big endian, the bytes are swapped.

§Examples

Basic usage:

use endian_num::Le;

let n = 0x1Au16;

if cfg!(target_endian = "little") {
    assert_eq!(Le::<u16>::from_ne(n).0, n);
} else {
    assert_eq!(Le::<u16>::from_ne(n).0, n.swap_bytes());
}

Source

pub const fn from_be(n: Be<u16>) -> Le<u16>

Creates a new little-endian integer from a big-endian integer.

This always swaps the bytes.

§Examples

use endian_num::{Be, Le};

let n = 0x1Au16;

assert_eq!(Le::<u16>::from_be(Be(n)).0, n.swap_bytes());

Source

pub const fn to_ne(self) -> u16

Returns the integer in native-endian byte order.

On little endian, this is a no-op. On big endian, the bytes are swapped.

§Examples

Basic usage:

use endian_num::Le;

let n = 0x1Au16;

if cfg!(target_endian = "little") {
    assert_eq!(Le(n).to_ne(), n);
} else {
    assert_eq!(Le(n).to_ne(), n.swap_bytes());
}

Source

pub const fn to_be(self) -> Be<u16>

Returns the integer in big-endian byte order.

This always swaps the bytes.

§Examples

Basic usage:

use endian_num::Le;

let n = 0x1Au16;

assert_eq!(Le(n).to_be().0, n.swap_bytes());

Source

pub const fn to_be_bytes(self) -> [u8; 2]

Return the memory representation of this integer as a byte array in big-endian (network) byte order.

§Examples

use endian_num::Le;

let bytes = Le::<u16>::from_ne(0x1234).to_be_bytes();
assert_eq!(bytes, [0x12, 0x34]);

Source

pub const fn to_le_bytes(self) -> [u8; 2]

Return the memory representation of this integer as a byte array in little-endian byte order.

§Examples

use endian_num::Le;

let bytes = Le::<u16>::from_ne(0x1234).to_le_bytes();
assert_eq!(bytes, [0x34, 0x12]);

Source

pub const fn to_ne_bytes(self) -> [u8; 2]

Return the memory representation of this integer as a byte array in native byte order.

As the target platform’s native endianness is used, portable code should use to_be_bytes or to_le_bytes, as appropriate, instead.

§Examples

use endian_num::Le;

let bytes = Le::<u16>::from_ne(0x1234).to_ne_bytes();
assert_eq!(
    bytes,
    if cfg!(target_endian = "big") {
        [0x12, 0x34]
    } else {
        [0x34, 0x12]
    }
);

Source

pub const fn from_be_bytes(bytes: [u8; 2]) -> Le<u16>

Create a little endian integer value from its representation as a byte array in little endian.

§Examples

use endian_num::Le;

let value = Le::<u16>::from_be_bytes([0x12, 0x34]);
assert_eq!(value.to_ne(), 0x1234);

When starting from a slice rather than an array, fallible conversion APIs can be used:

use endian_num::Le;

fn read_be_u16(input: &mut &[u8]) -> Le<u16> {
    let (int_bytes, rest) = input.split_at(std::mem::size_of::<Le<u16>>());
    *input = rest;
    Le::<u16>::from_be_bytes(int_bytes.try_into().unwrap())
}

Source

pub const fn from_le_bytes(bytes: [u8; 2]) -> Le<u16>

Create a little endian integer value from its representation as a byte array in big endian.

§Examples

use endian_num::Le;

let value = Le::<u16>::from_le_bytes([0x34, 0x12]);
assert_eq!(value.to_ne(), 0x1234);

When starting from a slice rather than an array, fallible conversion APIs can be used:

use endian_num::Le;

fn read_le_u16(input: &mut &[u8]) -> Le<u16> {
    let (int_bytes, rest) = input.split_at(std::mem::size_of::<Le<u16>>());
    *input = rest;
    Le::<u16>::from_le_bytes(int_bytes.try_into().unwrap())
}

Source

pub const fn from_ne_bytes(bytes: [u8; 2]) -> Le<u16>

Create a little endian integer value from its memory representation as a byte array in native endianness.

As the target platform’s native endianness is used, portable code likely wants to use from_be_bytes or from_le_bytes, as appropriate instead.

§Examples

use endian_num::Le;

let value = Le::<u16>::from_ne_bytes(if cfg!(target_endian = "big") {
    [0x12, 0x34]
} else {
    [0x34, 0x12]
});
assert_eq!(value.to_ne(), 0x1234);

When starting from a slice rather than an array, fallible conversion APIs can be used:

use endian_num::Le;

fn read_ne_u16(input: &mut &[u8]) -> Le<u16> {
    let (int_bytes, rest) = input.split_at(std::mem::size_of::<Le<u16>>());
    *input = rest;
    Le::<u16>::from_ne_bytes(int_bytes.try_into().unwrap())
}

Source

pub const fn rotate_left(self, n: u32) -> Le<u16>

Shifts the bits to the left by a specified amount, n, wrapping the truncated bits to the end of the resulting integer.

Please note this isn’t the same operation as the << shifting operator!

§Examples

Basic usage:

use endian_num::Le;

let n = Le::<u16>::from_ne(0xa003);
let m = Le::<u16>::from_ne(0x3a);

assert_eq!(n.rotate_left(4), m);

Source

pub const fn rotate_right(self, n: u32) -> Le<u16>

Shifts the bits to the right by a specified amount, n, wrapping the truncated bits to the beginning of the resulting integer.

Please note this isn’t the same operation as the >> shifting operator!

§Examples

Basic usage:

use endian_num::Le;

let n = Le::<u16>::from_ne(0x3a);
let m = Le::<u16>::from_ne(0xa003);

assert_eq!(n.rotate_right(4), m);

Source

pub const fn swap_bytes(self) -> Le<u16>

Reverses the byte order of the integer.

§Examples

Basic usage:

use endian_num::Le;

let n = Le(0x1234u16);
let m = n.swap_bytes();

assert_eq!(m, Le(0x3412));

Source

pub const fn reverse_bits(self) -> Le<u16>

Reverses the order of bits in the integer.

The least significant bit becomes the most significant bit, second least-significant bit becomes second most-significant bit, etc.

§Examples

Basic usage:

use endian_num::Le;

let n = Le(0x1234u16);
let m = n.reverse_bits();

assert_eq!(m, Le(0x2c48));
assert_eq!(Le(0), Le(0u16).reverse_bits());

Source

pub const fn pow(self, exp: u32) -> Le<u16>

Raises self to the power of exp, using exponentiation by squaring.

§Examples

Basic usage:

use endian_num::Le;

assert_eq!(Le::<u16>::from_ne(2).pow(5).to_ne(), 32);

Basic usage:

use endian_num::Le;

assert_eq!(Le::<u32>::BITS, u32::BITS);

Source

pub const fn from_ne(n: u32) -> Le<u32>

Creates a new little-endian integer from a native-endian integer.

On little endian, this is a no-op. On big endian, the bytes are swapped.

§Examples

Basic usage:

use endian_num::Le;

let n = 0x1Au32;

if cfg!(target_endian = "little") {
    assert_eq!(Le::<u32>::from_ne(n).0, n);
} else {
    assert_eq!(Le::<u32>::from_ne(n).0, n.swap_bytes());
}

Source

pub const fn from_be(n: Be<u32>) -> Le<u32>

Creates a new little-endian integer from a big-endian integer.

This always swaps the bytes.

§Examples

use endian_num::{Be, Le};

let n = 0x1Au32;

assert_eq!(Le::<u32>::from_be(Be(n)).0, n.swap_bytes());

Source

pub const fn to_ne(self) -> u32

Returns the integer in native-endian byte order.

On little endian, this is a no-op. On big endian, the bytes are swapped.

§Examples

Basic usage:

use endian_num::Le;

let n = 0x1Au32;

if cfg!(target_endian = "little") {
    assert_eq!(Le(n).to_ne(), n);
} else {
    assert_eq!(Le(n).to_ne(), n.swap_bytes());
}

Source

pub const fn to_be(self) -> Be<u32>

Returns the integer in big-endian byte order.

This always swaps the bytes.

§Examples

Basic usage:

use endian_num::Le;

let n = 0x1Au32;

assert_eq!(Le(n).to_be().0, n.swap_bytes());

Source

pub const fn to_be_bytes(self) -> [u8; 4]

Return the memory representation of this integer as a byte array in big-endian (network) byte order.

§Examples

use endian_num::Le;

let bytes = Le::<u32>::from_ne(0x12345678).to_be_bytes();
assert_eq!(bytes, [0x12, 0x34, 0x56, 0x78]);

Source

pub const fn to_le_bytes(self) -> [u8; 4]

Return the memory representation of this integer as a byte array in little-endian byte order.

§Examples

use endian_num::Le;

let bytes = Le::<u32>::from_ne(0x12345678).to_le_bytes();
assert_eq!(bytes, [0x78, 0x56, 0x34, 0x12]);

Source

pub const fn to_ne_bytes(self) -> [u8; 4]

Return the memory representation of this integer as a byte array in native byte order.

As the target platform’s native endianness is used, portable code should use to_be_bytes or to_le_bytes, as appropriate, instead.

§Examples

use endian_num::Le;

let bytes = Le::<u32>::from_ne(0x12345678).to_ne_bytes();
assert_eq!(
    bytes,
    if cfg!(target_endian = "big") {
        [0x12, 0x34, 0x56, 0x78]
    } else {
        [0x78, 0x56, 0x34, 0x12]
    }
);

Source

pub const fn from_be_bytes(bytes: [u8; 4]) -> Le<u32>

Create a little endian integer value from its representation as a byte array in little endian.

§Examples

use endian_num::Le;

let value = Le::<u32>::from_be_bytes([0x12, 0x34, 0x56, 0x78]);
assert_eq!(value.to_ne(), 0x12345678);

When starting from a slice rather than an array, fallible conversion APIs can be used:

use endian_num::Le;

fn read_be_u32(input: &mut &[u8]) -> Le<u32> {
    let (int_bytes, rest) = input.split_at(std::mem::size_of::<Le<u32>>());
    *input = rest;
    Le::<u32>::from_be_bytes(int_bytes.try_into().unwrap())
}

Source

pub const fn from_le_bytes(bytes: [u8; 4]) -> Le<u32>

Create a little endian integer value from its representation as a byte array in big endian.

§Examples

use endian_num::Le;

let value = Le::<u32>::from_le_bytes([0x78, 0x56, 0x34, 0x12]);
assert_eq!(value.to_ne(), 0x12345678);

When starting from a slice rather than an array, fallible conversion APIs can be used:

use endian_num::Le;

fn read_le_u32(input: &mut &[u8]) -> Le<u32> {
    let (int_bytes, rest) = input.split_at(std::mem::size_of::<Le<u32>>());
    *input = rest;
    Le::<u32>::from_le_bytes(int_bytes.try_into().unwrap())
}

Source

pub const fn from_ne_bytes(bytes: [u8; 4]) -> Le<u32>

Create a little endian integer value from its memory representation as a byte array in native endianness.

As the target platform’s native endianness is used, portable code likely wants to use from_be_bytes or from_le_bytes, as appropriate instead.

§Examples

use endian_num::Le;

let value = Le::<u32>::from_ne_bytes(if cfg!(target_endian = "big") {
    [0x12, 0x34, 0x56, 0x78]
} else {
    [0x78, 0x56, 0x34, 0x12]
});
assert_eq!(value.to_ne(), 0x12345678);

When starting from a slice rather than an array, fallible conversion APIs can be used:

use endian_num::Le;

fn read_ne_u32(input: &mut &[u8]) -> Le<u32> {
    let (int_bytes, rest) = input.split_at(std::mem::size_of::<Le<u32>>());
    *input = rest;
    Le::<u32>::from_ne_bytes(int_bytes.try_into().unwrap())
}

Source

pub const fn rotate_left(self, n: u32) -> Le<u32>

Shifts the bits to the left by a specified amount, n, wrapping the truncated bits to the end of the resulting integer.

Please note this isn’t the same operation as the << shifting operator!

§Examples

Basic usage:

use endian_num::Le;

let n = Le::<u32>::from_ne(0x10000b3);
let m = Le::<u32>::from_ne(0xb301);

assert_eq!(n.rotate_left(8), m);

Source

pub const fn rotate_right(self, n: u32) -> Le<u32>

Shifts the bits to the right by a specified amount, n, wrapping the truncated bits to the beginning of the resulting integer.

Please note this isn’t the same operation as the >> shifting operator!

§Examples

Basic usage:

use endian_num::Le;

let n = Le::<u32>::from_ne(0xb301);
let m = Le::<u32>::from_ne(0x10000b3);

assert_eq!(n.rotate_right(8), m);

Source

pub const fn swap_bytes(self) -> Le<u32>

Reverses the byte order of the integer.

§Examples

Basic usage:

use endian_num::Le;

let n = Le(0x12345678u32);
let m = n.swap_bytes();

assert_eq!(m, Le(0x78563412));

Source

pub const fn reverse_bits(self) -> Le<u32>

Reverses the order of bits in the integer.

The least significant bit becomes the most significant bit, second least-significant bit becomes second most-significant bit, etc.

§Examples

Basic usage:

use endian_num::Le;

let n = Le(0x12345678u32);
let m = n.reverse_bits();

assert_eq!(m, Le(0x1e6a2c48));
assert_eq!(Le(0), Le(0u32).reverse_bits());

Source

pub const fn pow(self, exp: u32) -> Le<u32>

Raises self to the power of exp, using exponentiation by squaring.

§Examples

Basic usage:

use endian_num::Le;

assert_eq!(Le::<u32>::from_ne(2).pow(5).to_ne(), 32);

Basic usage:

use endian_num::Le;

assert_eq!(Le::<u64>::BITS, u64::BITS);

Source

pub const fn from_ne(n: u64) -> Le<u64>

Creates a new little-endian integer from a native-endian integer.

On little endian, this is a no-op. On big endian, the bytes are swapped.

§Examples

Basic usage:

use endian_num::Le;

let n = 0x1Au64;

if cfg!(target_endian = "little") {
    assert_eq!(Le::<u64>::from_ne(n).0, n);
} else {
    assert_eq!(Le::<u64>::from_ne(n).0, n.swap_bytes());
}

Source

pub const fn from_be(n: Be<u64>) -> Le<u64>

Creates a new little-endian integer from a big-endian integer.

This always swaps the bytes.

§Examples

use endian_num::{Be, Le};

let n = 0x1Au64;

assert_eq!(Le::<u64>::from_be(Be(n)).0, n.swap_bytes());

Source

pub const fn to_ne(self) -> u64

Returns the integer in native-endian byte order.

On little endian, this is a no-op. On big endian, the bytes are swapped.

§Examples

Basic usage:

use endian_num::Le;

let n = 0x1Au64;

if cfg!(target_endian = "little") {
    assert_eq!(Le(n).to_ne(), n);
} else {
    assert_eq!(Le(n).to_ne(), n.swap_bytes());
}

Source

pub const fn to_be(self) -> Be<u64>

Returns the integer in big-endian byte order.

This always swaps the bytes.

§Examples

Basic usage:

use endian_num::Le;

let n = 0x1Au64;

assert_eq!(Le(n).to_be().0, n.swap_bytes());

Source

pub const fn to_be_bytes(self) -> [u8; 8]

Return the memory representation of this integer as a byte array in big-endian (network) byte order.

§Examples

use endian_num::Le;

let bytes = Le::<u64>::from_ne(0x1234567890123456).to_be_bytes();
assert_eq!(bytes, [0x12, 0x34, 0x56, 0x78, 0x90, 0x12, 0x34, 0x56]);

Source

pub const fn to_le_bytes(self) -> [u8; 8]

Return the memory representation of this integer as a byte array in little-endian byte order.

§Examples

use endian_num::Le;

let bytes = Le::<u64>::from_ne(0x1234567890123456).to_le_bytes();
assert_eq!(bytes, [0x56, 0x34, 0x12, 0x90, 0x78, 0x56, 0x34, 0x12]);

Source

pub const fn to_ne_bytes(self) -> [u8; 8]

Return the memory representation of this integer as a byte array in native byte order.

As the target platform’s native endianness is used, portable code should use to_be_bytes or to_le_bytes, as appropriate, instead.

§Examples

use endian_num::Le;

let bytes = Le::<u64>::from_ne(0x1234567890123456).to_ne_bytes();
assert_eq!(
    bytes,
    if cfg!(target_endian = "big") {
        [0x12, 0x34, 0x56, 0x78, 0x90, 0x12, 0x34, 0x56]
    } else {
        [0x56, 0x34, 0x12, 0x90, 0x78, 0x56, 0x34, 0x12]
    }
);

Source

pub const fn from_be_bytes(bytes: [u8; 8]) -> Le<u64>

Create a little endian integer value from its representation as a byte array in little endian.

§Examples

use endian_num::Le;

let value = Le::<u64>::from_be_bytes([0x12, 0x34, 0x56, 0x78, 0x90, 0x12, 0x34, 0x56]);
assert_eq!(value.to_ne(), 0x1234567890123456);

When starting from a slice rather than an array, fallible conversion APIs can be used:

use endian_num::Le;

fn read_be_u64(input: &mut &[u8]) -> Le<u64> {
    let (int_bytes, rest) = input.split_at(std::mem::size_of::<Le<u64>>());
    *input = rest;
    Le::<u64>::from_be_bytes(int_bytes.try_into().unwrap())
}

Source

pub const fn from_le_bytes(bytes: [u8; 8]) -> Le<u64>

Create a little endian integer value from its representation as a byte array in big endian.

§Examples

use endian_num::Le;

let value = Le::<u64>::from_le_bytes([0x56, 0x34, 0x12, 0x90, 0x78, 0x56, 0x34, 0x12]);
assert_eq!(value.to_ne(), 0x1234567890123456);

When starting from a slice rather than an array, fallible conversion APIs can be used:

use endian_num::Le;

fn read_le_u64(input: &mut &[u8]) -> Le<u64> {
    let (int_bytes, rest) = input.split_at(std::mem::size_of::<Le<u64>>());
    *input = rest;
    Le::<u64>::from_le_bytes(int_bytes.try_into().unwrap())
}

Source

pub const fn from_ne_bytes(bytes: [u8; 8]) -> Le<u64>

Create a little endian integer value from its memory representation as a byte array in native endianness.

As the target platform’s native endianness is used, portable code likely wants to use from_be_bytes or from_le_bytes, as appropriate instead.

§Examples

use endian_num::Le;

let value = Le::<u64>::from_ne_bytes(if cfg!(target_endian = "big") {
    [0x12, 0x34, 0x56, 0x78, 0x90, 0x12, 0x34, 0x56]
} else {
    [0x56, 0x34, 0x12, 0x90, 0x78, 0x56, 0x34, 0x12]
});
assert_eq!(value.to_ne(), 0x1234567890123456);

When starting from a slice rather than an array, fallible conversion APIs can be used:

use endian_num::Le;

fn read_ne_u64(input: &mut &[u8]) -> Le<u64> {
    let (int_bytes, rest) = input.split_at(std::mem::size_of::<Le<u64>>());
    *input = rest;
    Le::<u64>::from_ne_bytes(int_bytes.try_into().unwrap())
}

Source

pub const fn rotate_left(self, n: u32) -> Le<u64>

Shifts the bits to the left by a specified amount, n, wrapping the truncated bits to the end of the resulting integer.

Please note this isn’t the same operation as the << shifting operator!

§Examples

Basic usage:

use endian_num::Le;

let n = Le::<u64>::from_ne(0xaa00000000006e1);
let m = Le::<u64>::from_ne(0x6e10aa);

assert_eq!(n.rotate_left(12), m);

Source

pub const fn rotate_right(self, n: u32) -> Le<u64>

Shifts the bits to the right by a specified amount, n, wrapping the truncated bits to the beginning of the resulting integer.

Please note this isn’t the same operation as the >> shifting operator!

§Examples

Basic usage:

use endian_num::Le;

let n = Le::<u64>::from_ne(0x6e10aa);
let m = Le::<u64>::from_ne(0xaa00000000006e1);

assert_eq!(n.rotate_right(12), m);

Source

pub const fn swap_bytes(self) -> Le<u64>

Reverses the byte order of the integer.

§Examples

Basic usage:

use endian_num::Le;

let n = Le(0x1234567890123456u64);
let m = n.swap_bytes();

assert_eq!(m, Le(0x5634129078563412));

Source

pub const fn reverse_bits(self) -> Le<u64>

Reverses the order of bits in the integer.

The least significant bit becomes the most significant bit, second least-significant bit becomes second most-significant bit, etc.

§Examples

Basic usage:

use endian_num::Le;

let n = Le(0x1234567890123456u64);
let m = n.reverse_bits();

assert_eq!(m, Le(0x6a2c48091e6a2c48));
assert_eq!(Le(0), Le(0u64).reverse_bits());

Source

pub const fn pow(self, exp: u32) -> Le<u64>

Raises self to the power of exp, using exponentiation by squaring.

§Examples

Basic usage:

use endian_num::Le;

assert_eq!(Le::<u64>::from_ne(2).pow(5).to_ne(), 32);

Basic usage:

use endian_num::Le;

assert_eq!(Le::<u128>::BITS, u128::BITS);

Source

pub const fn from_ne(n: u128) -> Le<u128>

Creates a new little-endian integer from a native-endian integer.

On little endian, this is a no-op. On big endian, the bytes are swapped.

§Examples

Basic usage:

use endian_num::Le;

let n = 0x1Au128;

if cfg!(target_endian = "little") {
    assert_eq!(Le::<u128>::from_ne(n).0, n);
} else {
    assert_eq!(Le::<u128>::from_ne(n).0, n.swap_bytes());
}

Source

pub const fn from_be(n: Be<u128>) -> Le<u128>

Creates a new little-endian integer from a big-endian integer.

This always swaps the bytes.

§Examples

use endian_num::{Be, Le};

let n = 0x1Au128;

assert_eq!(Le::<u128>::from_be(Be(n)).0, n.swap_bytes());

Source

pub const fn to_ne(self) -> u128

Returns the integer in native-endian byte order.

On little endian, this is a no-op. On big endian, the bytes are swapped.

§Examples

Basic usage:

use endian_num::Le;

let n = 0x1Au128;

if cfg!(target_endian = "little") {
    assert_eq!(Le(n).to_ne(), n);
} else {
    assert_eq!(Le(n).to_ne(), n.swap_bytes());
}

Source

pub const fn to_be(self) -> Be<u128>

Returns the integer in big-endian byte order.

This always swaps the bytes.

§Examples

Basic usage:

use endian_num::Le;

let n = 0x1Au128;

assert_eq!(Le(n).to_be().0, n.swap_bytes());

Source

pub const fn to_be_bytes(self) -> [u8; 16]

Return the memory representation of this integer as a byte array in big-endian (network) byte order.

§Examples

use endian_num::Le;

let bytes = Le::<u128>::from_ne(0x12345678901234567890123456789012).to_be_bytes();
assert_eq!(bytes, [0x12, 0x34, 0x56, 0x78, 0x90, 0x12, 0x34, 0x56, 0x78, 0x90, 0x12, 0x34, 0x56, 0x78, 0x90, 0x12]);

Source

pub const fn to_le_bytes(self) -> [u8; 16]

Return the memory representation of this integer as a byte array in little-endian byte order.

§Examples

use endian_num::Le;

let bytes = Le::<u128>::from_ne(0x12345678901234567890123456789012).to_le_bytes();
assert_eq!(bytes, [0x12, 0x90, 0x78, 0x56, 0x34, 0x12, 0x90, 0x78, 0x56, 0x34, 0x12, 0x90, 0x78, 0x56, 0x34, 0x12]);

Source

pub const fn to_ne_bytes(self) -> [u8; 16]

Return the memory representation of this integer as a byte array in native byte order.

As the target platform’s native endianness is used, portable code should use to_be_bytes or to_le_bytes, as appropriate, instead.

§Examples

use endian_num::Le;

let bytes = Le::<u128>::from_ne(0x12345678901234567890123456789012).to_ne_bytes();
assert_eq!(
    bytes,
    if cfg!(target_endian = "big") {
        [0x12, 0x34, 0x56, 0x78, 0x90, 0x12, 0x34, 0x56, 0x78, 0x90, 0x12, 0x34, 0x56, 0x78, 0x90, 0x12]
    } else {
        [0x12, 0x90, 0x78, 0x56, 0x34, 0x12, 0x90, 0x78, 0x56, 0x34, 0x12, 0x90, 0x78, 0x56, 0x34, 0x12]
    }
);

Source

pub const fn from_be_bytes(bytes: [u8; 16]) -> Le<u128>

Create a little endian integer value from its representation as a byte array in little endian.

§Examples

use endian_num::Le;

let value = Le::<u128>::from_be_bytes([0x12, 0x34, 0x56, 0x78, 0x90, 0x12, 0x34, 0x56, 0x78, 0x90, 0x12, 0x34, 0x56, 0x78, 0x90, 0x12]);
assert_eq!(value.to_ne(), 0x12345678901234567890123456789012);

When starting from a slice rather than an array, fallible conversion APIs can be used:

use endian_num::Le;

fn read_be_u128(input: &mut &[u8]) -> Le<u128> {
    let (int_bytes, rest) = input.split_at(std::mem::size_of::<Le<u128>>());
    *input = rest;
    Le::<u128>::from_be_bytes(int_bytes.try_into().unwrap())
}

Source

pub const fn from_le_bytes(bytes: [u8; 16]) -> Le<u128>

Create a little endian integer value from its representation as a byte array in big endian.

§Examples

use endian_num::Le;

let value = Le::<u128>::from_le_bytes([0x12, 0x90, 0x78, 0x56, 0x34, 0x12, 0x90, 0x78, 0x56, 0x34, 0x12, 0x90, 0x78, 0x56, 0x34, 0x12]);
assert_eq!(value.to_ne(), 0x12345678901234567890123456789012);

When starting from a slice rather than an array, fallible conversion APIs can be used:

use endian_num::Le;

fn read_le_u128(input: &mut &[u8]) -> Le<u128> {
    let (int_bytes, rest) = input.split_at(std::mem::size_of::<Le<u128>>());
    *input = rest;
    Le::<u128>::from_le_bytes(int_bytes.try_into().unwrap())
}

Source

pub const fn from_ne_bytes(bytes: [u8; 16]) -> Le<u128>

Create a little endian integer value from its memory representation as a byte array in native endianness.

As the target platform’s native endianness is used, portable code likely wants to use from_be_bytes or from_le_bytes, as appropriate instead.

§Examples

use endian_num::Le;

let value = Le::<u128>::from_ne_bytes(if cfg!(target_endian = "big") {
    [0x12, 0x34, 0x56, 0x78, 0x90, 0x12, 0x34, 0x56, 0x78, 0x90, 0x12, 0x34, 0x56, 0x78, 0x90, 0x12]
} else {
    [0x12, 0x90, 0x78, 0x56, 0x34, 0x12, 0x90, 0x78, 0x56, 0x34, 0x12, 0x90, 0x78, 0x56, 0x34, 0x12]
});
assert_eq!(value.to_ne(), 0x12345678901234567890123456789012);

When starting from a slice rather than an array, fallible conversion APIs can be used:

use endian_num::Le;

fn read_ne_u128(input: &mut &[u8]) -> Le<u128> {
    let (int_bytes, rest) = input.split_at(std::mem::size_of::<Le<u128>>());
    *input = rest;
    Le::<u128>::from_ne_bytes(int_bytes.try_into().unwrap())
}

Source

pub const fn rotate_left(self, n: u32) -> Le<u128>

Shifts the bits to the left by a specified amount, n, wrapping the truncated bits to the end of the resulting integer.

Please note this isn’t the same operation as the << shifting operator!

§Examples

Basic usage:

use endian_num::Le;

let n = Le::<u128>::from_ne(0x13f40000000000000000000000004f76);
let m = Le::<u128>::from_ne(0x4f7613f4);

assert_eq!(n.rotate_left(16), m);

Source

pub const fn rotate_right(self, n: u32) -> Le<u128>

Shifts the bits to the right by a specified amount, n, wrapping the truncated bits to the beginning of the resulting integer.

Please note this isn’t the same operation as the >> shifting operator!

§Examples

Basic usage:

use endian_num::Le;

let n = Le::<u128>::from_ne(0x4f7613f4);
let m = Le::<u128>::from_ne(0x13f40000000000000000000000004f76);

assert_eq!(n.rotate_right(16), m);

Source

pub const fn swap_bytes(self) -> Le<u128>

Reverses the byte order of the integer.

§Examples

Basic usage:

use endian_num::Le;

let n = Le(0x12345678901234567890123456789012u128);
let m = n.swap_bytes();

assert_eq!(m, Le(0x12907856341290785634129078563412));

Source

pub const fn reverse_bits(self) -> Le<u128>

Reverses the order of bits in the integer.

The least significant bit becomes the most significant bit, second least-significant bit becomes second most-significant bit, etc.

§Examples

Basic usage:

use endian_num::Le;

let n = Le(0x12345678901234567890123456789012u128);
let m = n.reverse_bits();

assert_eq!(m, Le(0x48091e6a2c48091e6a2c48091e6a2c48));
assert_eq!(Le(0), Le(0u128).reverse_bits());

Source

pub const fn pow(self, exp: u32) -> Le<u128>

Raises self to the power of exp, using exponentiation by squaring.

§Examples

Basic usage:

use endian_num::Le;

assert_eq!(Le::<u128>::from_ne(2).pow(5).to_ne(), 32);

Basic usage:

use endian_num::Le;

assert_eq!(Le::<usize>::BITS, usize::BITS);

Source

pub const fn from_ne(n: usize) -> Le<usize>

Creates a new little-endian integer from a native-endian integer.

On little endian, this is a no-op. On big endian, the bytes are swapped.

§Examples

Basic usage:

use endian_num::Le;

let n = 0x1Ausize;

if cfg!(target_endian = "little") {
    assert_eq!(Le::<usize>::from_ne(n).0, n);
} else {
    assert_eq!(Le::<usize>::from_ne(n).0, n.swap_bytes());
}

Source

pub const fn from_be(n: Be<usize>) -> Le<usize>

Creates a new little-endian integer from a big-endian integer.

This always swaps the bytes.

§Examples

use endian_num::{Be, Le};

let n = 0x1Ausize;

assert_eq!(Le::<usize>::from_be(Be(n)).0, n.swap_bytes());

Source

pub const fn to_ne(self) -> usize

Returns the integer in native-endian byte order.

On little endian, this is a no-op. On big endian, the bytes are swapped.

§Examples

Basic usage:

use endian_num::Le;

let n = 0x1Ausize;

if cfg!(target_endian = "little") {
    assert_eq!(Le(n).to_ne(), n);
} else {
    assert_eq!(Le(n).to_ne(), n.swap_bytes());
}

Source

pub const fn to_be(self) -> Be<usize>

Returns the integer in big-endian byte order.

This always swaps the bytes.

§Examples

Basic usage:

use endian_num::Le;

let n = 0x1Ausize;

assert_eq!(Le(n).to_be().0, n.swap_bytes());

Source

pub const fn to_be_bytes(self) -> [u8; 8]

Return the memory representation of this integer as a byte array in big-endian (network) byte order.

§Examples

use endian_num::Le;

let bytes = Le::<usize>::from_ne(0x1234567890123456).to_be_bytes();
assert_eq!(bytes, [0x12, 0x34, 0x56, 0x78, 0x90, 0x12, 0x34, 0x56]);

Source

pub const fn to_le_bytes(self) -> [u8; 8]

Return the memory representation of this integer as a byte array in little-endian byte order.

§Examples

use endian_num::Le;

let bytes = Le::<usize>::from_ne(0x1234567890123456).to_le_bytes();
assert_eq!(bytes, [0x56, 0x34, 0x12, 0x90, 0x78, 0x56, 0x34, 0x12]);

Source

pub const fn to_ne_bytes(self) -> [u8; 8]

Return the memory representation of this integer as a byte array in native byte order.

As the target platform’s native endianness is used, portable code should use to_be_bytes or to_le_bytes, as appropriate, instead.

§Examples

use endian_num::Le;

let bytes = Le::<usize>::from_ne(0x1234567890123456).to_ne_bytes();
assert_eq!(
    bytes,
    if cfg!(target_endian = "big") {
        [0x12, 0x34, 0x56, 0x78, 0x90, 0x12, 0x34, 0x56]
    } else {
        [0x56, 0x34, 0x12, 0x90, 0x78, 0x56, 0x34, 0x12]
    }
);

Source

pub const fn from_be_bytes(bytes: [u8; 8]) -> Le<usize>

Create a little endian integer value from its representation as a byte array in little endian.

§Examples

use endian_num::Le;

let value = Le::<usize>::from_be_bytes([0x12, 0x34, 0x56, 0x78, 0x90, 0x12, 0x34, 0x56]);
assert_eq!(value.to_ne(), 0x1234567890123456);

When starting from a slice rather than an array, fallible conversion APIs can be used:

use endian_num::Le;

fn read_be_usize(input: &mut &[u8]) -> Le<usize> {
    let (int_bytes, rest) = input.split_at(std::mem::size_of::<Le<usize>>());
    *input = rest;
    Le::<usize>::from_be_bytes(int_bytes.try_into().unwrap())
}

Source

pub const fn from_le_bytes(bytes: [u8; 8]) -> Le<usize>

Create a little endian integer value from its representation as a byte array in big endian.

§Examples

use endian_num::Le;

let value = Le::<usize>::from_le_bytes([0x56, 0x34, 0x12, 0x90, 0x78, 0x56, 0x34, 0x12]);
assert_eq!(value.to_ne(), 0x1234567890123456);

When starting from a slice rather than an array, fallible conversion APIs can be used:

use endian_num::Le;

fn read_le_usize(input: &mut &[u8]) -> Le<usize> {
    let (int_bytes, rest) = input.split_at(std::mem::size_of::<Le<usize>>());
    *input = rest;
    Le::<usize>::from_le_bytes(int_bytes.try_into().unwrap())
}

Source

pub const fn from_ne_bytes(bytes: [u8; 8]) -> Le<usize>

Create a little endian integer value from its memory representation as a byte array in native endianness.

As the target platform’s native endianness is used, portable code likely wants to use from_be_bytes or from_le_bytes, as appropriate instead.

§Examples

use endian_num::Le;

let value = Le::<usize>::from_ne_bytes(if cfg!(target_endian = "big") {
    [0x12, 0x34, 0x56, 0x78, 0x90, 0x12, 0x34, 0x56]
} else {
    [0x56, 0x34, 0x12, 0x90, 0x78, 0x56, 0x34, 0x12]
});
assert_eq!(value.to_ne(), 0x1234567890123456);

When starting from a slice rather than an array, fallible conversion APIs can be used:

use endian_num::Le;

fn read_ne_usize(input: &mut &[u8]) -> Le<usize> {
    let (int_bytes, rest) = input.split_at(std::mem::size_of::<Le<usize>>());
    *input = rest;
    Le::<usize>::from_ne_bytes(int_bytes.try_into().unwrap())
}

Source

pub const fn rotate_left(self, n: u32) -> Le<usize>

Shifts the bits to the left by a specified amount, n, wrapping the truncated bits to the end of the resulting integer.

Please note this isn’t the same operation as the << shifting operator!

§Examples

Basic usage:

use endian_num::Le;

let n = Le::<usize>::from_ne(0xaa00000000006e1);
let m = Le::<usize>::from_ne(0x6e10aa);

assert_eq!(n.rotate_left(12), m);

Source

pub const fn rotate_right(self, n: u32) -> Le<usize>

Shifts the bits to the right by a specified amount, n, wrapping the truncated bits to the beginning of the resulting integer.

Please note this isn’t the same operation as the >> shifting operator!

§Examples

Basic usage:

use endian_num::Le;

let n = Le::<usize>::from_ne(0x6e10aa);
let m = Le::<usize>::from_ne(0xaa00000000006e1);

assert_eq!(n.rotate_right(12), m);

Source

pub const fn swap_bytes(self) -> Le<usize>

Reverses the byte order of the integer.

§Examples

Basic usage:

use endian_num::Le;

let n = Le(0x1234567890123456usize);
let m = n.swap_bytes();

assert_eq!(m, Le(0x5634129078563412));

Source

pub const fn reverse_bits(self) -> Le<usize>

Reverses the order of bits in the integer.

The least significant bit becomes the most significant bit, second least-significant bit becomes second most-significant bit, etc.

§Examples

Basic usage:

use endian_num::Le;

let n = Le(0x1234567890123456usize);
let m = n.reverse_bits();

assert_eq!(m, Le(0x6a2c48091e6a2c48));
assert_eq!(Le(0), Le(0usize).reverse_bits());

Source

pub const fn pow(self, exp: u32) -> Le<usize>

Raises self to the power of exp, using exponentiation by squaring.

§Examples

Basic usage:

use endian_num::Le;

assert_eq!(Le::<usize>::from_ne(2).pow(5).to_ne(), 32);

Basic usage:

use endian_num::Le;

assert_eq!(Le::<i8>::BITS, i8::BITS);

Source

pub const fn from_ne(n: i8) -> Le<i8>

Creates a new little-endian integer from a native-endian integer.

On little endian, this is a no-op. On big endian, the bytes are swapped.

§Examples

Basic usage:

use endian_num::Le;

let n = 0x1Ai8;

if cfg!(target_endian = "little") {
    assert_eq!(Le::<i8>::from_ne(n).0, n);
} else {
    assert_eq!(Le::<i8>::from_ne(n).0, n.swap_bytes());
}

Source

pub const fn from_be(n: Be<i8>) -> Le<i8>

Creates a new little-endian integer from a big-endian integer.

This always swaps the bytes.

§Examples

use endian_num::{Be, Le};

let n = 0x1Ai8;

assert_eq!(Le::<i8>::from_be(Be(n)).0, n.swap_bytes());

Source

pub const fn to_ne(self) -> i8

Returns the integer in native-endian byte order.

On little endian, this is a no-op. On big endian, the bytes are swapped.

§Examples

Basic usage:

use endian_num::Le;

let n = 0x1Ai8;

if cfg!(target_endian = "little") {
    assert_eq!(Le(n).to_ne(), n);
} else {
    assert_eq!(Le(n).to_ne(), n.swap_bytes());
}

Source

pub const fn to_be(self) -> Be<i8>

Returns the integer in big-endian byte order.

This always swaps the bytes.

§Examples

Basic usage:

use endian_num::Le;

let n = 0x1Ai8;

assert_eq!(Le(n).to_be().0, n.swap_bytes());

Source

pub const fn to_be_bytes(self) -> [u8; 1]

Return the memory representation of this integer as a byte array in big-endian (network) byte order.

§Examples

use endian_num::Le;

let bytes = Le::<i8>::from_ne(0x12).to_be_bytes();
assert_eq!(bytes, [0x12]);

Source

pub const fn to_le_bytes(self) -> [u8; 1]

Return the memory representation of this integer as a byte array in little-endian byte order.

§Examples

use endian_num::Le;

let bytes = Le::<i8>::from_ne(0x12).to_le_bytes();
assert_eq!(bytes, [0x12]);

Source

pub const fn to_ne_bytes(self) -> [u8; 1]

Return the memory representation of this integer as a byte array in native byte order.

As the target platform’s native endianness is used, portable code should use to_be_bytes or to_le_bytes, as appropriate, instead.

§Examples

use endian_num::Le;

let bytes = Le::<i8>::from_ne(0x12).to_ne_bytes();
assert_eq!(
    bytes,
    if cfg!(target_endian = "big") {
        [0x12]
    } else {
        [0x12]
    }
);

Source

pub const fn from_be_bytes(bytes: [u8; 1]) -> Le<i8>

Create a little endian integer value from its representation as a byte array in little endian.

§Examples

use endian_num::Le;

let value = Le::<i8>::from_be_bytes([0x12]);
assert_eq!(value.to_ne(), 0x12);

When starting from a slice rather than an array, fallible conversion APIs can be used:

use endian_num::Le;

fn read_be_i8(input: &mut &[u8]) -> Le<i8> {
    let (int_bytes, rest) = input.split_at(std::mem::size_of::<Le<i8>>());
    *input = rest;
    Le::<i8>::from_be_bytes(int_bytes.try_into().unwrap())
}

Source

pub const fn from_le_bytes(bytes: [u8; 1]) -> Le<i8>

Create a little endian integer value from its representation as a byte array in big endian.

§Examples

use endian_num::Le;

let value = Le::<i8>::from_le_bytes([0x12]);
assert_eq!(value.to_ne(), 0x12);

When starting from a slice rather than an array, fallible conversion APIs can be used:

use endian_num::Le;

fn read_le_i8(input: &mut &[u8]) -> Le<i8> {
    let (int_bytes, rest) = input.split_at(std::mem::size_of::<Le<i8>>());
    *input = rest;
    Le::<i8>::from_le_bytes(int_bytes.try_into().unwrap())
}

Source

pub const fn from_ne_bytes(bytes: [u8; 1]) -> Le<i8>

Create a little endian integer value from its memory representation as a byte array in native endianness.

As the target platform’s native endianness is used, portable code likely wants to use from_be_bytes or from_le_bytes, as appropriate instead.

§Examples

use endian_num::Le;

let value = Le::<i8>::from_ne_bytes(if cfg!(target_endian = "big") {
    [0x12]
} else {
    [0x12]
});
assert_eq!(value.to_ne(), 0x12);

When starting from a slice rather than an array, fallible conversion APIs can be used:

use endian_num::Le;

fn read_ne_i8(input: &mut &[u8]) -> Le<i8> {
    let (int_bytes, rest) = input.split_at(std::mem::size_of::<Le<i8>>());
    *input = rest;
    Le::<i8>::from_ne_bytes(int_bytes.try_into().unwrap())
}

Source

pub const fn rotate_left(self, n: u32) -> Le<i8>

Shifts the bits to the left by a specified amount, n, wrapping the truncated bits to the end of the resulting integer.

Please note this isn’t the same operation as the << shifting operator!

§Examples

Basic usage:

use endian_num::Le;

let n = Le::<i8>::from_ne(-0x7e);
let m = Le::<i8>::from_ne(0xa);

assert_eq!(n.rotate_left(2), m);

Source

pub const fn rotate_right(self, n: u32) -> Le<i8>

Shifts the bits to the right by a specified amount, n, wrapping the truncated bits to the beginning of the resulting integer.

Please note this isn’t the same operation as the >> shifting operator!

§Examples

Basic usage:

use endian_num::Le;

let n = Le::<i8>::from_ne(0xa);
let m = Le::<i8>::from_ne(-0x7e);

assert_eq!(n.rotate_right(2), m);

Source

pub const fn swap_bytes(self) -> Le<i8>

Reverses the byte order of the integer.

§Examples

Basic usage:

use endian_num::Le;

let n = Le(0x12i8);
let m = n.swap_bytes();

assert_eq!(m, Le(0x12));

Source

pub const fn reverse_bits(self) -> Le<i8>

Reverses the order of bits in the integer.

The least significant bit becomes the most significant bit, second least-significant bit becomes second most-significant bit, etc.

§Examples

Basic usage:

use endian_num::Le;

let n = Le(0x12i8);
let m = n.reverse_bits();

assert_eq!(m, Le(0x48));
assert_eq!(Le(0), Le(0i8).reverse_bits());

Source

pub const fn pow(self, exp: u32) -> Le<i8>

Raises self to the power of exp, using exponentiation by squaring.

§Examples

Basic usage:

use endian_num::Le;

assert_eq!(Le::<i8>::from_ne(2).pow(5).to_ne(), 32);

Basic usage:

use endian_num::Le;

assert_eq!(Le::<i16>::BITS, i16::BITS);

Source

pub const fn from_ne(n: i16) -> Le<i16>

Creates a new little-endian integer from a native-endian integer.

On little endian, this is a no-op. On big endian, the bytes are swapped.

§Examples

Basic usage:

use endian_num::Le;

let n = 0x1Ai16;

if cfg!(target_endian = "little") {
    assert_eq!(Le::<i16>::from_ne(n).0, n);
} else {
    assert_eq!(Le::<i16>::from_ne(n).0, n.swap_bytes());
}

Source

pub const fn from_be(n: Be<i16>) -> Le<i16>

Creates a new little-endian integer from a big-endian integer.

This always swaps the bytes.

§Examples

use endian_num::{Be, Le};

let n = 0x1Ai16;

assert_eq!(Le::<i16>::from_be(Be(n)).0, n.swap_bytes());

Source

pub const fn to_ne(self) -> i16

Returns the integer in native-endian byte order.

On little endian, this is a no-op. On big endian, the bytes are swapped.

§Examples

Basic usage:

use endian_num::Le;

let n = 0x1Ai16;

if cfg!(target_endian = "little") {
    assert_eq!(Le(n).to_ne(), n);
} else {
    assert_eq!(Le(n).to_ne(), n.swap_bytes());
}

Source

pub const fn to_be(self) -> Be<i16>

Returns the integer in big-endian byte order.

This always swaps the bytes.

§Examples

Basic usage:

use endian_num::Le;

let n = 0x1Ai16;

assert_eq!(Le(n).to_be().0, n.swap_bytes());

Source

pub const fn to_be_bytes(self) -> [u8; 2]

Return the memory representation of this integer as a byte array in big-endian (network) byte order.

§Examples

use endian_num::Le;

let bytes = Le::<i16>::from_ne(0x1234).to_be_bytes();
assert_eq!(bytes, [0x12, 0x34]);

Source

pub const fn to_le_bytes(self) -> [u8; 2]

Return the memory representation of this integer as a byte array in little-endian byte order.

§Examples

use endian_num::Le;

let bytes = Le::<i16>::from_ne(0x1234).to_le_bytes();
assert_eq!(bytes, [0x34, 0x12]);

Source

pub const fn to_ne_bytes(self) -> [u8; 2]

Return the memory representation of this integer as a byte array in native byte order.

As the target platform’s native endianness is used, portable code should use to_be_bytes or to_le_bytes, as appropriate, instead.

§Examples

use endian_num::Le;

let bytes = Le::<i16>::from_ne(0x1234).to_ne_bytes();
assert_eq!(
    bytes,
    if cfg!(target_endian = "big") {
        [0x12, 0x34]
    } else {
        [0x34, 0x12]
    }
);

Source

pub const fn from_be_bytes(bytes: [u8; 2]) -> Le<i16>

Create a little endian integer value from its representation as a byte array in little endian.

§Examples

use endian_num::Le;

let value = Le::<i16>::from_be_bytes([0x12, 0x34]);
assert_eq!(value.to_ne(), 0x1234);

When starting from a slice rather than an array, fallible conversion APIs can be used:

use endian_num::Le;

fn read_be_i16(input: &mut &[u8]) -> Le<i16> {
    let (int_bytes, rest) = input.split_at(std::mem::size_of::<Le<i16>>());
    *input = rest;
    Le::<i16>::from_be_bytes(int_bytes.try_into().unwrap())
}

Source

pub const fn from_le_bytes(bytes: [u8; 2]) -> Le<i16>

Create a little endian integer value from its representation as a byte array in big endian.

§Examples

use endian_num::Le;

let value = Le::<i16>::from_le_bytes([0x34, 0x12]);
assert_eq!(value.to_ne(), 0x1234);

When starting from a slice rather than an array, fallible conversion APIs can be used:

use endian_num::Le;

fn read_le_i16(input: &mut &[u8]) -> Le<i16> {
    let (int_bytes, rest) = input.split_at(std::mem::size_of::<Le<i16>>());
    *input = rest;
    Le::<i16>::from_le_bytes(int_bytes.try_into().unwrap())
}

Source

pub const fn from_ne_bytes(bytes: [u8; 2]) -> Le<i16>

Create a little endian integer value from its memory representation as a byte array in native endianness.

As the target platform’s native endianness is used, portable code likely wants to use from_be_bytes or from_le_bytes, as appropriate instead.

§Examples

use endian_num::Le;

let value = Le::<i16>::from_ne_bytes(if cfg!(target_endian = "big") {
    [0x12, 0x34]
} else {
    [0x34, 0x12]
});
assert_eq!(value.to_ne(), 0x1234);

When starting from a slice rather than an array, fallible conversion APIs can be used:

use endian_num::Le;

fn read_ne_i16(input: &mut &[u8]) -> Le<i16> {
    let (int_bytes, rest) = input.split_at(std::mem::size_of::<Le<i16>>());
    *input = rest;
    Le::<i16>::from_ne_bytes(int_bytes.try_into().unwrap())
}

Source

pub const fn rotate_left(self, n: u32) -> Le<i16>

Shifts the bits to the left by a specified amount, n, wrapping the truncated bits to the end of the resulting integer.

Please note this isn’t the same operation as the << shifting operator!

§Examples

Basic usage:

use endian_num::Le;

let n = Le::<i16>::from_ne(-0x5ffd);
let m = Le::<i16>::from_ne(0x3a);

assert_eq!(n.rotate_left(4), m);

Source

pub const fn rotate_right(self, n: u32) -> Le<i16>

Shifts the bits to the right by a specified amount, n, wrapping the truncated bits to the beginning of the resulting integer.

Please note this isn’t the same operation as the >> shifting operator!

§Examples

Basic usage:

use endian_num::Le;

let n = Le::<i16>::from_ne(0x3a);
let m = Le::<i16>::from_ne(-0x5ffd);

assert_eq!(n.rotate_right(4), m);

Source

pub const fn swap_bytes(self) -> Le<i16>

Reverses the byte order of the integer.

§Examples

Basic usage:

use endian_num::Le;

let n = Le(0x1234i16);
let m = n.swap_bytes();

assert_eq!(m, Le(0x3412));

Source

pub const fn reverse_bits(self) -> Le<i16>

Reverses the order of bits in the integer.

The least significant bit becomes the most significant bit, second least-significant bit becomes second most-significant bit, etc.

§Examples

Basic usage:

use endian_num::Le;

let n = Le(0x1234i16);
let m = n.reverse_bits();

assert_eq!(m, Le(0x2c48));
assert_eq!(Le(0), Le(0i16).reverse_bits());

Source

pub const fn pow(self, exp: u32) -> Le<i16>

Raises self to the power of exp, using exponentiation by squaring.

§Examples

Basic usage:

use endian_num::Le;

assert_eq!(Le::<i16>::from_ne(2).pow(5).to_ne(), 32);

Basic usage:

use endian_num::Le;

assert_eq!(Le::<i32>::BITS, i32::BITS);

Source

pub const fn from_ne(n: i32) -> Le<i32>

Creates a new little-endian integer from a native-endian integer.

On little endian, this is a no-op. On big endian, the bytes are swapped.

§Examples

Basic usage:

use endian_num::Le;

let n = 0x1Ai32;

if cfg!(target_endian = "little") {
    assert_eq!(Le::<i32>::from_ne(n).0, n);
} else {
    assert_eq!(Le::<i32>::from_ne(n).0, n.swap_bytes());
}

Source

pub const fn from_be(n: Be<i32>) -> Le<i32>

Creates a new little-endian integer from a big-endian integer.

This always swaps the bytes.

§Examples

use endian_num::{Be, Le};

let n = 0x1Ai32;

assert_eq!(Le::<i32>::from_be(Be(n)).0, n.swap_bytes());

Source

pub const fn to_ne(self) -> i32

Returns the integer in native-endian byte order.

On little endian, this is a no-op. On big endian, the bytes are swapped.

§Examples

Basic usage:

use endian_num::Le;

let n = 0x1Ai32;

if cfg!(target_endian = "little") {
    assert_eq!(Le(n).to_ne(), n);
} else {
    assert_eq!(Le(n).to_ne(), n.swap_bytes());
}

Source

pub const fn to_be(self) -> Be<i32>

Returns the integer in big-endian byte order.

This always swaps the bytes.

§Examples

Basic usage:

use endian_num::Le;

let n = 0x1Ai32;

assert_eq!(Le(n).to_be().0, n.swap_bytes());

Source

pub const fn to_be_bytes(self) -> [u8; 4]

Return the memory representation of this integer as a byte array in big-endian (network) byte order.

§Examples

use endian_num::Le;

let bytes = Le::<i32>::from_ne(0x12345678).to_be_bytes();
assert_eq!(bytes, [0x12, 0x34, 0x56, 0x78]);

Source

pub const fn to_le_bytes(self) -> [u8; 4]

Return the memory representation of this integer as a byte array in little-endian byte order.

§Examples

use endian_num::Le;

let bytes = Le::<i32>::from_ne(0x12345678).to_le_bytes();
assert_eq!(bytes, [0x78, 0x56, 0x34, 0x12]);

Source

pub const fn to_ne_bytes(self) -> [u8; 4]

Return the memory representation of this integer as a byte array in native byte order.

As the target platform’s native endianness is used, portable code should use to_be_bytes or to_le_bytes, as appropriate, instead.

§Examples

use endian_num::Le;

let bytes = Le::<i32>::from_ne(0x12345678).to_ne_bytes();
assert_eq!(
    bytes,
    if cfg!(target_endian = "big") {
        [0x12, 0x34, 0x56, 0x78]
    } else {
        [0x78, 0x56, 0x34, 0x12]
    }
);

Source

pub const fn from_be_bytes(bytes: [u8; 4]) -> Le<i32>

Create a little endian integer value from its representation as a byte array in little endian.

§Examples

use endian_num::Le;

let value = Le::<i32>::from_be_bytes([0x12, 0x34, 0x56, 0x78]);
assert_eq!(value.to_ne(), 0x12345678);

When starting from a slice rather than an array, fallible conversion APIs can be used:

use endian_num::Le;

fn read_be_i32(input: &mut &[u8]) -> Le<i32> {
    let (int_bytes, rest) = input.split_at(std::mem::size_of::<Le<i32>>());
    *input = rest;
    Le::<i32>::from_be_bytes(int_bytes.try_into().unwrap())
}

Source

pub const fn from_le_bytes(bytes: [u8; 4]) -> Le<i32>

Create a little endian integer value from its representation as a byte array in big endian.

§Examples

use endian_num::Le;

let value = Le::<i32>::from_le_bytes([0x78, 0x56, 0x34, 0x12]);
assert_eq!(value.to_ne(), 0x12345678);

When starting from a slice rather than an array, fallible conversion APIs can be used:

use endian_num::Le;

fn read_le_i32(input: &mut &[u8]) -> Le<i32> {
    let (int_bytes, rest) = input.split_at(std::mem::size_of::<Le<i32>>());
    *input = rest;
    Le::<i32>::from_le_bytes(int_bytes.try_into().unwrap())
}

Source

pub const fn from_ne_bytes(bytes: [u8; 4]) -> Le<i32>

Create a little endian integer value from its memory representation as a byte array in native endianness.

As the target platform’s native endianness is used, portable code likely wants to use from_be_bytes or from_le_bytes, as appropriate instead.

§Examples

use endian_num::Le;

let value = Le::<i32>::from_ne_bytes(if cfg!(target_endian = "big") {
    [0x12, 0x34, 0x56, 0x78]
} else {
    [0x78, 0x56, 0x34, 0x12]
});
assert_eq!(value.to_ne(), 0x12345678);

When starting from a slice rather than an array, fallible conversion APIs can be used:

use endian_num::Le;

fn read_ne_i32(input: &mut &[u8]) -> Le<i32> {
    let (int_bytes, rest) = input.split_at(std::mem::size_of::<Le<i32>>());
    *input = rest;
    Le::<i32>::from_ne_bytes(int_bytes.try_into().unwrap())
}

Source

pub const fn rotate_left(self, n: u32) -> Le<i32>

Shifts the bits to the left by a specified amount, n, wrapping the truncated bits to the end of the resulting integer.

Please note this isn’t the same operation as the << shifting operator!

§Examples

Basic usage:

use endian_num::Le;

let n = Le::<i32>::from_ne(0x10000b3);
let m = Le::<i32>::from_ne(0xb301);

assert_eq!(n.rotate_left(8), m);

Source

pub const fn rotate_right(self, n: u32) -> Le<i32>

Shifts the bits to the right by a specified amount, n, wrapping the truncated bits to the beginning of the resulting integer.

Please note this isn’t the same operation as the >> shifting operator!

§Examples

Basic usage:

use endian_num::Le;

let n = Le::<i32>::from_ne(0xb301);
let m = Le::<i32>::from_ne(0x10000b3);

assert_eq!(n.rotate_right(8), m);

Source

pub const fn swap_bytes(self) -> Le<i32>

Reverses the byte order of the integer.

§Examples

Basic usage:

use endian_num::Le;

let n = Le(0x12345678i32);
let m = n.swap_bytes();

assert_eq!(m, Le(0x78563412));

Source

pub const fn reverse_bits(self) -> Le<i32>

Reverses the order of bits in the integer.

The least significant bit becomes the most significant bit, second least-significant bit becomes second most-significant bit, etc.

§Examples

Basic usage:

use endian_num::Le;

let n = Le(0x12345678i32);
let m = n.reverse_bits();

assert_eq!(m, Le(0x1e6a2c48));
assert_eq!(Le(0), Le(0i32).reverse_bits());

Source

pub const fn pow(self, exp: u32) -> Le<i32>

Raises self to the power of exp, using exponentiation by squaring.

§Examples

Basic usage:

use endian_num::Le;

assert_eq!(Le::<i32>::from_ne(2).pow(5).to_ne(), 32);

Basic usage:

use endian_num::Le;

assert_eq!(Le::<i64>::BITS, i64::BITS);

Source

pub const fn from_ne(n: i64) -> Le<i64>

Creates a new little-endian integer from a native-endian integer.

On little endian, this is a no-op. On big endian, the bytes are swapped.

§Examples

Basic usage:

use endian_num::Le;

let n = 0x1Ai64;

if cfg!(target_endian = "little") {
    assert_eq!(Le::<i64>::from_ne(n).0, n);
} else {
    assert_eq!(Le::<i64>::from_ne(n).0, n.swap_bytes());
}

Source

pub const fn from_be(n: Be<i64>) -> Le<i64>

Creates a new little-endian integer from a big-endian integer.

This always swaps the bytes.

§Examples

use endian_num::{Be, Le};

let n = 0x1Ai64;

assert_eq!(Le::<i64>::from_be(Be(n)).0, n.swap_bytes());

Source

pub const fn to_ne(self) -> i64

Returns the integer in native-endian byte order.

On little endian, this is a no-op. On big endian, the bytes are swapped.

§Examples

Basic usage:

use endian_num::Le;

let n = 0x1Ai64;

if cfg!(target_endian = "little") {
    assert_eq!(Le(n).to_ne(), n);
} else {
    assert_eq!(Le(n).to_ne(), n.swap_bytes());
}

Source

pub const fn to_be(self) -> Be<i64>

Returns the integer in big-endian byte order.

This always swaps the bytes.

§Examples

Basic usage:

use endian_num::Le;

let n = 0x1Ai64;

assert_eq!(Le(n).to_be().0, n.swap_bytes());

Source

pub const fn to_be_bytes(self) -> [u8; 8]

Return the memory representation of this integer as a byte array in big-endian (network) byte order.

§Examples

use endian_num::Le;

let bytes = Le::<i64>::from_ne(0x1234567890123456).to_be_bytes();
assert_eq!(bytes, [0x12, 0x34, 0x56, 0x78, 0x90, 0x12, 0x34, 0x56]);

Source

pub const fn to_le_bytes(self) -> [u8; 8]

Return the memory representation of this integer as a byte array in little-endian byte order.

§Examples

use endian_num::Le;

let bytes = Le::<i64>::from_ne(0x1234567890123456).to_le_bytes();
assert_eq!(bytes, [0x56, 0x34, 0x12, 0x90, 0x78, 0x56, 0x34, 0x12]);

Source

pub const fn to_ne_bytes(self) -> [u8; 8]

Return the memory representation of this integer as a byte array in native byte order.

As the target platform’s native endianness is used, portable code should use to_be_bytes or to_le_bytes, as appropriate, instead.

§Examples

use endian_num::Le;

let bytes = Le::<i64>::from_ne(0x1234567890123456).to_ne_bytes();
assert_eq!(
    bytes,
    if cfg!(target_endian = "big") {
        [0x12, 0x34, 0x56, 0x78, 0x90, 0x12, 0x34, 0x56]
    } else {
        [0x56, 0x34, 0x12, 0x90, 0x78, 0x56, 0x34, 0x12]
    }
);

Source

pub const fn from_be_bytes(bytes: [u8; 8]) -> Le<i64>

Create a little endian integer value from its representation as a byte array in little endian.

§Examples

use endian_num::Le;

let value = Le::<i64>::from_be_bytes([0x12, 0x34, 0x56, 0x78, 0x90, 0x12, 0x34, 0x56]);
assert_eq!(value.to_ne(), 0x1234567890123456);

When starting from a slice rather than an array, fallible conversion APIs can be used:

use endian_num::Le;

fn read_be_i64(input: &mut &[u8]) -> Le<i64> {
    let (int_bytes, rest) = input.split_at(std::mem::size_of::<Le<i64>>());
    *input = rest;
    Le::<i64>::from_be_bytes(int_bytes.try_into().unwrap())
}

Source

pub const fn from_le_bytes(bytes: [u8; 8]) -> Le<i64>

Create a little endian integer value from its representation as a byte array in big endian.

§Examples

use endian_num::Le;

let value = Le::<i64>::from_le_bytes([0x56, 0x34, 0x12, 0x90, 0x78, 0x56, 0x34, 0x12]);
assert_eq!(value.to_ne(), 0x1234567890123456);

When starting from a slice rather than an array, fallible conversion APIs can be used:

use endian_num::Le;

fn read_le_i64(input: &mut &[u8]) -> Le<i64> {
    let (int_bytes, rest) = input.split_at(std::mem::size_of::<Le<i64>>());
    *input = rest;
    Le::<i64>::from_le_bytes(int_bytes.try_into().unwrap())
}

Source

pub const fn from_ne_bytes(bytes: [u8; 8]) -> Le<i64>

Create a little endian integer value from its memory representation as a byte array in native endianness.

As the target platform’s native endianness is used, portable code likely wants to use from_be_bytes or from_le_bytes, as appropriate instead.

§Examples

use endian_num::Le;

let value = Le::<i64>::from_ne_bytes(if cfg!(target_endian = "big") {
    [0x12, 0x34, 0x56, 0x78, 0x90, 0x12, 0x34, 0x56]
} else {
    [0x56, 0x34, 0x12, 0x90, 0x78, 0x56, 0x34, 0x12]
});
assert_eq!(value.to_ne(), 0x1234567890123456);

When starting from a slice rather than an array, fallible conversion APIs can be used:

use endian_num::Le;

fn read_ne_i64(input: &mut &[u8]) -> Le<i64> {
    let (int_bytes, rest) = input.split_at(std::mem::size_of::<Le<i64>>());
    *input = rest;
    Le::<i64>::from_ne_bytes(int_bytes.try_into().unwrap())
}

Source

pub const fn rotate_left(self, n: u32) -> Le<i64>

Shifts the bits to the left by a specified amount, n, wrapping the truncated bits to the end of the resulting integer.

Please note this isn’t the same operation as the << shifting operator!

§Examples

Basic usage:

use endian_num::Le;

let n = Le::<i64>::from_ne(0xaa00000000006e1);
let m = Le::<i64>::from_ne(0x6e10aa);

assert_eq!(n.rotate_left(12), m);

Source

pub const fn rotate_right(self, n: u32) -> Le<i64>

Shifts the bits to the right by a specified amount, n, wrapping the truncated bits to the beginning of the resulting integer.

Please note this isn’t the same operation as the >> shifting operator!

§Examples

Basic usage:

use endian_num::Le;

let n = Le::<i64>::from_ne(0x6e10aa);
let m = Le::<i64>::from_ne(0xaa00000000006e1);

assert_eq!(n.rotate_right(12), m);

Source

pub const fn swap_bytes(self) -> Le<i64>

Reverses the byte order of the integer.

§Examples

Basic usage:

use endian_num::Le;

let n = Le(0x1234567890123456i64);
let m = n.swap_bytes();

assert_eq!(m, Le(0x5634129078563412));

Source

pub const fn reverse_bits(self) -> Le<i64>

Reverses the order of bits in the integer.

The least significant bit becomes the most significant bit, second least-significant bit becomes second most-significant bit, etc.

§Examples

Basic usage:

use endian_num::Le;

let n = Le(0x1234567890123456i64);
let m = n.reverse_bits();

assert_eq!(m, Le(0x6a2c48091e6a2c48));
assert_eq!(Le(0), Le(0i64).reverse_bits());

Source

pub const fn pow(self, exp: u32) -> Le<i64>

Raises self to the power of exp, using exponentiation by squaring.

§Examples

Basic usage:

use endian_num::Le;

assert_eq!(Le::<i64>::from_ne(2).pow(5).to_ne(), 32);

Basic usage:

use endian_num::Le;

assert_eq!(Le::<i128>::BITS, i128::BITS);

Source

pub const fn from_ne(n: i128) -> Le<i128>

Creates a new little-endian integer from a native-endian integer.

On little endian, this is a no-op. On big endian, the bytes are swapped.

§Examples

Basic usage:

use endian_num::Le;

let n = 0x1Ai128;

if cfg!(target_endian = "little") {
    assert_eq!(Le::<i128>::from_ne(n).0, n);
} else {
    assert_eq!(Le::<i128>::from_ne(n).0, n.swap_bytes());
}

Source

pub const fn from_be(n: Be<i128>) -> Le<i128>

Creates a new little-endian integer from a big-endian integer.

This always swaps the bytes.

§Examples

use endian_num::{Be, Le};

let n = 0x1Ai128;

assert_eq!(Le::<i128>::from_be(Be(n)).0, n.swap_bytes());

Source

pub const fn to_ne(self) -> i128

Returns the integer in native-endian byte order.

On little endian, this is a no-op. On big endian, the bytes are swapped.

§Examples

Basic usage:

use endian_num::Le;

let n = 0x1Ai128;

if cfg!(target_endian = "little") {
    assert_eq!(Le(n).to_ne(), n);
} else {
    assert_eq!(Le(n).to_ne(), n.swap_bytes());
}

Source

pub const fn to_be(self) -> Be<i128>

Returns the integer in big-endian byte order.

This always swaps the bytes.

§Examples

Basic usage:

use endian_num::Le;

let n = 0x1Ai128;

assert_eq!(Le(n).to_be().0, n.swap_bytes());

Source

pub const fn to_be_bytes(self) -> [u8; 16]

Return the memory representation of this integer as a byte array in big-endian (network) byte order.

§Examples

use endian_num::Le;

let bytes = Le::<i128>::from_ne(0x12345678901234567890123456789012).to_be_bytes();
assert_eq!(bytes, [0x12, 0x34, 0x56, 0x78, 0x90, 0x12, 0x34, 0x56, 0x78, 0x90, 0x12, 0x34, 0x56, 0x78, 0x90, 0x12]);

Source

pub const fn to_le_bytes(self) -> [u8; 16]

Return the memory representation of this integer as a byte array in little-endian byte order.

§Examples

use endian_num::Le;

let bytes = Le::<i128>::from_ne(0x12345678901234567890123456789012).to_le_bytes();
assert_eq!(bytes, [0x12, 0x90, 0x78, 0x56, 0x34, 0x12, 0x90, 0x78, 0x56, 0x34, 0x12, 0x90, 0x78, 0x56, 0x34, 0x12]);

Source

pub const fn to_ne_bytes(self) -> [u8; 16]

Return the memory representation of this integer as a byte array in native byte order.

As the target platform’s native endianness is used, portable code should use to_be_bytes or to_le_bytes, as appropriate, instead.

§Examples

use endian_num::Le;

let bytes = Le::<i128>::from_ne(0x12345678901234567890123456789012).to_ne_bytes();
assert_eq!(
    bytes,
    if cfg!(target_endian = "big") {
        [0x12, 0x34, 0x56, 0x78, 0x90, 0x12, 0x34, 0x56, 0x78, 0x90, 0x12, 0x34, 0x56, 0x78, 0x90, 0x12]
    } else {
        [0x12, 0x90, 0x78, 0x56, 0x34, 0x12, 0x90, 0x78, 0x56, 0x34, 0x12, 0x90, 0x78, 0x56, 0x34, 0x12]
    }
);

Source

pub const fn from_be_bytes(bytes: [u8; 16]) -> Le<i128>

Create a little endian integer value from its representation as a byte array in little endian.

§Examples

use endian_num::Le;

let value = Le::<i128>::from_be_bytes([0x12, 0x34, 0x56, 0x78, 0x90, 0x12, 0x34, 0x56, 0x78, 0x90, 0x12, 0x34, 0x56, 0x78, 0x90, 0x12]);
assert_eq!(value.to_ne(), 0x12345678901234567890123456789012);

When starting from a slice rather than an array, fallible conversion APIs can be used:

use endian_num::Le;

fn read_be_i128(input: &mut &[u8]) -> Le<i128> {
    let (int_bytes, rest) = input.split_at(std::mem::size_of::<Le<i128>>());
    *input = rest;
    Le::<i128>::from_be_bytes(int_bytes.try_into().unwrap())
}

Source

pub const fn from_le_bytes(bytes: [u8; 16]) -> Le<i128>

Create a little endian integer value from its representation as a byte array in big endian.

§Examples

use endian_num::Le;

let value = Le::<i128>::from_le_bytes([0x12, 0x90, 0x78, 0x56, 0x34, 0x12, 0x90, 0x78, 0x56, 0x34, 0x12, 0x90, 0x78, 0x56, 0x34, 0x12]);
assert_eq!(value.to_ne(), 0x12345678901234567890123456789012);

When starting from a slice rather than an array, fallible conversion APIs can be used:

use endian_num::Le;

fn read_le_i128(input: &mut &[u8]) -> Le<i128> {
    let (int_bytes, rest) = input.split_at(std::mem::size_of::<Le<i128>>());
    *input = rest;
    Le::<i128>::from_le_bytes(int_bytes.try_into().unwrap())
}

Source

pub const fn from_ne_bytes(bytes: [u8; 16]) -> Le<i128>

Create a little endian integer value from its memory representation as a byte array in native endianness.

As the target platform’s native endianness is used, portable code likely wants to use from_be_bytes or from_le_bytes, as appropriate instead.

§Examples

use endian_num::Le;

let value = Le::<i128>::from_ne_bytes(if cfg!(target_endian = "big") {
    [0x12, 0x34, 0x56, 0x78, 0x90, 0x12, 0x34, 0x56, 0x78, 0x90, 0x12, 0x34, 0x56, 0x78, 0x90, 0x12]
} else {
    [0x12, 0x90, 0x78, 0x56, 0x34, 0x12, 0x90, 0x78, 0x56, 0x34, 0x12, 0x90, 0x78, 0x56, 0x34, 0x12]
});
assert_eq!(value.to_ne(), 0x12345678901234567890123456789012);

When starting from a slice rather than an array, fallible conversion APIs can be used:

use endian_num::Le;

fn read_ne_i128(input: &mut &[u8]) -> Le<i128> {
    let (int_bytes, rest) = input.split_at(std::mem::size_of::<Le<i128>>());
    *input = rest;
    Le::<i128>::from_ne_bytes(int_bytes.try_into().unwrap())
}

Source

pub const fn rotate_left(self, n: u32) -> Le<i128>

Shifts the bits to the left by a specified amount, n, wrapping the truncated bits to the end of the resulting integer.

Please note this isn’t the same operation as the << shifting operator!

§Examples

Basic usage:

use endian_num::Le;

let n = Le::<i128>::from_ne(0x13f40000000000000000000000004f76);
let m = Le::<i128>::from_ne(0x4f7613f4);

assert_eq!(n.rotate_left(16), m);

Source

pub const fn rotate_right(self, n: u32) -> Le<i128>

Shifts the bits to the right by a specified amount, n, wrapping the truncated bits to the beginning of the resulting integer.

Please note this isn’t the same operation as the >> shifting operator!

§Examples

Basic usage:

use endian_num::Le;

let n = Le::<i128>::from_ne(0x4f7613f4);
let m = Le::<i128>::from_ne(0x13f40000000000000000000000004f76);

assert_eq!(n.rotate_right(16), m);

Source

pub const fn swap_bytes(self) -> Le<i128>

Reverses the byte order of the integer.

§Examples

Basic usage:

use endian_num::Le;

let n = Le(0x12345678901234567890123456789012i128);
let m = n.swap_bytes();

assert_eq!(m, Le(0x12907856341290785634129078563412));

Source

pub const fn reverse_bits(self) -> Le<i128>

Reverses the order of bits in the integer.

The least significant bit becomes the most significant bit, second least-significant bit becomes second most-significant bit, etc.

§Examples

Basic usage:

use endian_num::Le;

let n = Le(0x12345678901234567890123456789012i128);
let m = n.reverse_bits();

assert_eq!(m, Le(0x48091e6a2c48091e6a2c48091e6a2c48));
assert_eq!(Le(0), Le(0i128).reverse_bits());

Source

pub const fn pow(self, exp: u32) -> Le<i128>

Raises self to the power of exp, using exponentiation by squaring.

§Examples

Basic usage:

use endian_num::Le;

assert_eq!(Le::<i128>::from_ne(2).pow(5).to_ne(), 32);

Basic usage:

use endian_num::Le;

assert_eq!(Le::<isize>::BITS, isize::BITS);

Source

pub const fn from_ne(n: isize) -> Le<isize>

Creates a new little-endian integer from a native-endian integer.

On little endian, this is a no-op. On big endian, the bytes are swapped.

§Examples

Basic usage:

use endian_num::Le;

let n = 0x1Aisize;

if cfg!(target_endian = "little") {
    assert_eq!(Le::<isize>::from_ne(n).0, n);
} else {
    assert_eq!(Le::<isize>::from_ne(n).0, n.swap_bytes());
}

Source

pub const fn from_be(n: Be<isize>) -> Le<isize>

Creates a new little-endian integer from a big-endian integer.

This always swaps the bytes.

§Examples

use endian_num::{Be, Le};

let n = 0x1Aisize;

assert_eq!(Le::<isize>::from_be(Be(n)).0, n.swap_bytes());

Source

pub const fn to_ne(self) -> isize

Returns the integer in native-endian byte order.

On little endian, this is a no-op. On big endian, the bytes are swapped.

§Examples

Basic usage:

use endian_num::Le;

let n = 0x1Aisize;

if cfg!(target_endian = "little") {
    assert_eq!(Le(n).to_ne(), n);
} else {
    assert_eq!(Le(n).to_ne(), n.swap_bytes());
}

Source

pub const fn to_be(self) -> Be<isize>

Returns the integer in big-endian byte order.

This always swaps the bytes.

§Examples

Basic usage:

use endian_num::Le;

let n = 0x1Aisize;

assert_eq!(Le(n).to_be().0, n.swap_bytes());

Source

pub const fn to_be_bytes(self) -> [u8; 8]

Return the memory representation of this integer as a byte array in big-endian (network) byte order.

§Examples

use endian_num::Le;

let bytes = Le::<isize>::from_ne(0x1234567890123456).to_be_bytes();
assert_eq!(bytes, [0x12, 0x34, 0x56, 0x78, 0x90, 0x12, 0x34, 0x56]);

Source

pub const fn to_le_bytes(self) -> [u8; 8]

Return the memory representation of this integer as a byte array in little-endian byte order.

§Examples

use endian_num::Le;

let bytes = Le::<isize>::from_ne(0x1234567890123456).to_le_bytes();
assert_eq!(bytes, [0x56, 0x34, 0x12, 0x90, 0x78, 0x56, 0x34, 0x12]);

Source

pub const fn to_ne_bytes(self) -> [u8; 8]

Return the memory representation of this integer as a byte array in native byte order.

As the target platform’s native endianness is used, portable code should use to_be_bytes or to_le_bytes, as appropriate, instead.

§Examples

use endian_num::Le;

let bytes = Le::<isize>::from_ne(0x1234567890123456).to_ne_bytes();
assert_eq!(
    bytes,
    if cfg!(target_endian = "big") {
        [0x12, 0x34, 0x56, 0x78, 0x90, 0x12, 0x34, 0x56]
    } else {
        [0x56, 0x34, 0x12, 0x90, 0x78, 0x56, 0x34, 0x12]
    }
);

Source

pub const fn from_be_bytes(bytes: [u8; 8]) -> Le<isize>

Create a little endian integer value from its representation as a byte array in little endian.

§Examples

use endian_num::Le;

let value = Le::<isize>::from_be_bytes([0x12, 0x34, 0x56, 0x78, 0x90, 0x12, 0x34, 0x56]);
assert_eq!(value.to_ne(), 0x1234567890123456);

When starting from a slice rather than an array, fallible conversion APIs can be used:

use endian_num::Le;

fn read_be_isize(input: &mut &[u8]) -> Le<isize> {
    let (int_bytes, rest) = input.split_at(std::mem::size_of::<Le<isize>>());
    *input = rest;
    Le::<isize>::from_be_bytes(int_bytes.try_into().unwrap())
}

Source

pub const fn from_le_bytes(bytes: [u8; 8]) -> Le<isize>

Create a little endian integer value from its representation as a byte array in big endian.

§Examples

use endian_num::Le;

let value = Le::<isize>::from_le_bytes([0x56, 0x34, 0x12, 0x90, 0x78, 0x56, 0x34, 0x12]);
assert_eq!(value.to_ne(), 0x1234567890123456);

When starting from a slice rather than an array, fallible conversion APIs can be used:

use endian_num::Le;

fn read_le_isize(input: &mut &[u8]) -> Le<isize> {
    let (int_bytes, rest) = input.split_at(std::mem::size_of::<Le<isize>>());
    *input = rest;
    Le::<isize>::from_le_bytes(int_bytes.try_into().unwrap())
}

Source

pub const fn from_ne_bytes(bytes: [u8; 8]) -> Le<isize>

Create a little endian integer value from its memory representation as a byte array in native endianness.

As the target platform’s native endianness is used, portable code likely wants to use from_be_bytes or from_le_bytes, as appropriate instead.

§Examples

use endian_num::Le;

let value = Le::<isize>::from_ne_bytes(if cfg!(target_endian = "big") {
    [0x12, 0x34, 0x56, 0x78, 0x90, 0x12, 0x34, 0x56]
} else {
    [0x56, 0x34, 0x12, 0x90, 0x78, 0x56, 0x34, 0x12]
});
assert_eq!(value.to_ne(), 0x1234567890123456);

When starting from a slice rather than an array, fallible conversion APIs can be used:

use endian_num::Le;

fn read_ne_isize(input: &mut &[u8]) -> Le<isize> {
    let (int_bytes, rest) = input.split_at(std::mem::size_of::<Le<isize>>());
    *input = rest;
    Le::<isize>::from_ne_bytes(int_bytes.try_into().unwrap())
}

Source

pub const fn rotate_left(self, n: u32) -> Le<isize>

Shifts the bits to the left by a specified amount, n, wrapping the truncated bits to the end of the resulting integer.

Please note this isn’t the same operation as the << shifting operator!

§Examples

Basic usage:

use endian_num::Le;

let n = Le::<isize>::from_ne(0xaa00000000006e1);
let m = Le::<isize>::from_ne(0x6e10aa);

assert_eq!(n.rotate_left(12), m);

Source

pub const fn rotate_right(self, n: u32) -> Le<isize>

Shifts the bits to the right by a specified amount, n, wrapping the truncated bits to the beginning of the resulting integer.

Please note this isn’t the same operation as the >> shifting operator!

§Examples

Basic usage:

use endian_num::Le;

let n = Le::<isize>::from_ne(0x6e10aa);
let m = Le::<isize>::from_ne(0xaa00000000006e1);

assert_eq!(n.rotate_right(12), m);

Source

pub const fn swap_bytes(self) -> Le<isize>

Reverses the byte order of the integer.

§Examples

Basic usage:

use endian_num::Le;

let n = Le(0x1234567890123456isize);
let m = n.swap_bytes();

assert_eq!(m, Le(0x5634129078563412));

Source

pub const fn reverse_bits(self) -> Le<isize>

Reverses the order of bits in the integer.

The least significant bit becomes the most significant bit, second least-significant bit becomes second most-significant bit, etc.

§Examples

Basic usage:

use endian_num::Le;

let n = Le(0x1234567890123456isize);
let m = n.reverse_bits();

assert_eq!(m, Le(0x6a2c48091e6a2c48));
assert_eq!(Le(0), Le(0isize).reverse_bits());

Source

pub const fn pow(self, exp: u32) -> Le<isize>

Raises self to the power of exp, using exponentiation by squaring.

§Examples

Basic usage:

use endian_num::Le;

assert_eq!(Le::<isize>::from_ne(2).pow(5).to_ne(), 32);

Source §

impl Le<i8>

Source

pub const fn abs(self) -> Le<i8>

Computes the absolute value of self.

See i8::abs for documentation on overflow behavior.

§Examples

Basic usage:

use endian_num::Le;

assert_eq!(Le::<i8>::from_ne(10).abs(), Le::<i8>::from_ne(10));
assert_eq!(Le::<i8>::from_ne(-10).abs(), Le::<i8>::from_ne(10));

Source

pub const fn signum(self) -> Le<i8>

Returns a number representing sign of self.

0 if the number is zero
1 if the number is positive
-1 if the number is negative

§Examples

Basic usage:

use endian_num::Le;

assert_eq!(Le::<i8>::from_ne(10).signum().to_ne(), 1);
assert_eq!(Le::<i8>::from_ne(0).signum().to_ne(), 0);
assert_eq!(Le::<i8>::from_ne(-10).signum().to_ne(), -1);

Source

pub const fn is_positive(self) -> bool

Returns true if self is positive and false if the number is zero or negative.

§Examples

Basic usage:

use endian_num::Le;

assert!(Le::<i8>::from_ne(10).is_positive());
assert!(!Le::<i8>::from_ne(-10).is_positive());

Source

pub const fn is_negative(self) -> bool

Returns true if self is negative and false if the number is zero or positive.

§Examples

Basic usage:

use endian_num::Le;

assert!(Le::<i8>::from_ne(-10).is_negative());
assert!(!Le::<i8>::from_ne(10).is_negative());

Source

pub const fn count_ones(self) -> u32

Returns the number of ones in the binary representation of self.

§Examples

Basic usage:

use endian_num::Le;

let n = Le(0b100_0000i8);

assert_eq!(n.count_ones(), 1);

Source

pub const fn count_zeros(self) -> u32

Returns the number of zeros in the binary representation of self.

§Examples

Basic usage:

use endian_num::Le;

assert_eq!(Le::<i8>::MAX.count_zeros(), 1);

Source

pub const fn leading_zeros(self) -> u32

Returns the number of leading zeros in the binary representation of self.

§Examples

Basic usage:

use endian_num::Le;

let n = Le::<i8>::from_ne(-1);

assert_eq!(n.leading_zeros(), 0);

Source

pub const fn trailing_zeros(self) -> u32

Returns the number of trailing zeros in the binary representation of self.

§Examples

Basic usage:

use endian_num::Le;

let n = Le::<i8>::from_ne(-4);

assert_eq!(n.trailing_zeros(), 2);

Source §

impl Le<i16>

Source

pub const fn abs(self) -> Le<i16>

Computes the absolute value of self.

See i16::abs for documentation on overflow behavior.

§Examples

Basic usage:

use endian_num::Le;

assert_eq!(Le::<i16>::from_ne(10).abs(), Le::<i16>::from_ne(10));
assert_eq!(Le::<i16>::from_ne(-10).abs(), Le::<i16>::from_ne(10));

Source

pub const fn signum(self) -> Le<i16>

Returns a number representing sign of self.

0 if the number is zero
1 if the number is positive
-1 if the number is negative

§Examples

Basic usage:

use endian_num::Le;

assert_eq!(Le::<i16>::from_ne(10).signum().to_ne(), 1);
assert_eq!(Le::<i16>::from_ne(0).signum().to_ne(), 0);
assert_eq!(Le::<i16>::from_ne(-10).signum().to_ne(), -1);

Source

pub const fn is_positive(self) -> bool

Returns true if self is positive and false if the number is zero or negative.

§Examples

Basic usage:

use endian_num::Le;

assert!(Le::<i16>::from_ne(10).is_positive());
assert!(!Le::<i16>::from_ne(-10).is_positive());

Source

pub const fn is_negative(self) -> bool

Returns true if self is negative and false if the number is zero or positive.

§Examples

Basic usage:

use endian_num::Le;

assert!(Le::<i16>::from_ne(-10).is_negative());
assert!(!Le::<i16>::from_ne(10).is_negative());

Source

pub const fn count_ones(self) -> u32

Returns the number of ones in the binary representation of self.

§Examples

Basic usage:

use endian_num::Le;

let n = Le(0b100_0000i16);

assert_eq!(n.count_ones(), 1);

Source

pub const fn count_zeros(self) -> u32

Returns the number of zeros in the binary representation of self.

§Examples

Basic usage:

use endian_num::Le;

assert_eq!(Le::<i16>::MAX.count_zeros(), 1);

Source

pub const fn leading_zeros(self) -> u32

Returns the number of leading zeros in the binary representation of self.

§Examples

Basic usage:

use endian_num::Le;

let n = Le::<i16>::from_ne(-1);

assert_eq!(n.leading_zeros(), 0);

Source

pub const fn trailing_zeros(self) -> u32

Returns the number of trailing zeros in the binary representation of self.

§Examples

Basic usage:

use endian_num::Le;

let n = Le::<i16>::from_ne(-4);

assert_eq!(n.trailing_zeros(), 2);

Source §

impl Le<i32>

Source

pub const fn abs(self) -> Le<i32>

Computes the absolute value of self.

See i32::abs for documentation on overflow behavior.

§Examples

Basic usage:

use endian_num::Le;

assert_eq!(Le::<i32>::from_ne(10).abs(), Le::<i32>::from_ne(10));
assert_eq!(Le::<i32>::from_ne(-10).abs(), Le::<i32>::from_ne(10));

Source

pub const fn signum(self) -> Le<i32>

Returns a number representing sign of self.

0 if the number is zero
1 if the number is positive
-1 if the number is negative

§Examples

Basic usage:

use endian_num::Le;

assert_eq!(Le::<i32>::from_ne(10).signum().to_ne(), 1);
assert_eq!(Le::<i32>::from_ne(0).signum().to_ne(), 0);
assert_eq!(Le::<i32>::from_ne(-10).signum().to_ne(), -1);

Source

pub const fn is_positive(self) -> bool

Returns true if self is positive and false if the number is zero or negative.

§Examples

Basic usage:

use endian_num::Le;

assert!(Le::<i32>::from_ne(10).is_positive());
assert!(!Le::<i32>::from_ne(-10).is_positive());

Source

pub const fn is_negative(self) -> bool

Returns true if self is negative and false if the number is zero or positive.

§Examples

Basic usage:

use endian_num::Le;

assert!(Le::<i32>::from_ne(-10).is_negative());
assert!(!Le::<i32>::from_ne(10).is_negative());

Source

pub const fn count_ones(self) -> u32

Returns the number of ones in the binary representation of self.

§Examples

Basic usage:

use endian_num::Le;

let n = Le(0b100_0000i32);

assert_eq!(n.count_ones(), 1);

Source

pub const fn count_zeros(self) -> u32

Returns the number of zeros in the binary representation of self.

§Examples

Basic usage:

use endian_num::Le;

assert_eq!(Le::<i32>::MAX.count_zeros(), 1);

Source

pub const fn leading_zeros(self) -> u32

Returns the number of leading zeros in the binary representation of self.

§Examples

Basic usage:

use endian_num::Le;

let n = Le::<i32>::from_ne(-1);

assert_eq!(n.leading_zeros(), 0);

Source

pub const fn trailing_zeros(self) -> u32

Returns the number of trailing zeros in the binary representation of self.

§Examples

Basic usage:

use endian_num::Le;

let n = Le::<i32>::from_ne(-4);

assert_eq!(n.trailing_zeros(), 2);

Source §

impl Le<i64>

Source

pub const fn abs(self) -> Le<i64>

Computes the absolute value of self.

See i64::abs for documentation on overflow behavior.

§Examples

Basic usage:

use endian_num::Le;

assert_eq!(Le::<i64>::from_ne(10).abs(), Le::<i64>::from_ne(10));
assert_eq!(Le::<i64>::from_ne(-10).abs(), Le::<i64>::from_ne(10));

Source

pub const fn signum(self) -> Le<i64>

Returns a number representing sign of self.

0 if the number is zero
1 if the number is positive
-1 if the number is negative

§Examples

Basic usage:

use endian_num::Le;

assert_eq!(Le::<i64>::from_ne(10).signum().to_ne(), 1);
assert_eq!(Le::<i64>::from_ne(0).signum().to_ne(), 0);
assert_eq!(Le::<i64>::from_ne(-10).signum().to_ne(), -1);

Source

pub const fn is_positive(self) -> bool

Returns true if self is positive and false if the number is zero or negative.

§Examples

Basic usage:

use endian_num::Le;

assert!(Le::<i64>::from_ne(10).is_positive());
assert!(!Le::<i64>::from_ne(-10).is_positive());

Source

pub const fn is_negative(self) -> bool

Returns true if self is negative and false if the number is zero or positive.

§Examples

Basic usage:

use endian_num::Le;

assert!(Le::<i64>::from_ne(-10).is_negative());
assert!(!Le::<i64>::from_ne(10).is_negative());

Source

pub const fn count_ones(self) -> u32

Returns the number of ones in the binary representation of self.

§Examples

Basic usage:

use endian_num::Le;

let n = Le(0b100_0000i64);

assert_eq!(n.count_ones(), 1);

Source

pub const fn count_zeros(self) -> u32

Returns the number of zeros in the binary representation of self.

§Examples

Basic usage:

use endian_num::Le;

assert_eq!(Le::<i64>::MAX.count_zeros(), 1);

Source

pub const fn leading_zeros(self) -> u32

Returns the number of leading zeros in the binary representation of self.

§Examples

Basic usage:

use endian_num::Le;

let n = Le::<i64>::from_ne(-1);

assert_eq!(n.leading_zeros(), 0);

Source

pub const fn trailing_zeros(self) -> u32

Returns the number of trailing zeros in the binary representation of self.

§Examples

Basic usage:

use endian_num::Le;

let n = Le::<i64>::from_ne(-4);

assert_eq!(n.trailing_zeros(), 2);

Source §

impl Le<i128>

Source

pub const fn abs(self) -> Le<i128>

Computes the absolute value of self.

See i128::abs for documentation on overflow behavior.

§Examples

Basic usage:

use endian_num::Le;

assert_eq!(Le::<i128>::from_ne(10).abs(), Le::<i128>::from_ne(10));
assert_eq!(Le::<i128>::from_ne(-10).abs(), Le::<i128>::from_ne(10));

Source

pub const fn signum(self) -> Le<i128>

Returns a number representing sign of self.

0 if the number is zero
1 if the number is positive
-1 if the number is negative

§Examples

Basic usage:

use endian_num::Le;

assert_eq!(Le::<i128>::from_ne(10).signum().to_ne(), 1);
assert_eq!(Le::<i128>::from_ne(0).signum().to_ne(), 0);
assert_eq!(Le::<i128>::from_ne(-10).signum().to_ne(), -1);

Source

pub const fn is_positive(self) -> bool

Returns true if self is positive and false if the number is zero or negative.

§Examples

Basic usage:

use endian_num::Le;

assert!(Le::<i128>::from_ne(10).is_positive());
assert!(!Le::<i128>::from_ne(-10).is_positive());

Source

pub const fn is_negative(self) -> bool

Returns true if self is negative and false if the number is zero or positive.

§Examples

Basic usage:

use endian_num::Le;

assert!(Le::<i128>::from_ne(-10).is_negative());
assert!(!Le::<i128>::from_ne(10).is_negative());

Source

pub const fn count_ones(self) -> u32

Returns the number of ones in the binary representation of self.

§Examples

Basic usage:

use endian_num::Le;

let n = Le(0b100_0000i128);

assert_eq!(n.count_ones(), 1);

Source

pub const fn count_zeros(self) -> u32

Returns the number of zeros in the binary representation of self.

§Examples

Basic usage:

use endian_num::Le;

assert_eq!(Le::<i128>::MAX.count_zeros(), 1);

Source

pub const fn leading_zeros(self) -> u32

Returns the number of leading zeros in the binary representation of self.

§Examples

Basic usage:

use endian_num::Le;

let n = Le::<i128>::from_ne(-1);

assert_eq!(n.leading_zeros(), 0);

Source

pub const fn trailing_zeros(self) -> u32

Returns the number of trailing zeros in the binary representation of self.

§Examples

Basic usage:

use endian_num::Le;

let n = Le::<i128>::from_ne(-4);

assert_eq!(n.trailing_zeros(), 2);

Source §

impl Le<isize>

Source

pub const fn abs(self) -> Le<isize>

Computes the absolute value of self.

See isize::abs for documentation on overflow behavior.

§Examples

Basic usage:

use endian_num::Le;

assert_eq!(Le::<isize>::from_ne(10).abs(), Le::<isize>::from_ne(10));
assert_eq!(Le::<isize>::from_ne(-10).abs(), Le::<isize>::from_ne(10));

Source

pub const fn signum(self) -> Le<isize>

Returns a number representing sign of self.

0 if the number is zero
1 if the number is positive
-1 if the number is negative

§Examples

Basic usage:

use endian_num::Le;

assert_eq!(Le::<isize>::from_ne(10).signum().to_ne(), 1);
assert_eq!(Le::<isize>::from_ne(0).signum().to_ne(), 0);
assert_eq!(Le::<isize>::from_ne(-10).signum().to_ne(), -1);

Source

pub const fn is_positive(self) -> bool

Returns true if self is positive and false if the number is zero or negative.

§Examples

Basic usage:

use endian_num::Le;

assert!(Le::<isize>::from_ne(10).is_positive());
assert!(!Le::<isize>::from_ne(-10).is_positive());

Source

pub const fn is_negative(self) -> bool

Returns true if self is negative and false if the number is zero or positive.

§Examples

Basic usage:

use endian_num::Le;

assert!(Le::<isize>::from_ne(-10).is_negative());
assert!(!Le::<isize>::from_ne(10).is_negative());

Source

pub const fn count_ones(self) -> u32

Returns the number of ones in the binary representation of self.

§Examples

Basic usage:

use endian_num::Le;

let n = Le(0b100_0000isize);

assert_eq!(n.count_ones(), 1);

Source

pub const fn count_zeros(self) -> u32

Returns the number of zeros in the binary representation of self.

§Examples

Basic usage:

use endian_num::Le;

assert_eq!(Le::<isize>::MAX.count_zeros(), 1);

Source

pub const fn leading_zeros(self) -> u32

Returns the number of leading zeros in the binary representation of self.

§Examples

Basic usage:

use endian_num::Le;

let n = Le::<isize>::from_ne(-1);

assert_eq!(n.leading_zeros(), 0);

Source

pub const fn trailing_zeros(self) -> u32

Returns the number of trailing zeros in the binary representation of self.

§Examples

Basic usage:

use endian_num::Le;

let n = Le::<isize>::from_ne(-4);

assert_eq!(n.trailing_zeros(), 2);

Source §

impl Le<u8>

Source

pub const fn count_ones(self) -> u32

Returns the number of ones in the binary representation of self.

§Examples

Basic usage:

use endian_num::Le;

let n = Le(0b01001100u8);

assert_eq!(n.count_ones(), 3);

Source

pub const fn count_zeros(self) -> u32

Returns the number of zeros in the binary representation of self.

§Examples

Basic usage:

use endian_num::Le;

assert_eq!(Le::<u8>::MAX.count_zeros(), 0);

Source

pub const fn leading_zeros(self) -> u32

Returns the number of leading zeros in the binary representation of self.

§Examples

Basic usage:

use endian_num::Le;

let n = Le::<u8>::from_ne(u8::MAX >> 2);

assert_eq!(n.leading_zeros(), 2);

Source

pub const fn trailing_zeros(self) -> u32

Returns the number of trailing zeros in the binary representation of self.

§Examples

Basic usage:

use endian_num::Le;

let n = Le::<u8>::from_ne(0b0101000);

assert_eq!(n.trailing_zeros(), 3);

Source

pub const fn is_power_of_two(self) -> bool

Returns true if and only if self == 2^k for some k.

§Examples

Basic usage:

use endian_num::Le;

assert!(Le::<u8>::from_ne(16).is_power_of_two());
assert!(!Le::<u8>::from_ne(10).is_power_of_two());

Source §

impl Le<u16>

Source

pub const fn count_ones(self) -> u32

Returns the number of ones in the binary representation of self.

§Examples

Basic usage:

use endian_num::Le;

let n = Le(0b01001100u16);

assert_eq!(n.count_ones(), 3);

Source

pub const fn count_zeros(self) -> u32

Returns the number of zeros in the binary representation of self.

§Examples

Basic usage:

use endian_num::Le;

assert_eq!(Le::<u16>::MAX.count_zeros(), 0);

Source

pub const fn leading_zeros(self) -> u32

Returns the number of leading zeros in the binary representation of self.

§Examples

Basic usage:

use endian_num::Le;

let n = Le::<u16>::from_ne(u16::MAX >> 2);

assert_eq!(n.leading_zeros(), 2);

Source

pub const fn trailing_zeros(self) -> u32

Returns the number of trailing zeros in the binary representation of self.

§Examples

Basic usage:

use endian_num::Le;

let n = Le::<u16>::from_ne(0b0101000);

assert_eq!(n.trailing_zeros(), 3);

Source

pub const fn is_power_of_two(self) -> bool

Returns true if and only if self == 2^k for some k.

§Examples

Basic usage:

use endian_num::Le;

assert!(Le::<u16>::from_ne(16).is_power_of_two());
assert!(!Le::<u16>::from_ne(10).is_power_of_two());

Source §

impl Le<u32>

Source

pub const fn count_ones(self) -> u32

Returns the number of ones in the binary representation of self.

§Examples

Basic usage:

use endian_num::Le;

let n = Le(0b01001100u32);

assert_eq!(n.count_ones(), 3);

Source

pub const fn count_zeros(self) -> u32

Returns the number of zeros in the binary representation of self.

§Examples

Basic usage:

use endian_num::Le;

assert_eq!(Le::<u32>::MAX.count_zeros(), 0);

Source

pub const fn leading_zeros(self) -> u32

Returns the number of leading zeros in the binary representation of self.

§Examples

Basic usage:

use endian_num::Le;

let n = Le::<u32>::from_ne(u32::MAX >> 2);

assert_eq!(n.leading_zeros(), 2);

Source

pub const fn trailing_zeros(self) -> u32

Returns the number of trailing zeros in the binary representation of self.

§Examples

Basic usage:

use endian_num::Le;

let n = Le::<u32>::from_ne(0b0101000);

assert_eq!(n.trailing_zeros(), 3);

Source

pub const fn is_power_of_two(self) -> bool

Returns true if and only if self == 2^k for some k.

§Examples

Basic usage:

use endian_num::Le;

assert!(Le::<u32>::from_ne(16).is_power_of_two());
assert!(!Le::<u32>::from_ne(10).is_power_of_two());

Source §

impl Le<u64>

Source

pub const fn count_ones(self) -> u32

Returns the number of ones in the binary representation of self.

§Examples

Basic usage:

use endian_num::Le;

let n = Le(0b01001100u64);

assert_eq!(n.count_ones(), 3);

Source

pub const fn count_zeros(self) -> u32

Returns the number of zeros in the binary representation of self.

§Examples

Basic usage:

use endian_num::Le;

assert_eq!(Le::<u64>::MAX.count_zeros(), 0);

Source

pub const fn leading_zeros(self) -> u32

Returns the number of leading zeros in the binary representation of self.

§Examples

Basic usage:

use endian_num::Le;

let n = Le::<u64>::from_ne(u64::MAX >> 2);

assert_eq!(n.leading_zeros(), 2);

Source

pub const fn trailing_zeros(self) -> u32

Returns the number of trailing zeros in the binary representation of self.

§Examples

Basic usage:

use endian_num::Le;

let n = Le::<u64>::from_ne(0b0101000);

assert_eq!(n.trailing_zeros(), 3);

Source

pub const fn is_power_of_two(self) -> bool

Returns true if and only if self == 2^k for some k.

§Examples

Basic usage:

use endian_num::Le;

assert!(Le::<u64>::from_ne(16).is_power_of_two());
assert!(!Le::<u64>::from_ne(10).is_power_of_two());

Source §

impl Le<u128>

Source

pub const fn count_ones(self) -> u32

Returns the number of ones in the binary representation of self.

§Examples

Basic usage:

use endian_num::Le;

let n = Le(0b01001100u128);

assert_eq!(n.count_ones(), 3);

Source

pub const fn count_zeros(self) -> u32

Returns the number of zeros in the binary representation of self.

§Examples

Basic usage:

use endian_num::Le;

assert_eq!(Le::<u128>::MAX.count_zeros(), 0);

Source

pub const fn leading_zeros(self) -> u32

Returns the number of leading zeros in the binary representation of self.

§Examples

Basic usage:

use endian_num::Le;

let n = Le::<u128>::from_ne(u128::MAX >> 2);

assert_eq!(n.leading_zeros(), 2);

Source

pub const fn trailing_zeros(self) -> u32

Returns the number of trailing zeros in the binary representation of self.

§Examples

Basic usage:

use endian_num::Le;

let n = Le::<u128>::from_ne(0b0101000);

assert_eq!(n.trailing_zeros(), 3);

Source

pub const fn is_power_of_two(self) -> bool

Returns true if and only if self == 2^k for some k.

§Examples

Basic usage:

use endian_num::Le;

assert!(Le::<u128>::from_ne(16).is_power_of_two());
assert!(!Le::<u128>::from_ne(10).is_power_of_two());

Source §

impl Le<usize>

Source

pub const fn count_ones(self) -> u32

Returns the number of ones in the binary representation of self.

§Examples

Basic usage:

use endian_num::Le;

let n = Le(0b01001100usize);

assert_eq!(n.count_ones(), 3);

Source

pub const fn count_zeros(self) -> u32

Returns the number of zeros in the binary representation of self.

§Examples

Basic usage:

use endian_num::Le;

assert_eq!(Le::<usize>::MAX.count_zeros(), 0);

Source

pub const fn leading_zeros(self) -> u32

Returns the number of leading zeros in the binary representation of self.

§Examples

Basic usage:

use endian_num::Le;

let n = Le::<usize>::from_ne(usize::MAX >> 2);

assert_eq!(n.leading_zeros(), 2);

Source

pub const fn trailing_zeros(self) -> u32

Returns the number of trailing zeros in the binary representation of self.

§Examples

Basic usage:

use endian_num::Le;

let n = Le::<usize>::from_ne(0b0101000);

assert_eq!(n.trailing_zeros(), 3);

Source

pub const fn is_power_of_two(self) -> bool

Returns true if and only if self == 2^k for some k.

§Examples

Basic usage:

use endian_num::Le;

assert!(Le::<usize>::from_ne(16).is_power_of_two());
assert!(!Le::<usize>::from_ne(10).is_power_of_two());

Source §

fn zero(&mut self)

Overwrites self with zeros. Read more

Source §

fn new_zeroed() -> Self
where Self: Sized,

Creates an instance of Self from zeroed bytes. Read more

Source §

impl<T> Hash for Le<T>
where T: Hash,

Source §

fn hash<H>(&self, state: &mut H)
where __H: Hasher,

Feeds this value into the given Hasher. Read more

1.3.0 · Source§

fn hash_slice<H>(data: &[Self], state: &mut H)
where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher. Read more

Source §

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

Source §

This method returns an ordering between self and other values if one exists. Read more

1.0.0 · Source§

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator. Read more

1.0.0 · Source§

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator. Read more

1.0.0 · Source§

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator. Read more

1.0.0 · Source§

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator. Read more

Source §

This method returns an ordering between self and other values if one exists. Read more

1.0.0 · Source§

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator. Read more

1.0.0 · Source§

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator. Read more

1.0.0 · Source§

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator. Read more

1.0.0 · Source§

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator. Read more

Source §

This method returns an ordering between self and other values if one exists. Read more

1.0.0 · Source§

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator. Read more

1.0.0 · Source§

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator. Read more

1.0.0 · Source§

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator. Read more

impl WriteHex for Le<usize>

Source §

fn write_hex<W>(&self, writer: W) -> Result<(), Error>
where W: Write,

Write the value as hex.

Source §

impl<T> StructuralPartialEq for Le<T>

impl<T, U> Into for T
where U: From<T>,

Source §

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source §

impl<T> ToOwned for T
where T: Clone,

Source §

type Owned = T

The resulting type after obtaining ownership.

Source §

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more

Performs the conversion.

Source §

impl<T, U> TryInto for T
where U: TryFrom<T>,

Source §

type Error = >::Error

The type returned in the event of a conversion error.

Source §

fn try_into(self) -> Result<U, >::Error>

Performs the conversion.

Struct LeCopy item path

§Examples

Tuple Fields§

Implementations§

impl Le<u8>

pub const MIN: Le<u8>

§Examples

pub const MAX: Le<u8>

§Examples

pub const BITS: u32 = 8u32

§Examples

pub const fn from_ne(n: u8) -> Le<u8>

§Examples

pub const fn from_be(n: Be<u8>) -> Le<u8>

§Examples

pub const fn to_ne(self) -> u8

§Examples

pub const fn to_be(self) -> Be<u8>

§Examples

pub const fn to_be_bytes(self) -> [u8; 1]

§Examples

pub const fn to_le_bytes(self) -> [u8; 1]

§Examples

pub const fn to_ne_bytes(self) -> [u8; 1]

§Examples

pub const fn from_be_bytes(bytes: [u8; 1]) -> Le<u8>

§Examples

pub const fn from_le_bytes(bytes: [u8; 1]) -> Le<u8>

§Examples

pub const fn from_ne_bytes(bytes: [u8; 1]) -> Le<u8>

§Examples

pub const fn rotate_left(self, n: u32) -> Le<u8>

§Examples

pub const fn rotate_right(self, n: u32) -> Le<u8>

§Examples

pub const fn swap_bytes(self) -> Le<u8>

§Examples

pub const fn reverse_bits(self) -> Le<u8>

§Examples

pub const fn pow(self, exp: u32) -> Le<u8>

§Examples

impl Le<u16>

pub const MIN: Le<u16>

§Examples

pub const MAX: Le<u16>

§Examples

pub const BITS: u32 = 16u32

§Examples

pub const fn from_ne(n: u16) -> Le<u16>

§Examples

pub const fn from_be(n: Be<u16>) -> Le<u16>

§Examples

pub const fn to_ne(self) -> u16

§Examples

pub const fn to_be(self) -> Be<u16>

§Examples

pub const fn to_be_bytes(self) -> [u8; 2]

§Examples

pub const fn to_le_bytes(self) -> [u8; 2]

§Examples

pub const fn to_ne_bytes(self) -> [u8; 2]

§Examples

pub const fn from_be_bytes(bytes: [u8; 2]) -> Le<u16>

§Examples

pub const fn from_le_bytes(bytes: [u8; 2]) -> Le<u16>

§Examples

pub const fn from_ne_bytes(bytes: [u8; 2]) -> Le<u16>

§Examples

pub const fn rotate_left(self, n: u32) -> Le<u16>

§Examples

pub const fn rotate_right(self, n: u32) -> Le<u16>

§Examples

pub const fn swap_bytes(self) -> Le<u16>

§Examples

pub const fn reverse_bits(self) -> Le<u16>

§Examples

pub const fn pow(self, exp: u32) -> Le<u16>

§Examples

impl Le<u32>

pub const MIN: Le<u32>

Struct Le