Struct LittleEndian 

pub struct LittleEndian<T: Endianable>(/* private fields */);

A wrapper type that ensures the inner Endianable value is treated as Little-Endian.

When creating a LittleEndian instance, the value is converted to little-endian. When retrieving the inner value with get, it is converted back to the native endianness.

Implementations

impl<T: Endianable> LittleEndian<T>

pub fn new(val: T) -> Self

Creates a new LittleEndian instance from a value, converting it to little-endian.

Examples found in repository

examples/simple_usage.rs (line 33)

fn main() {
    println!("=== Simple Byteable Usage Example ===\n");

    // Example 1: Create a sensor reading
    let reading = SensorReading {
        sensor_id: 5,
        temperature: LittleEndian::new(2547), // 25.47°C
        humidity: LittleEndian::new(6523),    // 65.23%
        pressure: BigEndian::new(101325),     // Standard atmospheric pressure
    };

    println!("1. Sensor Reading:");
    println!("   Sensor ID: {}", reading.sensor_id);
    println!(
        "   Temperature: {:.2}°C",
        reading.temperature.get() as f32 / 100.0
    );
    println!("   Humidity: {:.2}%", reading.humidity.get() as f32 / 100.0);
    println!("   Pressure: {} Pa", reading.pressure.get());

    // Convert to bytes
    let bytes = reading.as_bytearray();
    println!("   Byte representation: {:?}", bytes);
    println!("   Size: {} bytes\n", bytes.len());

    // Example 2: Reconstruct from bytes
    println!("2. Reconstructing from bytes:");
    let reconstructed = SensorReading::from_bytearray(bytes);
    println!("   Reconstructed: {:?}", reconstructed);
    println!("   Matches original: {}\n", reconstructed == reading);

    // Example 3: Working with colors
    println!("3. RGB Color:");
    let cyan = RgbColor {
        red: 0,
        green: 255,
        blue: 255,
    };

    println!("   Color: RGB({}, {}, {})", cyan.red, cyan.green, cyan.blue);
    let color_bytes = cyan.as_bytearray();
    println!("   Bytes: {:?}", color_bytes);
    println!(
        "   Hex representation: #{:02X}{:02X}{:02X}\n",
        color_bytes[0], color_bytes[1], color_bytes[2]
    );

    // Example 4: Array of byteable structs
    println!("4. Working with arrays:");
    let color_palette = [
        RgbColor {
            red: 255,
            green: 0,
            blue: 0,
        }, // Red
        RgbColor {
            red: 0,
            green: 255,
            blue: 0,
        }, // Green
        RgbColor {
            red: 0,
            green: 0,
            blue: 255,
        }, // Blue
    ];

    println!("   Color palette:");
    for (i, color) in color_palette.iter().enumerate() {
        let bytes = color.as_bytearray();
        println!(
            "   Color {}: RGB({:3}, {:3}, {:3}) = {:?}",
            i + 1,
            color.red,
            color.green,
            color.blue,
            bytes
        );
    }

    // Convert entire palette to bytes
    let total_size = std::mem::size_of::<RgbColor>() * color_palette.len();
    println!("   Total palette size: {} bytes", total_size);

    println!("\n=== Example completed! ===");
}

examples/file_io.rs (line 55)

