接口

interface BigEndianOrder<T>

public interface BigEndianOrder<T> {
    func writeBigEndian(buffer: Array<Byte>): Int64
    static func readBigEndian(buffer: Array<Byte>): T
}

功能：大端序字节序列转换接口。

static func readBigEndian(Array<Byte>)

static func readBigEndian(buffer: Array<Byte>): T

功能：从字节数组中以大端序的方式读取一个 T 值。

参数：

• buffer: Array<Byte> - 缓冲区，用于存放待读取的数据。

返回值：

• T - T 值。

异常：

• IllegalArgumentException - 当 buffer 太小，不足以读出 T 值时，抛出异常。

func writeBigEndian(Array<Byte>)

func writeBigEndian(buffer: Array<Byte>): Int64

功能：将 T 值以大端序的方式写入字节数组中。

参数：

• buffer: Array<Byte> - 缓冲区，用于存放待写入的数据。

返回值：

• Int64 - 写入的数据的字节数。

异常：

• IllegalArgumentException - 当 buffer 太小，不足以存储 T 值时，抛出异常。

extend Bool <: BigEndianOrder<Bool>

extend Bool <: BigEndianOrder<Bool>

功能：为 Bool 扩展 BigEndianOrder 接口，以实现将 Bool 值和大端序字节序列的转换。

父类型：

• BigEndianOrder<Bool>

static func readBigEndian(Array<Byte>)

public static func readBigEndian(buffer: Array<Byte>): Bool

功能：从字节数组中以大端序的方式读取一个 Bool 值。

参数：

• buffer: Array<Byte> - 缓冲区，用于存放待读取的数据。

返回值：

• Bool - Bool 值。

异常：

• IllegalArgumentException - 当 buffer 太小，不足以读出 Bool 值时，抛出异常。

示例：

import std.binary.*
import std.unittest.*
import std.unittest.testmacro.*

main() {
    let buffer: Array<Byte> = [0x1]
    let n = Bool.readBigEndian(buffer)
    @Assert(n, true)
}

func writeBigEndian(Array<Byte>)

public func writeBigEndian(buffer: Array<Byte>): Int64

功能：将 Bool 值以大端序的方式写入字节数组中。

参数：

• buffer: Array<Byte> - 缓冲区，用于存放待写入的数据。

返回值：

• Int64 - 写入的数据的字节数。

异常：

• IllegalArgumentException - 当 buffer 太小，不足以存储 Bool 值时，抛出异常。

示例：

import std.binary.*
import std.unittest.*
import std.unittest.testmacro.*

main() {
    let buffer = Array<Byte>(8, repeat: 0)
    let n = true.writeBigEndian(buffer)
    @Assert(n, 1)
    @Assert(buffer[..n], [0x01u8])
}

extend Float16 <: BigEndianOrder<Float16>

extend Float16 <: BigEndianOrder<Float16>

功能：为 Float16 扩展 BigEndianOrder 接口，以实现将 Float16 值和大端序字节序列的转换。

父类型：

• BigEndianOrder<Float16>

static func readBigEndian(Array<Byte>)

public static func readBigEndian(buffer: Array<Byte>): Float16

功能：从字节数组中以大端序的方式读取一个 Float16 值。

参数：

• buffer: Array<Byte> - 缓冲区，用于存放待读取的数据。

返回值：

• Float16 - Float16 值。

异常：

• IllegalArgumentException - 当 buffer 太小，不足以读出 Float16 值时，抛出异常。

示例：

import std.binary.*
import std.unittest.*
import std.unittest.testmacro.*

main() {
    let buffer: Array<Byte> = [0x4A, 0x40]
    let n = Float16.readBigEndian(buffer)
    @Assert(n, 12.5)
}

func writeBigEndian(Array<Byte>)

public func writeBigEndian(buffer: Array<Byte>): Int64

功能：将 Float16 值以大端序的方式写入字节数组中。

参数：

• buffer: Array<Byte> - 缓冲区，用于存放待写入的数据。

返回值：

• Int64 - 写入的数据的字节数。

异常：

• IllegalArgumentException - 当 buffer 太小，不足以存储 Float16 值时，抛出异常。

示例：

import std.binary.*
import std.unittest.*
import std.unittest.testmacro.*

main() {
    let buffer = Array<Byte>(8, repeat: 0)
    let n = 12.5f16.writeBigEndian(buffer)
    @Assert(n, 2)
    @Assert(buffer[..n], [0x4A, 0x40])
}

extend Float32 <: BigEndianOrder<Float32>

extend Float32 <: BigEndianOrder<Float32>

功能：为 Float32 扩展 BigEndianOrder 接口，以实现将 Float32 值和大端序字节序列的转换。

父类型：

• BigEndianOrder<Float32>

static func readBigEndian(Array<Byte>)

public static func readBigEndian(buffer: Array<Byte>): Float32

功能：从字节数组中以大端序的方式读取一个 Float32 值。

参数：

• buffer: Array<Byte> - 缓冲区，用于存放待读取的数据。

返回值：

• Float32 - Float32 值。

异常：

• IllegalArgumentException - 当 buffer 太小，不足以读出 Float32 值时，抛出异常。

示例：

import std.binary.*
import std.unittest.*
import std.unittest.testmacro.*

main() {
    let buffer: Array<Byte> = [0x41, 0x48, 0x00, 0x00]
    let n = Float32.readBigEndian(buffer)
    @Assert(n, 12.5)
}

func writeBigEndian(Array<Byte>)

public func writeBigEndian(buffer: Array<Byte>): Int64

功能：将 Float32 值以大端序的方式写入字节数组中。

参数：

• buffer: Array<Byte> - 缓冲区，用于存放待写入的数据。

返回值：

• Int64 - 写入的数据的字节数。

异常：

• IllegalArgumentException - 当 buffer 太小，不足以存储 Float32 值时，抛出异常。

示例：

import std.binary.*
import std.unittest.*
import std.unittest.testmacro.*

main() {
    let buffer = Array<Byte>(8, repeat: 0)
    let n = 12.5f32.writeBigEndian(buffer)
    @Assert(n, 4)
    @Assert(buffer[..n], [0x41, 0x48, 0x00, 0x00])
}

extend Float64 <: BigEndianOrder<Float64>

