mirror of
https://github.com/vlang/v.git
synced 2025-09-14 15:02:33 +03:00
89 lines
2.1 KiB
Markdown
89 lines
2.1 KiB
Markdown
## Description
|
|
|
|
`encoding.binary` contains utility functions for converting between an array of bytes (`[]u8`)
|
|
and unsigned integers of various widths (`u16`, `u32`, and `u64`).
|
|
|
|
Also, it provide functions `encode_binary[T]()` and `decode_binary[T]()` which can converting
|
|
between an array of bytes (`[]u8`) and generic type `T`.
|
|
|
|
There are two ways in which bytes can be encoded:
|
|
|
|
1. Little endian: The least significant bytes are stored first, followed by the most
|
|
significant bytes.
|
|
2. Big endian: The most significant bytes are stored first, opposite to the little endian
|
|
convention.
|
|
|
|
For example, let us take the number `0x12345678`. In little endian, the bytes are extracted as
|
|
`0x78`, `0x56`, `0x34`, and `0x12`. In big endian, the bytes are `0x12`, `0x34`, `0x56`,
|
|
and `0x78`.
|
|
|
|
We follow a similar procedure when we want to go the other way around. Consider the second
|
|
sequence of bytes in the previous example: `0x12`, `0x34`, `0x56`, and `0x78`. If we encode
|
|
this sequence in little endian format, we get the integer `0x78563412`. If we encode this
|
|
sequence in big endian, we get `0x12345678`.
|
|
|
|
> **Note**
|
|
> The functions in this module assume appropriately sized u8 arrays. If the sizes
|
|
> are not valid, the functions will panic.
|
|
|
|
For generic `T` data encoding/decoding, you can use `encode_binary[T]()` and `decode_binary[T]()`:
|
|
|
|
```v
|
|
module main
|
|
|
|
import encoding.binary
|
|
|
|
struct MyStruct {
|
|
g_u8 u8
|
|
}
|
|
|
|
struct ComplexStruct {
|
|
mut:
|
|
f_u8 u8
|
|
f_u32 u32 @[serialize: '-'] // this field will be skipped
|
|
f_u64 u64
|
|
f_string string
|
|
f_structs []MyStruct
|
|
f_maps []map[string]string
|
|
}
|
|
|
|
fn main() {
|
|
a := ComplexStruct{
|
|
f_u8: u8(10)
|
|
f_u32: u32(1024)
|
|
f_u64: u64(2048)
|
|
f_string: 'serialize me'
|
|
f_structs: [
|
|
MyStruct{
|
|
g_u8: u8(1)
|
|
},
|
|
MyStruct{
|
|
g_u8: u8(2)
|
|
},
|
|
MyStruct{
|
|
g_u8: u8(3)
|
|
},
|
|
]
|
|
f_maps: [
|
|
{
|
|
'abc': 'def'
|
|
},
|
|
{
|
|
'123': '456'
|
|
},
|
|
{
|
|
',./': '!@#'
|
|
},
|
|
]
|
|
}
|
|
|
|
b := binary.encode_binary(a)!
|
|
mut c := binary.decode_binary[ComplexStruct](b)!
|
|
|
|
// because there skipped field in `a`, a != c
|
|
assert a != c
|
|
|
|
c.f_u32 = u32(1024)
|
|
assert a == c
|
|
}
|
|
```
|