fn main() -> io::Result<()> {
    println!("=== Byteable Derive Macro Example ===\n");

    // Example 1: Creating and inspecting a byteable struct
    println!("1. Creating a NetworkPacket:");
    let packet = NetworkPacket {
        sequence: 42,
        packet_type: LittleEndian::new(0x1234),
        payload_length: BigEndian::new(1024),
        timestamp: LittleEndian::new(1638360000),
    };

    println!("   Packet: {:?}", packet);
    println!("   Sequence: {}", packet.sequence);
    println!("   Packet Type: 0x{:04X}", packet.packet_type.get());
    println!("   Payload Length: {} bytes", packet.payload_length.get());
    println!("   Timestamp: {}", packet.timestamp.get());

    // Convert to byte array
    let bytes = packet.as_bytearray();
    println!("   As bytes: {:?}", bytes);
    println!("   Size: {} bytes\n", bytes.len());

    // Example 2: Writing to a file
    println!("2. Writing structs to a file:");
    let mut file = File::create("example_data.bin")?;

    // Write multiple packets
    file.write_one(packet)?;

    let packet2 = NetworkPacket {
        sequence: 43,
        packet_type: LittleEndian::new(0x5678),
        payload_length: BigEndian::new(2048),
        timestamp: LittleEndian::new(1638360001),
    };
    file.write_one(packet2)?;

    // Write a device config
    let config = DeviceConfig {
        device_id: LittleEndian::new(0xABCDEF01),
        version: 1,
        flags: 0b10101010,
        port: BigEndian::new(8080),
        calibration: LittleEndian::new(3.14159),
    };
    file.write_one(config)?;

    println!("   Written 2 NetworkPackets and 1 DeviceConfig to 'example_data.bin'");
    println!(
        "   File size: {} bytes\n",
        std::mem::size_of::<NetworkPacket>() * 2 + std::mem::size_of::<DeviceConfig>()
    );

    // Example 3: Reading from a file
    println!("3. Reading structs from the file:");
    let mut file = File::open("example_data.bin")?;

    // Read the packets back
    let read_packet1: NetworkPacket = file.read_one()?;
    let read_packet2: NetworkPacket = file.read_one()?;
    let read_config: DeviceConfig = file.read_one()?;

    println!("   First packet: {:?}", read_packet1);
    println!("   Matches original: {}", read_packet1 == packet);
    println!();

    println!("   Second packet: {:?}", read_packet2);
    println!("   Sequence: {}", read_packet2.sequence);
    println!();

    println!("   Device config: {:?}", read_config);
    println!("   Device ID: 0x{:08X}", read_config.device_id.get());
    println!("   Version: {}", read_config.version);
    println!("   Flags: 0b{:08b}", read_config.flags);
    println!("   Port: {}", read_config.port.get());
    println!("   Calibration: {:.5}", read_config.calibration.get());
    println!();

    // Example 4: Random access with seek
    println!("4. Random access with seek:");
    file.seek(SeekFrom::Start(0))?;
    let first: NetworkPacket = file.read_one()?;
    println!("   Read first packet again: sequence = {}", first.sequence);

    // Seek to the second packet
    file.seek(SeekFrom::Start(std::mem::size_of::<NetworkPacket>() as u64))?;
    let second: NetworkPacket = file.read_one()?;
    println!("   Seeked to second packet: sequence = {}", second.sequence);
    println!();

    // Example 5: Demonstrating byte array conversion
    println!("5. Manual byte array conversion:");
    let test_packet = NetworkPacket {
        sequence: 100,
        packet_type: LittleEndian::new(0xFF00),
        payload_length: BigEndian::new(512),
        timestamp: LittleEndian::new(999999),
    };

    // Convert to bytes
    let byte_array = test_packet.as_bytearray();
    println!("   Original packet: {:?}", test_packet);
    println!("   Byte array: {:?}", byte_array);

    // Convert back from bytes
    let reconstructed = NetworkPacket::from_bytearray(byte_array);
    println!("   Reconstructed: {:?}", reconstructed);
    println!("   Round-trip successful: {}", test_packet == reconstructed);

    // Cleanup
    println!("\n=== Example completed successfully! ===");
    println!("Note: The file 'example_data.bin' has been created in the current directory.");

    Ok(())
}

examples/cursor_usage.rs (line 50)