extend Float64 <: BigEndianOrder<Float64>

功能：为 Float64 扩展 BigEndianOrder 接口，以实现将 Float64 值和大端序字节序列的转换。

父类型：

• BigEndianOrder<Float64>

static func readBigEndian(Array<Byte>)

public static func readBigEndian(buffer: Array<Byte>): Float64

功能：从字节数组中以大端序的方式读取一个 Float64 值。

参数：

• buffer: Array<Byte> - 缓冲区，用于存放待读取的数据。

返回值：

• Float64 - Float64 值。

异常：

• IllegalArgumentException - 当 buffer 太小，不足以读出 Float64 值时，抛出异常。

示例：

import std.binary.*
import std.unittest.*
import std.unittest.testmacro.*

main() {
    let buffer: Array<Byte> = [0x40, 0x29, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]
    let n = Float64.readBigEndian(buffer)
    @Assert(n, 12.5)
}

func writeBigEndian(Array<Byte>)

public func writeBigEndian(buffer: Array<Byte>): Int64

功能：将 Float64 值以大端序的方式写入字节数组中。

参数：

• buffer: Array<Byte> - 缓冲区，用于存放待写入的数据。

返回值：

• Int64 - 写入的数据的字节数。

异常：

• IllegalArgumentException - 当 buffer 太小，不足以存储 Float64 值时，抛出异常。

示例：

import std.binary.*
import std.unittest.*
import std.unittest.testmacro.*