fn main() -> std::io::Result<()> {
    println!("=== Cursor-based Byteable Example ===\n");

    // Example 1: Writing to a cursor (in-memory buffer)
    println!("1. Writing messages to an in-memory buffer:");

    let header = MessageHeader {
        magic: *b"DEMO",
        version: 1,
        message_type: 0x01,
        payload_length: BigEndian::new(16),
        sequence_number: LittleEndian::new(1001),
    };

    let login = LoginRequest {
        user_id: LittleEndian::new(42),
        session_token: LittleEndian::new(0x1234567890ABCDEF),
        flags: 0b00001111,
        padding: [0; 3],
    };

    // Write to cursor
    let mut buffer = Cursor::new(Vec::new());
    buffer.write_one(header)?;
    buffer.write_one(login)?;

    let bytes = buffer.into_inner();
    println!("   Written {} bytes", bytes.len());
    println!("   Buffer contents: {:02X?}\n", bytes);

    // Example 2: Reading from a cursor
    println!("2. Reading messages from the buffer:");
    let mut reader = Cursor::new(bytes.clone());

    let read_header: MessageHeader = reader.read_one()?;
    let read_login: LoginRequest = reader.read_one()?;

    println!("   Header:");
    println!(
        "      Magic: {}",
        std::str::from_utf8(&read_header.magic).unwrap_or("???")
    );
    println!("      Version: {}", read_header.version);
    println!("      Message Type: 0x{:02X}", read_header.message_type);
    println!(
        "      Payload Length: {} bytes",
        read_header.payload_length.get()
    );
    println!(
        "      Sequence Number: {}",
        read_header.sequence_number.get()
    );

    println!("\n   Login Request:");
    println!("      User ID: {}", read_login.user_id.get());
    println!(
        "      Session Token: 0x{:016X}",
        read_login.session_token.get()
    );
    println!("      Flags: 0b{:08b}", read_login.flags);

    println!(
        "\n   Data matches: {}\n",
        read_header == header && read_login == login
    );

    // Example 3: Building a packet with multiple messages
    println!("3. Building a multi-message packet:");

    let mut packet = Cursor::new(Vec::new());

    // Write three different messages
    let headers = [
        MessageHeader {
            magic: *b"MSG1",
            version: 1,
            message_type: 0x10,
            payload_length: BigEndian::new(16),
            sequence_number: LittleEndian::new(100),
        },
        MessageHeader {
            magic: *b"MSG2",
            version: 1,
            message_type: 0x20,
            payload_length: BigEndian::new(16),
            sequence_number: LittleEndian::new(101),
        },
        MessageHeader {
            magic: *b"MSG3",
            version: 1,
            message_type: 0x30,
            payload_length: BigEndian::new(16),
            sequence_number: LittleEndian::new(102),
        },
    ];

    for header in &headers {
        packet.write_one(*header)?;
    }

    let packet_bytes = packet.into_inner();
    println!("   Packet size: {} bytes", packet_bytes.len());
    println!(
        "   Messages per packet: {}",
        packet_bytes.len() / std::mem::size_of::<MessageHeader>()
    );

    // Read them back
    let mut reader = Cursor::new(packet_bytes);
    println!("\n   Reading messages:");
    for i in 0..3 {
        let msg: MessageHeader = reader.read_one()?;
        println!(
            "      Message {}: {} (type: 0x{:02X}, seq: {})",
            i + 1,
            std::str::from_utf8(&msg.magic).unwrap_or("???"),
            msg.message_type,
            msg.sequence_number.get()
        );
    }

    // Example 4: Working with status responses
    println!("\n4. Status response example:");

    let status = StatusResponse {
        status_code: BigEndian::new(200),
        timestamp: LittleEndian::new(1700000000),
        reserved: [0; 6],
    };

    let mut status_buffer = Cursor::new(Vec::new());
    status_buffer.write_one(status)?;

    let status_bytes = status_buffer.into_inner();
    println!("   Status response bytes: {:?}", status_bytes);

    let mut status_reader = Cursor::new(status_bytes);
    let read_status: StatusResponse = status_reader.read_one()?;

    println!("   Status Code: {}", read_status.status_code.get());
    println!("   Timestamp: {}", read_status.timestamp.get());
    println!("   Matches original: {}", read_status == status);

    println!("\n=== Example completed successfully! ===");
    Ok(())
}

pub fn get(self) -> T

Returns the inner value, converting it from little-endian to the native endianness.

Examples found in repository

examples/simple_usage.rs (line 42)

fn main() {
    println!("=== Simple Byteable Usage Example ===\n");

    // Example 1: Create a sensor reading
    let reading = SensorReading {
        sensor_id: 5,
        temperature: LittleEndian::new(2547), // 25.47°C
        humidity: LittleEndian::new(6523),    // 65.23%
        pressure: BigEndian::new(101325),     // Standard atmospheric pressure
    };

    println!("1. Sensor Reading:");
    println!("   Sensor ID: {}", reading.sensor_id);
    println!(
        "   Temperature: {:.2}°C",
        reading.temperature.get() as f32 / 100.0
    );
    println!("   Humidity: {:.2}%", reading.humidity.get() as f32 / 100.0);
    println!("   Pressure: {} Pa", reading.pressure.get());

    // Convert to bytes
    let bytes = reading.as_bytearray();
    println!("   Byte representation: {:?}", bytes);
    println!("   Size: {} bytes\n", bytes.len());

    // Example 2: Reconstruct from bytes
    println!("2. Reconstructing from bytes:");
    let reconstructed = SensorReading::from_bytearray(bytes);
    println!("   Reconstructed: {:?}", reconstructed);
    println!("   Matches original: {}\n", reconstructed == reading);

    // Example 3: Working with colors
    println!("3. RGB Color:");
    let cyan = RgbColor {
        red: 0,
        green: 255,
        blue: 255,
    };

    println!("   Color: RGB({}, {}, {})", cyan.red, cyan.green, cyan.blue);
    let color_bytes = cyan.as_bytearray();
    println!("   Bytes: {:?}", color_bytes);
    println!(
        "   Hex representation: #{:02X}{:02X}{:02X}\n",
        color_bytes[0], color_bytes[1], color_bytes[2]
    );

    // Example 4: Array of byteable structs
    println!("4. Working with arrays:");
    let color_palette = [
        RgbColor {
            red: 255,
            green: 0,
            blue: 0,
        }, // Red
        RgbColor {
            red: 0,
            green: 255,
            blue: 0,
        }, // Green
        RgbColor {
            red: 0,
            green: 0,
            blue: 255,
        }, // Blue
    ];

    println!("   Color palette:");
    for (i, color) in color_palette.iter().enumerate() {
        let bytes = color.as_bytearray();
        println!(
            "   Color {}: RGB({:3}, {:3}, {:3}) = {:?}",
            i + 1,
            color.red,
            color.green,
            color.blue,
            bytes
        );
    }

    // Convert entire palette to bytes
    let total_size = std::mem::size_of::<RgbColor>() * color_palette.len();
    println!("   Total palette size: {} bytes", total_size);

    println!("\n=== Example completed! ===");
}

examples/file_io.rs (line 62)