main() {
    let buffer = Array<Byte>(8, repeat: 0)
    let n = 12.5f64.writeBigEndian(buffer)
    @Assert(n, 8)
    @Assert(buffer[..n], [0x40, 0x29, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
}

extend Int16 <: BigEndianOrder<Int16>

extend Int16 <: BigEndianOrder<Int16>

功能：为 Int16 扩展 BigEndianOrder 接口，以实现将 Int16 值和大端序字节序列的转换。

父类型：

• BigEndianOrder<Int16>

static func readBigEndian(Array<Byte>)

public static func readBigEndian(buffer: Array<Byte>): Int16

功能：从字节数组中以大端序的方式读取一个 Int16 值。

参数：

• buffer: Array<Byte> - 缓冲区，用于存放待读取的数据。

返回值：

• Int16 - Int16 值。

异常：

• IllegalArgumentException - 当 buffer 太小，不足以读出 Int16 值时，抛出异常。

示例：

import std.binary.*
import std.unittest.*
import std.unittest.testmacro.*

main() {
    let buffer: Array<Byte> = [0x12, 0x34]
    let n = Int16.readBigEndian(buffer)
    @Assert(n, 0x1234)
}

func writeBigEndian(Array<Byte>)

public func writeBigEndian(buffer: Array<Byte>): Int64

功能：将 Int16 值以大端序的方式写入字节数组中。

参数：

• buffer: Array<Byte> - 缓冲区，用于存放待写入的数据。

返回值：

• Int64 - 写入的数据的字节数。

异常：

• IllegalArgumentException - 当 buffer 太小，不足以存储 Int16 值时，抛出异常。

示例：

import std.binary.*
import std.unittest.*
import std.unittest.testmacro.*

main() {
    let buffer = Array<Byte>(8, repeat: 0)
    let n = 0x1234i16.writeBigEndian(buffer)
    @Assert(n, 2)
    @Assert(buffer[..n], [0x12, 0x34])
}

extend Int32 <: BigEndianOrder<Int32>

extend Int32 <: BigEndianOrder<Int32>

功能：为 Int32 扩展 BigEndianOrder 接口，以实现将 Int32 值和大端序字节序列的转换。

父类型：

• BigEndianOrder<Int32>

static func readBigEndian(Array<Byte>)

public static func readBigEndian(buffer: Array<Byte>): Int32

功能：从字节数组中以大端序的方式读取一个 Int32 值。

参数：

• buffer: Array<Byte> - 缓冲区，用于存放待读取的数据。

返回值：

• Int32 - Int32 值。

异常：

• IllegalArgumentException - 当 buffer 太小，不足以读出 Int32 值时，抛出异常。

示例：

import std.binary.*
import std.unittest.*
import std.unittest.testmacro.*

main() {
    let buffer: Array<Byte> = [0x12, 0x34, 0x56, 0x78]
    let n = Int32.readBigEndian(buffer)
    @Assert(n, 0x12345678)
}

func writeBigEndian(Array<Byte>)

public func writeBigEndian(buffer: Array<Byte>): Int64

功能：将 Int32 值以大端序的方式写入字节数组中。

参数：

• buffer: Array<Byte> - 缓冲区，用于存放待写入的数据。

返回值：

• Int64 - 写入的数据的字节数。

异常：

• IllegalArgumentException - 当 buffer 太小，不足以存储 Int32 值时，抛出异常。

示例：

import std.binary.*
import std.unittest.*
import std.unittest.testmacro.*

main() {
    let buffer = Array<Byte>(8, repeat: 0)
    let n = 0x12345678i32.writeBigEndian(buffer)
    @Assert(n, 4)
    @Assert(buffer[..n], [0x12, 0x34, 0x56, 0x78])
}

extend Int64 <: BigEndianOrder<Int64>

extend Int64 <: BigEndianOrder<Int64>

功能：为 Int64 扩展 BigEndianOrder 接口，以实现将 Int64 值和大端序字节序列的转换。

父类型：

• BigEndianOrder<Int64>

static func readBigEndian(Array<Byte>)

public static func readBigEndian(buffer: Array<Byte>): Int64

功能：从字节数组中以大端序的方式读取一个 Int64 值。

参数：

• buffer: Array<Byte> - 缓冲区，用于存放待读取的数据。

返回值：

• Int64 - Int64 值。

异常：

• IllegalArgumentException - 当 buffer 太小，不足以读出 Int64 值时，抛出异常。

示例：

import std.binary.*
import std.unittest.*
import std.unittest.testmacro.*

main() {
    let buffer: Array<Byte> = [0x12, 0x34, 0x56, 0x78, 0x90, 0x12, 0x34, 0x56]
    let n = Int64.readBigEndian(buffer)
    @Assert(n, 0x1234567890123456)
}

func writeBigEndian(Array<Byte>)

public func writeBigEndian(buffer: Array<Byte>): Int64

功能：将 Int64 值以大端序的方式写入字节数组中。

参数：

• buffer: Array<Byte> - 缓冲区，用于存放待写入的数据。

返回值：

• Int64 - 写入的数据的字节数。

异常：

• IllegalArgumentException - 当 buffer 太小，不足以存储 Int64 值时，抛出异常。

示例：

import std.binary.*
import std.unittest.*
import std.unittest.testmacro.*

main() {
    let buffer = Array<Byte>(8, repeat: 0)
    let n = 0x1234567890123456i64.writeBigEndian(buffer)
    @Assert(n, 8)
    @Assert(buffer[..n], [0x12, 0x34, 0x56, 0x78, 0x90, 0x12, 0x34, 0x56])
}

extend Int8 <: BigEndianOrder<Int8>

extend Int8 <: BigEndianOrder<Int8>

功能：为 Int8 扩展 BigEndianOrder 接口，以实现将 Int8 值和大端序字节序列的转换。

父类型：

• BigEndianOrder<Int8>

static func readBigEndian(Array<Byte>)

public static func readBigEndian(buffer: Array<Byte>): Int8

功能：从字节数组中以大端序的方式读取一个 Int8 值。

参数：

• buffer: Array<Byte> - 缓冲区，用于存放待读取的数据。

返回值：

• Int8 - Int8 值。

异常：

• IllegalArgumentException - 当 buffer 太小，不足以读出 Int8 值时，抛出异常。

示例：

import std.binary.*
import std.unittest.*
import std.unittest.testmacro.*

main() {
    let buffer: Array<Byte> = [0x12]
    let n = Int8.readBigEndian(buffer)
    @Assert(n, 0x12)
}

func writeBigEndian(Array<Byte>)

public func writeBigEndian(buffer: Array<Byte>): Int64

功能：将 Int8 值以大端序的方式写入字节数组中。

参数：

• buffer: Array<Byte> - 缓冲区，用于存放待写入的数据。

返回值：

• Int64 - 写入的数据的字节数。

异常：

• IllegalArgumentException - 当 buffer 太小，不足以存储 Int8 值时，抛出异常。

示例：

import std.binary.*
import std.unittest.*
import std.unittest.testmacro.*

main() {
    let buffer = Array<Byte>(8, repeat: 0)
    let n = 0x12i8.writeBigEndian(buffer)
    @Assert(n, 1)
    @Assert(buffer[..n], [0x12])
}

extend UInt16 <: BigEndianOrder<UInt16>

extend UInt16 <: BigEndianOrder<UInt16>

功能：为 UInt16 扩展 BigEndianOrder 接口，以实现将 UInt16 值和大端序字节序列的转换。

父类型：

• BigEndianOrder<UInt16>

static func readBigEndian(Array<Byte>)

public static func readBigEndian(buffer: Array<Byte>): UInt16

功能：从字节数组中以大端序的方式读取一个 UInt16 值。

参数：

• buffer: Array<Byte> - 缓冲区，用于存放待读取的数据。

返回值：

• UInt16 - UInt16 值。

异常：

• IllegalArgumentException - 当 buffer 太小，不足以读出 UInt16 值时，抛出异常。

示例：

import std.binary.*
import std.unittest.*
import std.unittest.testmacro.*

main() {
    let buffer: Array<Byte> = [0x12, 0x34]
    let n = UInt16.readBigEndian(buffer)
    @Assert(n, 0x1234)
}

func writeBigEndian(Array<Byte>)

public func writeBigEndian(buffer: Array<Byte>): Int64

功能：将 UInt16 值以大端序的方式写入字节数组中。

参数：

• buffer: Array<Byte> - 缓冲区，用于存放待写入的数据。

返回值：

• Int64 - 写入的数据的字节数。

异常：

• IllegalArgumentException - 当 buffer 太小，不足以存储 UInt16 值时，抛出异常。

示例：

import std.binary.*
import std.unittest.*
import std.unittest.testmacro.*

main() {
    let buffer = Array<Byte>(8, repeat: 0)
    let n = 0x1234u16.writeBigEndian(buffer)
    @Assert(n, 2)
    @Assert(buffer[..n], [0x12, 0x34])
}

extend UInt32 <: BigEndianOrder<UInt32>

extend UInt32 <: BigEndianOrder<UInt32>

功能：为 UInt32 扩展 BigEndianOrder 接口，以实现将 UInt32 值和大端序字节序列的转换。

父类型：

• BigEndianOrder<UInt32>

static func readBigEndian(Array<Byte>)

public static func readBigEndian(buffer: Array<Byte>): UInt32

功能：从字节数组中以大端序的方式读取一个 UInt32 值。

参数：

• buffer: Array<Byte> - 缓冲区，用于存放待读取的数据。

返回值：

• UInt32 - UInt32 值。

异常：

• IllegalArgumentException - 当 buffer 太小，不足以读出 UInt32 值时，抛出异常。

示例：

import std.binary.*
import std.unittest.*
import std.unittest.testmacro.*

main() {
    let buffer: Array<Byte> = [0x12, 0x34, 0x56, 0x78]
    let n = UInt32.readBigEndian(buffer)
    @Assert(n, 0x12345678)
}

func writeBigEndian(Array<Byte>)

public func writeBigEndian(buffer: Array<Byte>): Int64

功能：将 UInt32 值以大端序的方式写入字节数组中。

参数：

• buffer: Array<Byte> - 缓冲区，用于存放待写入的数据。

返回值：

• Int64 - 写入的数据的字节数。

异常：

• IllegalArgumentException - 当 buffer 太小，不足以存储 UInt32 值时，抛出异常。

示例：

import std.binary.*
import std.unittest.*
import std.unittest.testmacro.*

main() {
    let buffer = Array<Byte>(8, repeat: 0)
    let n = 0x12345678u32.writeBigEndian(buffer)
    @Assert(n, 4)
    @Assert(buffer[..n], [0x12, 0x34, 0x56, 0x78])
}

extend UInt64 <: BigEndianOrder<UInt64>

extend UInt64 <: BigEndianOrder<UInt64>

功能：为 UInt64 扩展 BigEndianOrder 接口，以实现将 UInt64 值和大端序字节序列的转换。

父类型：

• BigEndianOrder<UInt64>

static func readBigEndian(Array<Byte>)

public static func readBigEndian(buffer: Array<Byte>): UInt64

功能：从字节数组中以大端序的方式读取一个 UInt64 值。

参数：

• buffer: Array<Byte> - 缓冲区，用于存放待读取的数据。

返回值：

• UInt64 - UInt64 值。

异常：

• IllegalArgumentException - 当 buffer 太小，不足以读出 UInt64 值时，抛出异常。

示例：

import std.binary.*
import std.unittest.*
import std.unittest.testmacro.*

main() {
    let buffer: Array<Byte> = [0x12, 0x34, 0x56, 0x78, 0x90, 0x12, 0x34, 0x56]
    let n = UInt64.readBigEndian(buffer)
    @Assert(n, 0x1234567890123456)
}

func writeBigEndian(Array<Byte>)

public func writeBigEndian(buffer: Array<Byte>): Int64

功能：将 UInt64 值以大端序的方式写入字节数组中。

参数：

• buffer: Array<Byte> - 缓冲区，用于存放待写入的数据。

返回值：

• Int64 - 写入的数据的字节数。

异常：

• IllegalArgumentException - 当 buffer 太小，不足以存储 UInt64 值时，抛出异常。

示例：

import std.binary.*
import std.unittest.*
import std.unittest.testmacro.*

main() {
    let buffer = Array<Byte>(8, repeat: 0)
    let n = 0x1234567890123456u64.writeBigEndian(buffer)
    @Assert(n, 8)
    @Assert(buffer[..n], [0x12, 0x34, 0x56, 0x78, 0x90, 0x12, 0x34, 0x56])
}

extend UInt8 <: BigEndianOrder<UInt8>

extend UInt8 <: BigEndianOrder<UInt8>

功能：为 UInt8 扩展 BigEndianOrder 接口，以实现将 UInt8 值和大端序字节序列的转换。

父类型：

• BigEndianOrder<UInt8>

static func readBigEndian(Array<Byte>)

public static func readBigEndian(buffer: Array<Byte>): UInt8

功能：从字节数组中以大端序的方式读取一个 UInt8 值。

参数：

• buffer: Array<Byte> - 缓冲区，用于存放待读取的数据。

返回值：

• UInt8 - UInt8 值。

异常：

• IllegalArgumentException - 当 buffer 太小，不足以读出 UInt8 值时，抛出异常。

示例：

import std.binary.*
import std.unittest.*
import std.unittest.testmacro.*

main() {
    let buffer: Array<Byte> = [0x12]
    let n = UInt8.readBigEndian(buffer)
    @Assert(n, 0x12)
}

func writeBigEndian(Array<Byte>)

public func writeBigEndian(buffer: Array<Byte>): Int64

功能：将 UInt8 值以大端序的方式写入字节数组中。

参数：

• buffer: Array<Byte> - 缓冲区，用于存放待写入的数据。

返回值：

• Int64 - 写入的数据的字节数。

异常：

• IllegalArgumentException - 当 buffer 太小，不足以存储 UInt8 值时，抛出异常。

示例：

import std.binary.*
import std.unittest.*
import std.unittest.testmacro.*

main() {
    let buffer = Array<Byte>(8, repeat: 0)
    let n = 0x12u8.writeBigEndian(buffer)
    @Assert(n, 1)
    @Assert(buffer[..n], [0x12])
}

interface LittleEndianOrder<T>

public interface LittleEndianOrder<T> {
    func writeLittleEndian(buffer: Array<Byte>): Int64
    static func readLittleEndian(buffer: Array<Byte>): T
}

功能：小端序字节序列转换接口。

static func readLittleEndian(Array<Byte>)

static func readLittleEndian(buffer: Array<Byte>): T

功能：从字节数组中以小端序的方式读取一个 T 值。

参数：

• buffer: Array<Byte> - 缓冲区，用于存放待读取的数据。

返回值：

• T - T 值。

异常：

• IllegalArgumentException - 当 buffer 太小，不足以读出 T 值时，抛出异常。

func writeLittleEndian(Array<Byte>)

func writeLittleEndian(buffer: Array<Byte>): Int64

功能：将 T 值以小端序的方式写入字节数组中。

参数：

• buffer: Array<Byte> - 缓冲区，用于存放待写入的数据。

返回值：

• Int64 - 写入的数据的字节数。

异常：

• IllegalArgumentException - 当 buffer 太小，不足以存储 T 值时，抛出异常。

extend Bool <: LittleEndianOrder<Bool>

extend Bool <: LittleEndianOrder<Bool>

功能：为 Bool 扩展 LittleEndianOrder 接口，以实现将 Bool 值和小端序字节序列的转换。

父类型：

• LittleEndianOrder<Bool>

static func readLittleEndian(Array<Byte>)

public static func readLittleEndian(buffer: Array<Byte>): Bool

功能：从字节数组中以小端序的方式读取一个 Bool 值。

参数：

• buffer: Array<Byte> - 缓冲区，用于存放待读取的数据。

返回值：

• Bool - Bool 值。

异常：

• IllegalArgumentException - 当 buffer 太小，不足以读出 Bool 值时，抛出异常。

示例：

import std.binary.*
import std.unittest.*
import std.unittest.testmacro.*

main() {
    let buffer: Array<Byte> = [0x1]
    let n = Bool.readLittleEndian(buffer)
    @Assert(n, true)
}

func writeLittleEndian(Array<Byte>)

public func writeLittleEndian(buffer: Array<Byte>): Int64

功能：将 Bool 值以小端序的方式写入字节数组中。

参数：

• buffer: Array<Byte> - 缓冲区，用于存放待写入的数据。

返回值：

• Int64 - 写入的数据的字节数。

异常：

• IllegalArgumentException - 当 buffer 太小，不足以存储 Bool 值时，抛出异常。

示例：

import std.binary.*
import std.unittest.*
import std.unittest.testmacro.*

main() {
    let buffer = Array<Byte>(8, repeat: 0)
    let n = true.writeLittleEndian(buffer)
    @Assert(n, 1)
    @Assert(buffer[..n], [0x01])
}

extend Float16 <: LittleEndianOrder<Float16>

extend Float16 <: LittleEndianOrder<Float16>

功能：为 Float16 扩展 LittleEndianOrder 接口，以实现将 Float16 值和小端序字节序列的转换。

父类型：

• LittleEndianOrder<Float16>

static func readLittleEndian(Array<Byte>)

public static func readLittleEndian(buffer: Array<Byte>): Float16

功能：从字节数组中以小端序的方式读取一个 Float16 值。

参数：

• buffer: Array<Byte> - 缓冲区，用于存放待读取的数据。

返回值：

• Float16 - Float16 值。

异常：

• IllegalArgumentException - 当 buffer 太小，不足以读出 Float16 值时，抛出异常。

示例：

import std.binary.*
import std.unittest.*
import std.unittest.testmacro.*

main() {
    let buffer: Array<Byte> = [0x40, 0x4A]
    let n = Float16.readLittleEndian(buffer)
    @Assert(n, 12.5)
}

func writeLittleEndian(Array<Byte>)

public func writeLittleEndian(buffer: Array<Byte>): Int64

功能：将 Float16 值以小端序的方式写入字节数组中。

参数：

• buffer: Array<Byte> - 缓冲区，用于存放待写入的数据。

返回值：

• Int64 - 写入的数据的字节数。

异常：

• IllegalArgumentException - 当 buffer 太小，不足以存储 Float16 值时，抛出异常。

示例：

import std.binary.*
import std.unittest.*
import std.unittest.testmacro.*

main() {
    let buffer = Array<Byte>(8, repeat: 0)
    let n = 12.5f16.writeLittleEndian(buffer)
    @Assert(n, 2)
    @Assert(buffer[..n], [0x40, 0x4A])
}

extend Float32 <: LittleEndianOrder<Float32>

extend Float32  <: LittleEndianOrder<Float32>

功能：为 Float32 扩展 LittleEndianOrder 接口，以实现将 Float32 值和小端序字节序列的转换。

父类型：

• LittleEndianOrder<Float32>

static func readLittleEndian(Array<Byte>)

public static func readLittleEndian(buffer: Array<Byte>): Float32

功能：从字节数组中以小端序的方式读取一个 Float32 值。

参数：

• buffer: Array<Byte> - 缓冲区，用于存放待读取的数据。

返回值：

• Float32 - Float32 值。

异常：

• IllegalArgumentException - 当 buffer 太小，不足以读出 Float32 值时，抛出异常。

示例：

import std.binary.*
import std.unittest.*
import std.unittest.testmacro.*

main() {
    let buffer: Array<Byte> = [0x00, 0x00, 0x48, 0x41]
    let n = Float32.readLittleEndian(buffer)
    @Assert(n, 12.5)
}

func writeLittleEndian(Array<Byte>)

public func writeLittleEndian(buffer: Array<Byte>): Int64

功能：将 Float32 值以小端序的方式写入字节数组中。

参数：

• buffer: Array<Byte> - 缓冲区，用于存放待写入的数据。

返回值：

• Int64 - 写入的数据的字节数。

异常：

• IllegalArgumentException - 当 buffer 太小，不足以存储 Float32 值时，抛出异常。

示例：

import std.binary.*
import std.unittest.*
import std.unittest.testmacro.*

main() {
    let buffer = Array<Byte>(8, repeat: 0)
    let n = 12.5f32.writeLittleEndian(buffer)
    @Assert(n, 4)
    @Assert(buffer[..n], [0x00, 0x00, 0x48, 0x41])
}

extend Float64 <: LittleEndianOrder<Float64>

extend Float64 <: LittleEndianOrder<Float64>

功能：为 Float64 扩展 LittleEndianOrder 接口，以实现将 Float64 值和小端序字节序列的转换。

父类型：

• LittleEndianOrder<Float64>

static func readLittleEndian(Array<Byte>)

public static func readLittleEndian(buffer: Array<Byte>): Float64

功能：从字节数组中以小端序的方式读取一个 Float64 值。

参数：

• buffer: Array<Byte> - 缓冲区，用于存放待读取的数据。

返回值：

• Float64 - Float64 值。

异常：

• IllegalArgumentException - 当 buffer 太小，不足以读出 Float64 值时，抛出异常。

示例：

import std.binary.*
import std.unittest.*
import std.unittest.testmacro.*

main() {
    let buffer: Array<Byte> = [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x29, 0x40]
    let n = Float64.readLittleEndian(buffer)
    @Assert(n, 12.5)
}

func writeLittleEndian(Array<Byte>)

public func writeLittleEndian(buffer: Array<Byte>): Int64

功能：将 Float64 值以小端序的方式写入字节数组中。

参数：

• buffer: Array<Byte> - 缓冲区，用于存放待写入的数据。

返回值：

• Int64 - 写入的数据的字节数。

异常：

• IllegalArgumentException - 当 buffer 太小，不足以存储 Float64 值时，抛出异常。

示例：

import std.binary.*
import std.unittest.*
import std.unittest.testmacro.*

main() {
    let buffer = Array<Byte>(8, repeat: 0)
    let n = 12.5f64.writeLittleEndian(buffer)
    @Assert(n, 8)
    @Assert(buffer[..n], [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x29, 0x40])
}

extend Int16 <: LittleEndianOrder<Int16>

extend Int16 <: LittleEndianOrder<Int16>

功能：为 Int16 扩展 LittleEndianOrder 接口，以实现将 Int16 值和小端序字节序列的转换。

父类型：

• LittleEndianOrder<Int16>

static func readLittleEndian(Array<Byte>)

public static func readLittleEndian(buffer: Array<Byte>): Int16

功能：从字节数组中以小端序的方式读取一个 Int16 值。

参数：

• buffer: Array<Byte> - 缓冲区，用于存放待读取的数据。

返回值：

• Int16 - Int16 值。

异常：

• IllegalArgumentException - 当 buffer 太小，不足以读出 Int16 值时，抛出异常。

示例：

import std.binary.*
import std.unittest.*
import std.unittest.testmacro.*

main() {
    let buffer: Array<Byte> = [0x34, 0x12]
    let n = Int16.readLittleEndian(buffer)
    @Assert(n, 0x1234i16)
}

func writeLittleEndian(Array<Byte>)

public func writeLittleEndian(buffer: Array<Byte>): Int64

功能：将 Int16 值以小端序的方式写入字节数组中。

参数：

• buffer: Array<Byte> - 缓冲区，用于存放待写入的数据。

返回值：

• Int64 - 写入的数据的字节数。

异常：

• IllegalArgumentException - 当 buffer 太小，不足以存储 Int16 值时，抛出异常。

示例：

import std.binary.*
import std.unittest.*
import std.unittest.testmacro.*

main() {
    let buffer = Array<Byte>(8, repeat: 0)
    let n = 0x1234i16.writeLittleEndian(buffer)
    @Assert(n, 2)
    @Assert(buffer[..n], [0x34, 0x12])
}

extend Int32 <: LittleEndianOrder<Int32>

extend Int32 <: LittleEndianOrder<Int32>

功能：为 Int32 扩展 LittleEndianOrder 接口，以实现将 Int32 值和小端序字节序列的转换。

父类型：

• LittleEndianOrder<Int32>

static func readLittleEndian(Array<Byte>)

public static func readLittleEndian(buffer: Array<Byte>): Int32

功能：从字节数组中以小端序的方式读取一个 Int32 值。

参数：

• buffer: Array<Byte> - 缓冲区，用于存放待读取的数据。

返回值：

• Int32 - Int32 值。

异常：

• IllegalArgumentException - 当 buffer 太小，不足以读出 Int32 值时，抛出异常。

示例：

import std.binary.*
import std.unittest.*
import std.unittest.testmacro.*

main() {
    let buffer: Array<Byte> = [0x78, 0x56, 0x34, 0x12]
    let n = Int32.readLittleEndian(buffer)
    @Assert(n, 0x12345678i32)
}

func writeLittleEndian(Array<Byte>)

public func writeLittleEndian(buffer: Array<Byte>): Int64

功能：将 Int32 值以小端序的方式写入字节数组中。

参数：

• buffer: Array<Byte> - 缓冲区，用于存放待写入的数据。

返回值：

• Int64 - 写入的数据的字节数。

异常：

• IllegalArgumentException - 当 buffer 太小，不足以存储 Int32 值时，抛出异常。

示例：

import std.binary.*
import std.unittest.*
import std.unittest.testmacro.*

main() {
    let buffer = Array<Byte>(8, repeat: 0)
    let n = 0x12345678i32.writeLittleEndian(buffer)
    @Assert(n, 4)
    @Assert(buffer[..n], [0x78, 0x56, 0x34, 0x12])
}

extend Int64 <: LittleEndianOrder<Int64>

extend Int64 <: LittleEndianOrder<Int64>

功能：为 Int64 扩展 LittleEndianOrder 接口，以实现将 Int64 值和小端序字节序列的转换。

父类型：

• LittleEndianOrder<Int64>

static func readLittleEndian(Array<Byte>)

public static func readLittleEndian(buffer: Array<Byte>): Int64

功能：从字节数组中以小端序的方式读取一个 Int64 值。

参数：

• buffer: Array<Byte> - 缓冲区，用于存放待读取的数据。

返回值：

• Int64 - Int64 值。

异常：

• IllegalArgumentException - 当 buffer 太小，不足以读出 Int64 值时，抛出异常。

示例：

import std.binary.*
import std.unittest.*
import std.unittest.testmacro.*

main() {
    let buffer: Array<Byte> = [0x56, 0x34, 0x12, 0x90, 0x78, 0x56, 0x34, 0x12]
    let n = Int64.readLittleEndian(buffer)
    @Assert(n, 0x1234567890123456i64)
}

func writeLittleEndian(Array<Byte>)

public func writeLittleEndian(buffer: Array<Byte>): Int64

功能：将 Int64 值以小端序的方式写入字节数组中。

参数：

• buffer: Array<Byte> - 缓冲区，用于存放待写入的数据。

返回值：

• Int64 - 写入的数据的字节数。

异常：

• IllegalArgumentException - 当 buffer 太小，不足以存储 Int64 值时，抛出异常。

示例：

import std.binary.*
import std.unittest.*
import std.unittest.testmacro.*

main() {
    let buffer = Array<Byte>(8, repeat: 0)
    let n = 0x1234567890123456i64.writeLittleEndian(buffer)
    @Assert(n, 8)
    @Assert(buffer[..n], [0x56, 0x34, 0x12, 0x90, 0x78, 0x56, 0x34, 0x12])
}

extend Int8 <: LittleEndianOrder<Int8>

extend Int8 <: LittleEndianOrder<Int8>

功能：为 Int8 扩展 LittleEndianOrder 接口，以实现将 Int8 值和小端序字节序列的转换。

父类型：

• LittleEndianOrder<Int8>

static func readLittleEndian(Array<Byte>)

public static func readLittleEndian(buffer: Array<Byte>): Int8

功能：从字节数组中以小端序的方式读取一个 Int8 值。

参数：

• buffer: Array<Byte> - 缓冲区，用于存放待读取的数据。

返回值：

• Int8 - Int8 值。

异常：

• IllegalArgumentException - 当 buffer 太小，不足以读出 Int8 值时，抛出异常。

示例：

import std.binary.*
import std.unittest.*
import std.unittest.testmacro.*

main() {
    let buffer: Array<Byte> = [0x12]
    let n = Int8.readLittleEndian(buffer)
    @Assert(n, 0x12)
}

func writeLittleEndian(Array<Byte>)

public func writeLittleEndian(buffer: Array<Byte>): Int64

功能：将 Int8 值以小端序的方式写入字节数组中。

参数：

• buffer: Array<Byte> - 缓冲区，用于存放待写入的数据。

返回值：

• Int64 - 写入的数据的字节数。

异常：

• IllegalArgumentException - 当 buffer 太小，不足以存储 Int8 值时，抛出异常。

示例：

import std.binary.*
import std.unittest.*
import std.unittest.testmacro.*

main() {
    let buffer = Array<Byte>(8, repeat: 0)
    let n = 0x12i8.writeLittleEndian(buffer)
    @Assert(n, 1)
    @Assert(buffer[..n], [0x12])
}

extend UInt16 <: LittleEndianOrder<UInt16>

extend UInt16 <: LittleEndianOrder<UInt16>

功能：为 UInt16 扩展 LittleEndianOrder 接口，以实现将 UInt16 值和小端序字节序列的转换。

父类型：

• LittleEndianOrder<UInt16>

static func readLittleEndian(Array<Byte>)

public static func readLittleEndian(buffer: Array<Byte>): UInt16

功能：从字节数组中以小端序的方式读取一个 UInt16 值。

参数：

• buffer: Array<Byte> - 缓冲区，用于存放待读取的数据。

返回值：

• UInt16 - UInt16 值。

异常：

• IllegalArgumentException - 当 buffer 太小，不足以读出 UInt16 值时，抛出异常。

示例：

import std.binary.*
import std.unittest.*
import std.unittest.testmacro.*

main() {
    let buffer: Array<Byte> = [0x34, 0x12]
    let n = UInt16.readLittleEndian(buffer)
    @Assert(n, 0x1234u16)
}

func writeLittleEndian(Array<Byte>)

public func writeLittleEndian(buffer: Array<Byte>): Int64

功能：将 UInt16 值以小端序的方式写入字节数组中。

参数：

• buffer: Array<Byte> - 缓冲区，用于存放待写入的数据。

返回值：

• Int64 - 写入的数据的字节数。

异常：

• IllegalArgumentException - 当 buffer 太小，不足以存储 UInt16 值时，抛出异常。

示例：

import std.binary.*
import std.unittest.*
import std.unittest.testmacro.*

main() {
    let buffer = Array<Byte>(8, repeat: 0)
    let n = 0x1234u16.writeLittleEndian(buffer)
    @Assert(n, 2)
    @Assert(buffer[..n], [0x34, 0x12])
}

extend UInt32 <: LittleEndianOrder<UInt32>

extend UInt32 <: LittleEndianOrder<UInt32>

功能：为 UInt32 扩展 LittleEndianOrder 接口，以实现将 UInt32 值和小端序字节序列的转换。

父类型：

• LittleEndianOrder<UInt32>

static func readLittleEndian(Array<Byte>)

public static func readLittleEndian(buffer: Array<Byte>): UInt32

功能：从字节数组中以小端序的方式读取一个 UInt32 值。

参数：

• buffer: Array<Byte> - 缓冲区，用于存放待读取的数据。

返回值：

• UInt32 - UInt32 值。

异常：

• IllegalArgumentException - 当 buffer 太小，不足以读出 UInt32 值时，抛出异常。

示例：

import std.binary.*
import std.unittest.*
import std.unittest.testmacro.*

main() {
    let buffer: Array<Byte> = [0x78, 0x56, 0x34, 0x12]
    let n = UInt32.readLittleEndian(buffer)
    @Assert(n, 0x12345678i32)
}

func writeLittleEndian(Array<Byte>)

public func writeLittleEndian(buffer: Array<Byte>): Int64

功能：将 UInt32 值以小端序的方式写入字节数组中。

参数：

• buffer: Array<Byte> - 缓冲区，用于存放待写入的数据。

返回值：

• Int64 - 写入的数据的字节数。

异常：

• IllegalArgumentException - 当 buffer 太小，不足以存储 UInt32 值时，抛出异常。

示例：

import std.binary.*
import std.unittest.*
import std.unittest.testmacro.*

main() {
    let buffer = Array<Byte>(8, repeat: 0)
    let n = 0x12345678u32.writeLittleEndian(buffer)
    @Assert(n, 4)
    @Assert(buffer[..n], [0x78, 0x56, 0x34, 0x12])
}

extend UInt64 <: LittleEndianOrder<UInt64>

extend UInt64 <: LittleEndianOrder<UInt64>

功能：为 UInt64 扩展 LittleEndianOrder 接口，以实现将 UInt64 值和小端序字节序列的转换。

父类型：

• LittleEndianOrder<UInt64>

static func readLittleEndian(Array<Byte>)

public static func readLittleEndian(buffer: Array<Byte>): UInt64

功能：从字节数组中以小端序的方式读取一个 UInt64 值。

参数：

• buffer: Array<Byte> - 缓冲区，用于存放待读取的数据。

返回值：

• UInt64 - UInt64 值。

异常：

• IllegalArgumentException - 当 buffer 太小，不足以读出 UInt64 值时，抛出异常。

示例：

import std.binary.*
import std.unittest.*
import std.unittest.testmacro.*

main() {
    let buffer: Array<Byte> = [0x56, 0x34, 0x12, 0x90, 0x78, 0x56, 0x34, 0x12]
    let n = UInt64.readLittleEndian(buffer)
    @Assert(n, 0x1234567890123456i64)
}

func writeLittleEndian(Array<Byte>)

public func writeLittleEndian(buffer: Array<Byte>): Int64

功能：将 UInt64 值以小端序的方式写入字节数组中。

参数：

• buffer: Array<Byte> - 缓冲区，用于存放待写入的数据。

返回值：

• Int64 - 写入的数据的字节数。

异常：

• IllegalArgumentException - 当 buffer 太小，不足以存储 UInt64 值时，抛出异常。

示例：

import std.binary.*
import std.unittest.*
import std.unittest.testmacro.*

main() {
    let buffer = Array<Byte>(8, repeat: 0)
    let n = 0x1234567890123456u64.writeLittleEndian(buffer)
    @Assert(n, 8)
    @Assert(buffer[..n], [0x56, 0x34, 0x12, 0x90, 0x78, 0x56, 0x34, 0x12])
}

extend UInt8 <: LittleEndianOrder<UInt8>

extend UInt8 <: LittleEndianOrder<UInt8>

功能：为 UInt8 扩展 LittleEndianOrder 接口，以实现将 UInt8 值和小端序字节序列的转换。

父类型：

• LittleEndianOrder<UInt8>

static func readLittleEndian(Array<Byte>)

public static func readLittleEndian(buffer: Array<Byte>): UInt8

功能：从字节数组中以小端序的方式读取一个 UInt8 值。

参数：

• buffer: Array<Byte> - 缓冲区，用于存放待读取的数据。

返回值：

• UInt8 - UInt8 值。

异常：

• IllegalArgumentException - 当 buffer 太小，不足以读出 UInt8 值时，抛出异常。

示例：

import std.binary.*
import std.unittest.*
import std.unittest.testmacro.*

main() {
    let buffer: Array<Byte> = [0x12]
    let n = UInt8.readLittleEndian(buffer)
    @Assert(n, 0x12)
}

func writeLittleEndian(Array<Byte>)

public func writeLittleEndian(buffer: Array<Byte>): Int64

功能：将 UInt8 值以小端序的方式写入字节数组中。

参数：

• buffer: Array<Byte> - 缓冲区，用于存放待写入的数据。

返回值：

• Int64 - 写入的数据的字节数。

异常：

• IllegalArgumentException - 当 buffer 太小，不足以存储 UInt8 值时，抛出异常。

示例：

import std.binary.*
import std.unittest.*
import std.unittest.testmacro.*

main() {
    let buffer = Array<Byte>(8, repeat: 0)
    let n = 0x12u8.writeLittleEndian(buffer)
    @Assert(n, 1)
    @Assert(buffer[..n], [0x12])
}

interface SwapEndianOrder<T>

public interface SwapEndianOrder<T> {
    func swapBytes(): T
}

功能：反转字节顺序接口。

func swapBytes()

func swapBytes(): T

功能：反转 T 值的字节顺序。

返回值：

• T - T 值。

extend Int16 <: SwapEndianOrder<Int16>

extend Int16 <: SwapEndianOrder<Int16>

功能：为 Int16 扩展 SwapEndianOrder 接口，以实现将 Int16 值的字节顺序反转。

父类型：

• SwapEndianOrder<Int16>

func swapBytes()

public func swapBytes(): Int16

功能：反转 Int16 值的字节顺序。

返回值：

• Int16 - Int16 值。

示例：

import std.binary.*
import std.unittest.*
import std.unittest.testmacro.*

main() {
    let n = 0x1234i16
    let m = n.swapBytes()
    @Assert(m, 0x3412)
}

extend Int32 <: SwapEndianOrder<Int32>

extend Int32 <: SwapEndianOrder<Int32>

功能：为 Int32 扩展 SwapEndianOrder 接口，以实现将 Int32 值的字节顺序反转。

父类型：

• SwapEndianOrder<Int32>

func swapBytes()

public func swapBytes(): Int32

功能：反转 Int32 值的字节顺序。

返回值：

• Int32 - Int32 值。

示例：

import std.binary.*
import std.unittest.*
import std.unittest.testmacro.*

main() {
    let n = 0x12345678i32
    let m = n.swapBytes()
    @Assert(m, 0x78563412)
}

extend Int64 <: SwapEndianOrder<Int64>

extend Int64 <: SwapEndianOrder<Int64>

功能：为 Int64 扩展 SwapEndianOrder 接口，以实现将 Int64 值的字节顺序反转。

父类型：

• SwapEndianOrder<Int64>

func swapBytes()

public func swapBytes(): Int64

功能：反转 Int64 值的字节顺序。

返回值：

• Int64 - Int64 值。

示例：

import std.binary.*
import std.unittest.*
import std.unittest.testmacro.*

main() {
    let n = 0x1234567890123456i64
    let m = n.swapBytes()
    @Assert(m, 0x5634129078563412)
}

extend Int8 <: SwapEndianOrder<Int8>

extend Int8 <: SwapEndianOrder<Int8>

功能：为 Int8 扩展 SwapEndianOrder 接口，以实现将 Int8 值的字节顺序反转。

父类型：

• SwapEndianOrder<Int8>

func swapBytes()

public func swapBytes(): Int8

功能：反转 Int8 值的字节顺序。

返回值：

• Int8 - Int8 值。

示例：

import std.binary.*
import std.unittest.*
import std.unittest.testmacro.*

main() {
    let n = 0x12i8
    let m = n.swapBytes()
    @Assert(m, 0x12)
}

extend UInt16 <: SwapEndianOrder<UInt16>

extend UInt16 <: SwapEndianOrder<UInt16>

功能：为 UInt16 扩展 SwapEndianOrder 接口，以实现将 UInt16 值的字节顺序反转。

父类型：

• SwapEndianOrder<UInt16>

func swapBytes()

public func swapBytes(): UInt16

功能：反转 UInt16 值的字节顺序。

返回值：

• UInt16 - UInt16 值。

示例：

import std.binary.*
import std.unittest.*
import std.unittest.testmacro.*

main() {
    let n = 0x1234u16
    let m = n.swapBytes()
    @Assert(m, 0x3412)
}

extend UInt32 <: SwapEndianOrder<UInt32>

extend UInt32 <: SwapEndianOrder<UInt32>

功能：为 UInt32 扩展 SwapEndianOrder 接口，以实现将 UInt32 值的字节顺序反转。

父类型：

• SwapEndianOrder<UInt32>

func swapBytes()

public func swapBytes(): UInt32

功能：反转 UInt32 值的字节顺序。

返回值：

• UInt32 - UInt32 值。

示例：

import std.binary.*
import std.unittest.*
import std.unittest.testmacro.*

main() {
    let n = 0x12345678u32
    let m = n.swapBytes()
    @Assert(m, 0x78563412)
}

extend UInt64 <: SwapEndianOrder<UInt64>

extend UInt64 <: SwapEndianOrder<UInt64>

功能：为 UInt64 扩展 SwapEndianOrder 接口，以实现将 UInt64 值的字节顺序反转。

父类型：

• SwapEndianOrder<UInt64>

func swapBytes()

public func swapBytes(): UInt64

功能：反转 UInt64 值的字节顺序。

返回值：

• UInt64 - UInt64 值。

示例：

import std.binary.*
import std.unittest.*
import std.unittest.testmacro.*

main() {
    let n = 0x1234567890123456u64
    let m = n.swapBytes()
    @Assert(m, 0x5634129078563412)
}

extend UInt8 <: SwapEndianOrder<UInt8>

extend UInt8 <: SwapEndianOrder<UInt8>

功能：为 UInt8 扩展 SwapEndianOrder 接口，以实现将 UInt8 值的字节顺序反转。

父类型：

• SwapEndianOrder<UInt8>

func swapBytes()

public func swapBytes(): UInt8

功能：反转 UInt8 值的字节顺序。

返回值：

• UInt8 - UInt8 值。

示例：

import std.binary.*
import std.unittest.*
import std.unittest.testmacro.*

main() {
    let n = 0x12u8
    let m = n.swapBytes()
    @Assert(m, 0x12)
}