fn main() -> io::Result<()> {
    println!("=== Byteable Derive Macro Example ===\n");

    // Example 1: Creating and inspecting a byteable struct
    println!("1. Creating a NetworkPacket:");
    let packet = NetworkPacket {
        sequence: 42,
        packet_type: LittleEndian::new(0x1234),
        payload_length: BigEndian::new(1024),
        timestamp: LittleEndian::new(1638360000),
    };

    println!("   Packet: {:?}", packet);
    println!("   Sequence: {}", packet.sequence);
    println!("   Packet Type: 0x{:04X}", packet.packet_type.get());
    println!("   Payload Length: {} bytes", packet.payload_length.get());
    println!("   Timestamp: {}", packet.timestamp.get());

    // Convert to byte array
    let bytes = packet.as_bytearray();
    println!("   As bytes: {:?}", bytes);
    println!("   Size: {} bytes\n", bytes.len());

    // Example 2: Writing to a file
    println!("2. Writing structs to a file:");
    let mut file = File::create("example_data.bin")?;

    // Write multiple packets
    file.write_one(packet)?;

    let packet2 = NetworkPacket {
        sequence: 43,
        packet_type: LittleEndian::new(0x5678),
        payload_length: BigEndian::new(2048),
        timestamp: LittleEndian::new(1638360001),
    };
    file.write_one(packet2)?;

    // Write a device config
    let config = DeviceConfig {
        device_id: LittleEndian::new(0xABCDEF01),
        version: 1,
        flags: 0b10101010,
        port: BigEndian::new(8080),
        calibration: LittleEndian::new(3.14159),
    };
    file.write_one(config)?;

    println!("   Written 2 NetworkPackets and 1 DeviceConfig to 'example_data.bin'");
    println!(
        "   File size: {} bytes\n",
        std::mem::size_of::<NetworkPacket>() * 2 + std::mem::size_of::<DeviceConfig>()
    );

    // Example 3: Reading from a file
    println!("3. Reading structs from the file:");
    let mut file = File::open("example_data.bin")?;

    // Read the packets back
    let read_packet1: NetworkPacket = file.read_one()?;
    let read_packet2: NetworkPacket = file.read_one()?;
    let read_config: DeviceConfig = file.read_one()?;

    println!("   First packet: {:?}", read_packet1);
    println!("   Matches original: {}", read_packet1 == packet);
    println!();

    println!("   Second packet: {:?}", read_packet2);
    println!("   Sequence: {}", read_packet2.sequence);
    println!();

    println!("   Device config: {:?}", read_config);
    println!("   Device ID: 0x{:08X}", read_config.device_id.get());
    println!("   Version: {}", read_config.version);
    println!("   Flags: 0b{:08b}", read_config.flags);
    println!("   Port: {}", read_config.port.get());
    println!("   Calibration: {:.5}", read_config.calibration.get());
    println!();

    // Example 4: Random access with seek
    println!("4. Random access with seek:");
    file.seek(SeekFrom::Start(0))?;
    let first: NetworkPacket = file.read_one()?;
    println!("   Read first packet again: sequence = {}", first.sequence);

    // Seek to the second packet
    file.seek(SeekFrom::Start(std::mem::size_of::<NetworkPacket>() as u64))?;
    let second: NetworkPacket = file.read_one()?;
    println!("   Seeked to second packet: sequence = {}", second.sequence);
    println!();

    // Example 5: Demonstrating byte array conversion
    println!("5. Manual byte array conversion:");
    let test_packet = NetworkPacket {
        sequence: 100,
        packet_type: LittleEndian::new(0xFF00),
        payload_length: BigEndian::new(512),
        timestamp: LittleEndian::new(999999),
    };

    // Convert to bytes
    let byte_array = test_packet.as_bytearray();
    println!("   Original packet: {:?}", test_packet);
    println!("   Byte array: {:?}", byte_array);

    // Convert back from bytes
    let reconstructed = NetworkPacket::from_bytearray(byte_array);
    println!("   Reconstructed: {:?}", reconstructed);
    println!("   Round-trip successful: {}", test_packet == reconstructed);

    // Cleanup
    println!("\n=== Example completed successfully! ===");
    println!("Note: The file 'example_data.bin' has been created in the current directory.");

    Ok(())
}

examples/cursor_usage.rs (line 89)

fn main() -> std::io::Result<()> {
    println!("=== Cursor-based Byteable Example ===\n");

    // Example 1: Writing to a cursor (in-memory buffer)
    println!("1. Writing messages to an in-memory buffer:");

    let header = MessageHeader {
        magic: *b"DEMO",
        version: 1,
        message_type: 0x01,
        payload_length: BigEndian::new(16),
        sequence_number: LittleEndian::new(1001),
    };

    let login = LoginRequest {
        user_id: LittleEndian::new(42),
        session_token: LittleEndian::new(0x1234567890ABCDEF),
        flags: 0b00001111,
        padding: [0; 3],
    };

    // Write to cursor
    let mut buffer = Cursor::new(Vec::new());
    buffer.write_one(header)?;
    buffer.write_one(login)?;

    let bytes = buffer.into_inner();
    println!("   Written {} bytes", bytes.len());
    println!("   Buffer contents: {:02X?}\n", bytes);

    // Example 2: Reading from a cursor
    println!("2. Reading messages from the buffer:");
    let mut reader = Cursor::new(bytes.clone());

    let read_header: MessageHeader = reader.read_one()?;
    let read_login: LoginRequest = reader.read_one()?;

    println!("   Header:");
    println!(
        "      Magic: {}",
        std::str::from_utf8(&read_header.magic).unwrap_or("???")
    );
    println!("      Version: {}", read_header.version);
    println!("      Message Type: 0x{:02X}", read_header.message_type);
    println!(
        "      Payload Length: {} bytes",
        read_header.payload_length.get()
    );
    println!(
        "      Sequence Number: {}",
        read_header.sequence_number.get()
    );

    println!("\n   Login Request:");
    println!("      User ID: {}", read_login.user_id.get());
    println!(
        "      Session Token: 0x{:016X}",
        read_login.session_token.get()
    );
    println!("      Flags: 0b{:08b}", read_login.flags);

    println!(
        "\n   Data matches: {}\n",
        read_header == header && read_login == login
    );

    // Example 3: Building a packet with multiple messages
    println!("3. Building a multi-message packet:");

    let mut packet = Cursor::new(Vec::new());

    // Write three different messages
    let headers = [
        MessageHeader {
            magic: *b"MSG1",
            version: 1,
            message_type: 0x10,
            payload_length: BigEndian::new(16),
            sequence_number: LittleEndian::new(100),
        },
        MessageHeader {
            magic: *b"MSG2",
            version: 1,
            message_type: 0x20,
            payload_length: BigEndian::new(16),
            sequence_number: LittleEndian::new(101),
        },
        MessageHeader {
            magic: *b"MSG3",
            version: 1,
            message_type: 0x30,
            payload_length: BigEndian::new(16),
            sequence_number: LittleEndian::new(102),
        },
    ];

    for header in &headers {
        packet.write_one(*header)?;
    }

    let packet_bytes = packet.into_inner();
    println!("   Packet size: {} bytes", packet_bytes.len());
    println!(
        "   Messages per packet: {}",
        packet_bytes.len() / std::mem::size_of::<MessageHeader>()
    );

    // Read them back
    let mut reader = Cursor::new(packet_bytes);
    println!("\n   Reading messages:");
    for i in 0..3 {
        let msg: MessageHeader = reader.read_one()?;
        println!(
            "      Message {}: {} (type: 0x{:02X}, seq: {})",
            i + 1,
            std::str::from_utf8(&msg.magic).unwrap_or("???"),
            msg.message_type,
            msg.sequence_number.get()
        );
    }

    // Example 4: Working with status responses
    println!("\n4. Status response example:");

    let status = StatusResponse {
        status_code: BigEndian::new(200),
        timestamp: LittleEndian::new(1700000000),
        reserved: [0; 6],
    };

    let mut status_buffer = Cursor::new(Vec::new());
    status_buffer.write_one(status)?;

    let status_bytes = status_buffer.into_inner();
    println!("   Status response bytes: {:?}", status_bytes);

    let mut status_reader = Cursor::new(status_bytes);
    let read_status: StatusResponse = status_reader.read_one()?;

    println!("   Status Code: {}", read_status.status_code.get());
    println!("   Timestamp: {}", read_status.timestamp.get());
    println!("   Matches original: {}", read_status == status);

    println!("\n=== Example completed successfully! ===");
    Ok(())
}

pub fn get_raw(self) -> T

Returns the underlying native representation without any endian conversion.

Trait Implementations

impl Byteable for LittleEndian<f32>

type ByteArray = [u8; 4]

The associated byte array type that can represent Self.

fn as_bytearray(self) -> Self::ByteArray

Converts self into its ByteableByteArray representation.

fn from_bytearray(ba: Self::ByteArray) -> Self

Creates an instance of Self from a ByteableByteArray.

impl Byteable for LittleEndian<f64>

type ByteArray = [u8; 8]

The associated byte array type that can represent Self.

fn as_bytearray(self) -> Self::ByteArray

Converts self into its ByteableByteArray representation.

fn from_bytearray(ba: Self::ByteArray) -> Self

Creates an instance of Self from a ByteableByteArray.

impl Byteable for LittleEndian<i128>

type ByteArray = [u8; 16]

The associated byte array type that can represent Self.

fn as_bytearray(self) -> Self::ByteArray

Converts self into its ByteableByteArray representation.

fn from_bytearray(ba: Self::ByteArray) -> Self

Creates an instance of Self from a ByteableByteArray.

impl Byteable for LittleEndian<i16>

type ByteArray = [u8; 2]

The associated byte array type that can represent Self.

fn as_bytearray(self) -> Self::ByteArray

Converts self into its ByteableByteArray representation.

fn from_bytearray(ba: Self::ByteArray) -> Self

Creates an instance of Self from a ByteableByteArray.

impl Byteable for LittleEndian<i32>

type ByteArray = [u8; 4]

The associated byte array type that can represent Self.

fn as_bytearray(self) -> Self::ByteArray

Converts self into its ByteableByteArray representation.

fn from_bytearray(ba: Self::ByteArray) -> Self

Creates an instance of Self from a ByteableByteArray.

impl Byteable for LittleEndian<i64>

type ByteArray = [u8; 8]

The associated byte array type that can represent Self.

fn as_bytearray(self) -> Self::ByteArray

Converts self into its ByteableByteArray representation.

fn from_bytearray(ba: Self::ByteArray) -> Self

Creates an instance of Self from a ByteableByteArray.

impl Byteable for LittleEndian<i8>

type ByteArray = [u8; 1]

The associated byte array type that can represent Self.

fn as_bytearray(self) -> Self::ByteArray

Converts self into its ByteableByteArray representation.

fn from_bytearray(ba: Self::ByteArray) -> Self

Creates an instance of Self from a ByteableByteArray.

impl Byteable for LittleEndian<isize>

type ByteArray = [u8; 8]

The associated byte array type that can represent Self.

fn as_bytearray(self) -> Self::ByteArray

Converts self into its ByteableByteArray representation.

fn from_bytearray(ba: Self::ByteArray) -> Self

Creates an instance of Self from a ByteableByteArray.

impl Byteable for LittleEndian<u128>

type ByteArray = [u8; 16]

The associated byte array type that can represent Self.

fn as_bytearray(self) -> Self::ByteArray

Converts self into its ByteableByteArray representation.

fn from_bytearray(ba: Self::ByteArray) -> Self

Creates an instance of Self from a ByteableByteArray.

impl Byteable for LittleEndian<u16>

type ByteArray = [u8; 2]

The associated byte array type that can represent Self.

fn as_bytearray(self) -> Self::ByteArray

Converts self into its ByteableByteArray representation.

fn from_bytearray(ba: Self::ByteArray) -> Self

Creates an instance of Self from a ByteableByteArray.

impl Byteable for LittleEndian<u32>

type ByteArray = [u8; 4]

The associated byte array type that can represent Self.

fn as_bytearray(self) -> Self::ByteArray

Converts self into its ByteableByteArray representation.

fn from_bytearray(ba: Self::ByteArray) -> Self

Creates an instance of Self from a ByteableByteArray.

impl Byteable for LittleEndian<u64>

type ByteArray = [u8; 8]

The associated byte array type that can represent Self.

fn as_bytearray(self) -> Self::ByteArray

Converts self into its ByteableByteArray representation.

fn from_bytearray(ba: Self::ByteArray) -> Self

Creates an instance of Self from a ByteableByteArray.

impl Byteable for LittleEndian<u8>

type ByteArray = [u8; 1]

The associated byte array type that can represent Self.

fn as_bytearray(self) -> Self::ByteArray

Converts self into its ByteableByteArray representation.

fn from_bytearray(ba: Self::ByteArray) -> Self

Creates an instance of Self from a ByteableByteArray.

impl Byteable for LittleEndian<usize>

type ByteArray = [u8; 8]

The associated byte array type that can represent Self.

fn as_bytearray(self) -> Self::ByteArray

Converts self into its ByteableByteArray representation.

fn from_bytearray(ba: Self::ByteArray) -> Self

Creates an instance of Self from a ByteableByteArray.

impl<T: Clone + Endianable> Clone for LittleEndian<T>

fn clone(&self) -> LittleEndian<T>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug + Endianable> Debug for LittleEndian<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: Endianable + Default> Default for LittleEndian<T>

fn default() -> Self

Returns the “default value” for a type.

impl<T: Hash + Endianable> Hash for LittleEndian<T>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T: Ord + Endianable> Ord for LittleEndian<T>

fn cmp(&self, other: &LittleEndian<T>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<T: PartialEq + Endianable> PartialEq for LittleEndian<T>

fn eq(&self, other: &LittleEndian<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: PartialOrd + Endianable> PartialOrd for LittleEndian<T>

fn partial_cmp(&self, other: &LittleEndian<T>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T: Copy + Endianable> Copy for LittleEndian<T>

impl<T: Eq + Endianable> Eq for LittleEndian<T>

impl<T: Endianable> StructuralPartialEq for LittleEndian<T>