diff --git a/.github/workflows/test.yaml b/.github/workflows/test.yaml
new file mode 100644
index 0000000..8a4dd9e
--- /dev/null
+++ b/.github/workflows/test.yaml
@@ -0,0 +1,20 @@
+on:
+ push:
+ branches: ["dev"]
+ pull_request:
+ branches: ["main"]
+name: Test
+jobs:
+ test:
+ strategy:
+ matrix:
+ go-version: [1.19.x, 1.20.x, 1.21.x, 1.22.x, 1.23.x]
+ os: [ubuntu-latest, macos-latest, windows-latest]
+ runs-on: ${{ matrix.os }}
+ steps:
+ - uses: actions/setup-go@v4
+ with:
+ go-version: "${{ matrix.go-version }}"
+ - uses: actions/checkout@v3
+ - name: Test
+ run: go mod tidy && go test -v ./...
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..d151c7c
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,27 @@
+# If you prefer the allow list template instead of the deny list, see community template:
+# https://github.com/github/gitignore/blob/main/community/Golang/Go.AllowList.gitignore
+#
+# Binaries for programs and plugins
+*.exe
+*.exe~
+*.dll
+*.so
+*.dylib
+
+# Test binary, built with `go test -c`
+*.test
+
+# Output of the go coverage tool, specifically when used with LiteIDE
+*.out
+
+# Dependency directories (remove the comment below to include it)
+# vendor/
+
+# Go workspace file
+# go.work
+go.work.sum
+
+.vscode/
+.idea/
+.DS_Store
+.cursorrules
diff --git a/.travis.yml b/.travis.yml
deleted file mode 100644
index 757ab37..0000000
--- a/.travis.yml
+++ /dev/null
@@ -1,10 +0,0 @@
-language: go
-sudo: false
-
-script: go test -v
-
-go:
- - 1.3
- - 1.12
- - 1.13
- - tip
diff --git a/LICENSE b/LICENSE
index 42e8263..5a86376 100644
--- a/LICENSE
+++ b/LICENSE
@@ -1,4 +1,6 @@
-Copyright (c) 2015 Ryan Hileman
+MIT License
+
+Copyright (c) 2025 Kuma (路口 IT 大叔)
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
@@ -7,13 +9,13 @@ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/README.md b/README.md
index e8c6f01..ac24394 100644
--- a/README.md
+++ b/README.md
@@ -1,103 +1,405 @@
-[](https://travis-ci.org/lunixbochs/struc) [](https://godoc.org/github.com/lunixbochs/struc)
+English | [中文](./README_CN.md)
-struc
-====
+
+
+
+
+
iIqQfd", // 按照 formatMap 映射: Int8(b), Uint8(B), Int16(h), Uint16(H), Int32(i), Uint32(I), Int64(q), Uint64(Q), Float32(f), Float64(d)
+ },
+ {
+ name: "string types",
+ data: &FormatTestString{},
+ want: ">i10s5sh", // 按照 formatMap 映射: Int32(i), [10]byte(10s), [5]byte(5s), Int16(h)
+ },
+ {
+ name: "padding",
+ data: &FormatTestPadding{},
+ want: ">i4xH2xq", // 按照 formatMap 映射: Int32(i), Pad(4x), Uint16(H), Pad(2x), Int64(q)
+ },
+ {
+ name: "padding only",
+ data: &FormatTestPaddingOnly{},
+ want: ">4x2x", // 按照 formatMap 映射: Pad(4x), Pad(2x)
+ },
+ {
+ name: "mixed endianness",
+ data: &FormatTestEndian{},
+ want: ">HQiHb", // 按照 formatMap 映射: Int32(i), Uint16(H), Int8(b)
+ },
+ {
+ name: "nested struct",
+ data: &FormatTestNested{},
+ want: ">IH4s8xiBhhqd16sff2sh4s", // 按照 formatMap 映射: Uint32(I), Uint16(H), [4]byte(4s), Int8(i), Uint8(B), Int16(h), Int64(q), String(16s), Float32(f), Float64(d), Int32(i), Int16(h), Uint16(H), [4]byte(4s)
+ },
+ {
+ name: "array types",
+ data: &FormatTestArray{},
+ want: ">iiii8sff", // 按照 formatMap 映射: Int32(i,i,i,i), String(8s), Float32(f,f)
+ },
+ {
+ name: "non-struct",
+ data: 123,
+ wantErr: true,
+ errMsg: "data must be a struct or pointer to struct",
+ },
+ {
+ name: "nil pointer",
+ data: (*FormatTestBasic)(nil),
+ wantErr: true,
+ errMsg: "data must be a struct or pointer to struct",
+ },
+ }
+
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ got, err := GetFormatString(tt.data)
+ if (err != nil) != tt.wantErr {
+ t.Errorf("GetFormatString() error = %v, wantErr %v", err, tt.wantErr)
+ return
+ }
+ if tt.wantErr {
+ if err.Error() != tt.errMsg {
+ t.Errorf("GetFormatString() error message = %v, want %v", err.Error(), tt.errMsg)
+ }
+ return
+ }
+ if got != tt.want {
+ t.Errorf("GetFormatString() = %v, want %v", got, tt.want)
+ }
+ })
+ }
+}
diff --git a/go.mod b/go.mod
index e2b291e..ba4aaf4 100644
--- a/go.mod
+++ b/go.mod
@@ -1,3 +1,3 @@
-module github.com/lunixbochs/struc
+module github.com/shengyanli1982/struc/v2
-go 1.12
+go 1.19
diff --git a/go.sum b/go.sum
new file mode 100644
index 0000000..e69de29
diff --git a/options.go b/options.go
new file mode 100644
index 0000000..dd2dc1d
--- /dev/null
+++ b/options.go
@@ -0,0 +1,46 @@
+package struc
+
+import (
+ "encoding/binary"
+ "fmt"
+)
+
+// defaultPackingOptions 是默认的打包选项实例
+// 用于避免重复分配内存，提高性能
+var defaultPackingOptions = &Options{}
+
+// Options 定义了打包和解包的配置选项
+// 包含字节对齐、指针大小和字节序等设置
+type Options struct {
+ // ByteAlign 指定打包字段的字节对齐方式
+ // 值为 0 表示不进行对齐，其他值表示按该字节数对齐
+ ByteAlign int
+
+ // PtrSize 指定指针的大小（以位为单位）
+ // 可选值：8、16、32 或 64, 默认值：32
+ PtrSize int
+
+ // Order 指定字节序（大端或小端）
+ // 如果为 nil，则使用大端序
+ Order binary.ByteOrder
+}
+
+// Validate 验证选项的有效性
+// 检查指针大小是否合法，并设置默认值
+func (o *Options) Validate() error {
+ if o.PtrSize == 0 {
+ o.PtrSize = 32 // 设置默认指针大小
+ } else {
+ switch o.PtrSize {
+ case 8, 16, 32, 64:
+ // 有效的指针大小
+ default:
+ return fmt.Errorf("invalid Options.PtrSize: %d (must be 8, 16, 32, or 64)", o.PtrSize)
+ }
+ }
+ return nil
+}
+
+func init() {
+ _ = defaultPackingOptions.Validate()
+}
diff --git a/options_builder.go b/options_builder.go
new file mode 100644
index 0000000..5dfbf62
--- /dev/null
+++ b/options_builder.go
@@ -0,0 +1,106 @@
+package struc
+
+import (
+ "encoding/binary"
+)
+
+// OptionsBuilder 是配置选项的建造者模式实现
+// 提供链式调用的方式来构建 Options 对象
+type OptionsBuilder struct {
+ options *Options
+}
+
+// NewOptionsBuilder 创建一个新的配置选项建造者
+func NewOptionsBuilder() *OptionsBuilder {
+ return &OptionsBuilder{
+ options: &Options{},
+ }
+}
+
+// WithByteAlign 设置字节对齐方式
+func (b *OptionsBuilder) WithByteAlign(align int) *OptionsBuilder {
+ b.options.ByteAlign = align
+ return b
+}
+
+// WithPtrSize 设置指针大小
+func (b *OptionsBuilder) WithPtrSize(size int) *OptionsBuilder {
+ b.options.PtrSize = size
+ return b
+}
+
+// WithByteOrder 设置字节序
+func (b *OptionsBuilder) WithByteOrder(order binary.ByteOrder) *OptionsBuilder {
+ b.options.Order = order
+ return b
+}
+
+// WithLittleEndian 设置为小端字节序
+func (b *OptionsBuilder) WithLittleEndian() *OptionsBuilder {
+ b.options.Order = binary.LittleEndian
+ return b
+}
+
+// WithBigEndian 设置为大端字节序
+func (b *OptionsBuilder) WithBigEndian() *OptionsBuilder {
+ b.options.Order = binary.BigEndian
+ return b
+}
+
+// Build 构建最终的 Options 对象并验证
+func (b *OptionsBuilder) Build() (*Options, error) {
+ if err := b.options.Validate(); err != nil {
+ return nil, err
+ }
+ return b.options, nil
+}
+
+// MustBuild 构建最终的 Options 对象，如果验证失败则 panic
+func (b *OptionsBuilder) MustBuild() *Options {
+ options, err := b.Build()
+ if err != nil {
+ panic(err)
+ }
+ return options
+}
+
+// ==================== 便捷构建函数 ====================
+
+// DefaultOptions 返回默认配置选项
+func DefaultOptions() *Options {
+ return defaultPackingOptions
+}
+
+// LittleEndianOptions 返回小端字节序的配置选项
+func LittleEndianOptions() *Options {
+ builder := NewOptionsBuilder()
+ return builder.WithLittleEndian().MustBuild()
+}
+
+// BigEndianOptions 返回大端字节序的配置选项
+func BigEndianOptions() *Options {
+ builder := NewOptionsBuilder()
+ return builder.WithBigEndian().MustBuild()
+}
+
+// AlignedOptions 返回指定字节对齐的配置选项
+func AlignedOptions(align int) *Options {
+ builder := NewOptionsBuilder()
+ return builder.WithByteAlign(align).MustBuild()
+}
+
+// PtrSizeOptions 返回指定指针大小的配置选项
+func PtrSizeOptions(size int) *Options {
+ builder := NewOptionsBuilder()
+ return builder.WithPtrSize(size).MustBuild()
+}
+
+// CustomOptions 返回自定义配置选项
+func CustomOptions(align, ptrSize int, order binary.ByteOrder) *Options {
+ builder := NewOptionsBuilder()
+ return builder.
+ WithByteAlign(align).
+ WithPtrSize(ptrSize).
+ WithByteOrder(order).
+ MustBuild()
+}
\ No newline at end of file
diff --git a/packable_test.go b/packable_test.go
index ec2bed9..c55e078 100644
--- a/packable_test.go
+++ b/packable_test.go
@@ -3,121 +3,71 @@ package struc
import (
"bytes"
"fmt"
+ "reflect"
"testing"
)
-var packableReference = []byte{
+var testPackableBytes = []byte{
1, 0, 2, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 4, 5, 0, 6, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 8,
9, 10, 11, 12, 13, 14, 15, 16,
0, 17, 0, 18, 0, 19, 0, 20, 0, 21, 0, 22, 0, 23, 0, 24,
}
-func TestPackable(t *testing.T) {
- var (
- buf bytes.Buffer
+type testCase struct {
+ name string
+ value interface{}
+ expected interface{}
+}
- i8 int8 = 1
- i16 int16 = 2
- i32 int32 = 3
- i64 int64 = 4
- u8 uint8 = 5
- u16 uint16 = 6
- u32 uint32 = 7
- u64 uint64 = 8
+func TestPackable(t *testing.T) {
+ var buf bytes.Buffer
- u8a = [8]uint8{9, 10, 11, 12, 13, 14, 15, 16}
- u16a = [8]uint16{17, 18, 19, 20, 21, 22, 23, 24}
- )
- // pack tests
- if err := Pack(&buf, i8); err != nil {
- t.Fatal(err)
- }
- if err := Pack(&buf, i16); err != nil {
- t.Fatal(err)
- }
- if err := Pack(&buf, i32); err != nil {
- t.Fatal(err)
- }
- if err := Pack(&buf, i64); err != nil {
- t.Fatal(err)
- }
- if err := Pack(&buf, u8); err != nil {
- t.Fatal(err)
- }
- if err := Pack(&buf, u16); err != nil {
- t.Fatal(err)
- }
- if err := Pack(&buf, u32); err != nil {
- t.Fatal(err)
- }
- if err := Pack(&buf, u64); err != nil {
- t.Fatal(err)
- }
- if err := Pack(&buf, u8a[:]); err != nil {
- t.Fatal(err)
- }
- if err := Pack(&buf, u16a[:]); err != nil {
- t.Fatal(err)
- }
- if !bytes.Equal(buf.Bytes(), packableReference) {
- fmt.Println(buf.Bytes())
- fmt.Println(packableReference)
- t.Fatal("Packable Pack() did not match reference.")
- }
- // unpack tests
- i8 = 0
- i16 = 0
- i32 = 0
- i64 = 0
- u8 = 0
- u16 = 0
- u32 = 0
- u64 = 0
- if err := Unpack(&buf, &i8); err != nil {
- t.Fatal(err)
- }
- if err := Unpack(&buf, &i16); err != nil {
- t.Fatal(err)
- }
- if err := Unpack(&buf, &i32); err != nil {
- t.Fatal(err)
+ // 定义测试用例
+ cases := []testCase{
+ {"int8", int8(1), int8(1)},
+ {"int16", int16(2), int16(2)},
+ {"int32", int32(3), int32(3)},
+ {"int64", int64(4), int64(4)},
+ {"uint8", uint8(5), uint8(5)},
+ {"uint16", uint16(6), uint16(6)},
+ {"uint32", uint32(7), uint32(7)},
+ {"uint64", uint64(8), uint64(8)},
+ {"uint8 array", [8]uint8{9, 10, 11, 12, 13, 14, 15, 16}, [8]uint8{9, 10, 11, 12, 13, 14, 15, 16}},
+ {"uint16 array", [8]uint16{17, 18, 19, 20, 21, 22, 23, 24}, [8]uint16{17, 18, 19, 20, 21, 22, 23, 24}},
}
- if err := Unpack(&buf, &i64); err != nil {
- t.Fatal(err)
- }
- if err := Unpack(&buf, &u8); err != nil {
- t.Fatal(err)
- }
- if err := Unpack(&buf, &u16); err != nil {
- t.Fatal(err)
- }
- if err := Unpack(&buf, &u32); err != nil {
- t.Fatal(err)
- }
- if err := Unpack(&buf, &u64); err != nil {
- t.Fatal(err)
- }
- if err := Unpack(&buf, u8a[:]); err != nil {
- t.Fatal(err)
- }
- if err := Unpack(&buf, u16a[:]); err != nil {
- t.Fatal(err)
- }
- // unpack checks
- if i8 != 1 || i16 != 2 || i32 != 3 || i64 != 4 {
- t.Fatal("Signed integer unpack failed.")
- }
- if u8 != 5 || u16 != 6 || u32 != 7 || u64 != 8 {
- t.Fatal("Unsigned integer unpack failed.")
- }
- for i := 0; i < 8; i++ {
- if u8a[i] != uint8(i+9) {
- t.Fatal("uint8 array unpack failed.")
+
+ // Pack 测试
+ t.Run("Pack", func(t *testing.T) {
+ for _, tc := range cases {
+ t.Run(tc.name, func(t *testing.T) {
+ if err := Pack(&buf, tc.value); err != nil {
+ t.Fatalf("Pack %s failed: %v", tc.name, err)
+ }
+ })
}
- }
- for i := 0; i < 8; i++ {
- if u16a[i] != uint16(i+17) {
- t.Fatal("uint16 array unpack failed.")
+
+ if !bytes.Equal(buf.Bytes(), testPackableBytes) {
+ fmt.Println(buf.Bytes())
+ fmt.Println(testPackableBytes)
+ t.Fatal("Packable Pack() did not match reference.")
}
- }
+ })
+
+ // Unpack 测试
+ t.Run("Unpack", func(t *testing.T) {
+ for _, tc := range cases {
+ t.Run(tc.name, func(t *testing.T) {
+ // 创建一个与期望类型相同的变量来存储解包结果
+ value := reflect.New(reflect.TypeOf(tc.expected)).Interface()
+ if err := Unpack(&buf, value); err != nil {
+ t.Fatalf("Unpack %s failed: %v", tc.name, err)
+ }
+ // 解引用指针并比较值
+ actual := reflect.ValueOf(value).Elem().Interface()
+ if !reflect.DeepEqual(actual, tc.expected) {
+ t.Errorf("%s: expected %v, got %v", tc.name, tc.expected, actual)
+ }
+ })
+ }
+ })
}
diff --git a/packer.go b/packer.go
index a3a91a2..38ac65a 100644
--- a/packer.go
+++ b/packer.go
@@ -5,9 +5,18 @@ import (
"reflect"
)
+// Packer 定义了数据打包和解包的基本接口
+// 实现此接口的类型可以将自身序列化为字节流，并从字节流中反序列化
type Packer interface {
+ // Pack 将值序列化到字节缓冲区中
Pack(buf []byte, val reflect.Value, options *Options) (int, error)
+
+ // Unpack 从 Reader 中读取数据并反序列化到值中
Unpack(r io.Reader, val reflect.Value, options *Options) error
+
+ // Sizeof 返回值序列化后的字节大小
Sizeof(val reflect.Value, options *Options) int
+
+ // String 返回类型的字符串表示
String() string
}
diff --git a/parse.go b/parse.go
index be0afa7..7f5cb97 100644
--- a/parse.go
+++ b/parse.go
@@ -11,220 +11,280 @@ import (
"sync"
)
-// struc:"int32,big,sizeof=Data,skip,sizefrom=Len"
+// 标签格式示例：struc:"int32,big,sizeof=Data,skip,sizefrom=Len"
+// 标签选项说明：
+// - int32: 字段类型
+// - big/little: 字节序
+// - sizeof=Field: 指定字段大小来源
+// - skip: 跳过该字段
+// - sizefrom=Field: 指定长度来源字段
+// strucTag 定义了结构体字段标签的解析结果
+// 包含了字段的类型、字节序、大小引用等信息
type strucTag struct {
- Type string
- Order binary.ByteOrder
- Sizeof string
- Skip bool
- Sizefrom string
+ Type string // 字段类型（如 int32, uint8 等）
+ Order binary.ByteOrder // 字节序（大端或小端）
+ Sizeof string // 大小引用字段名
+ Skip bool // 是否跳过该字段
+ Sizefrom string // 长度来源字段名
}
-func parseStrucTag(tag reflect.StructTag) *strucTag {
- t := &strucTag{
+// parseStrucTag 解析结构体字段的标签
+// 支持 struc 和 struct 两种标签名（向后兼容）
+func parseStrucTag(fieldTag reflect.StructTag) *strucTag {
+ // 初始化标签结构体，默认使用大端字节序
+ parsedTag := &strucTag{
Order: binary.BigEndian,
}
- tagStr := tag.Get("struc")
- if tagStr == "" {
- // someone's going to typo this (I already did once)
- // sorry if you made a module actually using this tag
- // and you're mad at me now
- tagStr = tag.Get("struct")
- }
- for _, s := range strings.Split(tagStr, ",") {
- if strings.HasPrefix(s, "sizeof=") {
- tmp := strings.SplitN(s, "=", 2)
- t.Sizeof = tmp[1]
- } else if strings.HasPrefix(s, "sizefrom=") {
- tmp := strings.SplitN(s, "=", 2)
- t.Sizefrom = tmp[1]
- } else if s == "big" {
- t.Order = binary.BigEndian
- } else if s == "little" {
- t.Order = binary.LittleEndian
- } else if s == "skip" {
- t.Skip = true
- } else {
- t.Type = s
+
+ // 获取 struc 标签，如果不存在则尝试获取 struct 标签
+ tagString := fieldTag.Get("struc")
+ if tagString == "" {
+ tagString = fieldTag.Get("struct")
+ }
+
+ // 处理 "-" 标签，表示完全忽略该字段
+ if tagString == "-" {
+ parsedTag.Skip = true
+ return parsedTag
+ }
+
+ for _, option := range strings.Split(tagString, ",") {
+ if strings.HasPrefix(option, "sizeof=") {
+ parts := strings.SplitN(option, "=", 2)
+ parsedTag.Sizeof = parts[1]
+ } else if strings.HasPrefix(option, "sizefrom=") {
+ parts := strings.SplitN(option, "=", 2)
+ parsedTag.Sizefrom = parts[1]
+ } else if option == "big" {
+ parsedTag.Order = binary.BigEndian
+ } else if option == "little" {
+ parsedTag.Order = binary.LittleEndian
+ } else if option == "skip" {
+ parsedTag.Skip = true
+ } else if option != "" {
+ parsedTag.Type = option
}
}
- return t
+ return parsedTag
}
-var typeLenRe = regexp.MustCompile(`^\[(\d*)\]`)
+// arrayLengthParseRegex 用于匹配数组长度的正则表达式: [数字]
+var arrayLengthParseRegex = regexp.MustCompile(`^\[(\d*)\]`)
-func parseField(f reflect.StructField) (fd *Field, tag *strucTag, err error) {
- tag = parseStrucTag(f.Tag)
+// parseStructField 解析单个结构体字段
+func parseStructField(structField reflect.StructField) (fieldDesc *Field, fieldTag *strucTag, err error) {
+ fieldTag = parseStrucTag(structField.Tag)
var ok bool
- fd = &Field{
- Name: f.Name,
- Len: 1,
- Order: tag.Order,
- Slice: false,
- kind: f.Type.Kind(),
- }
- switch fd.kind {
+
+ fieldDesc = acquireField()
+
+ fieldDesc.Name = structField.Name
+ fieldDesc.Length = 1
+ fieldDesc.ByteOrder = fieldTag.Order
+ fieldDesc.IsSlice = false
+ fieldDesc.kind = structField.Type.Kind()
+
+ switch fieldDesc.kind {
case reflect.Array:
- fd.Slice = true
- fd.Array = true
- fd.Len = f.Type.Len()
- fd.kind = f.Type.Elem().Kind()
+ fieldDesc.IsSlice = true
+ fieldDesc.IsArray = true
+ fieldDesc.Length = structField.Type.Len()
+ fieldDesc.kind = structField.Type.Elem().Kind()
case reflect.Slice:
- fd.Slice = true
- fd.Len = -1
- fd.kind = f.Type.Elem().Kind()
+ fieldDesc.IsSlice = true
+ fieldDesc.Length = -1
+ fieldDesc.kind = structField.Type.Elem().Kind()
case reflect.Ptr:
- fd.Ptr = true
- fd.kind = f.Type.Elem().Kind()
+ fieldDesc.IsPointer = true
+ fieldDesc.kind = structField.Type.Elem().Kind()
}
- // check for custom types
- tmp := reflect.New(f.Type)
- if _, ok := tmp.Interface().(Custom); ok {
- fd.Type = CustomType
+
+ // 检查是否为自定义类型
+ tempValue := reflect.New(structField.Type)
+ if _, ok := tempValue.Interface().(CustomBinaryer); ok {
+ fieldDesc.Type = CustomType
return
}
+
var defTypeOk bool
- fd.defType, defTypeOk = reflectTypeMap[fd.kind]
- // find a type in the struct tag
- pureType := typeLenRe.ReplaceAllLiteralString(tag.Type, "")
- if fd.Type, ok = typeLookup[pureType]; ok {
- fd.Len = 1
- match := typeLenRe.FindAllStringSubmatch(tag.Type, -1)
- if len(match) > 0 && len(match[0]) > 1 {
- fd.Slice = true
- first := match[0][1]
- // Field.Len = -1 indicates a []slice
- if first == "" {
- fd.Len = -1
+ fieldDesc.defType, defTypeOk = typeKindToType[fieldDesc.kind]
+
+ // 从结构体标签中查找类型
+ pureType := arrayLengthParseRegex.ReplaceAllLiteralString(fieldTag.Type, "")
+ if fieldDesc.Type, ok = typeStrToType[pureType]; ok {
+ fieldDesc.Length = 1
+ // 解析数组长度
+ matches := arrayLengthParseRegex.FindAllStringSubmatch(fieldTag.Type, -1)
+ if len(matches) > 0 && len(matches[0]) > 1 {
+ fieldDesc.IsSlice = true
+ lengthStr := matches[0][1]
+ if lengthStr == "" {
+ fieldDesc.Length = -1 // 动态长度切片
} else {
- fd.Len, err = strconv.Atoi(first)
+ fieldDesc.Length, err = strconv.Atoi(lengthStr)
}
}
return
}
- // the user didn't specify a type
- switch f.Type {
+
+ // 处理特殊类型 Size_t 和 Off_t
+ switch structField.Type {
case reflect.TypeOf(Size_t(0)):
- fd.Type = SizeType
+ fieldDesc.Type = SizeType
case reflect.TypeOf(Off_t(0)):
- fd.Type = OffType
+ fieldDesc.Type = OffType
default:
if defTypeOk {
- fd.Type = fd.defType
+ fieldDesc.Type = fieldDesc.defType
} else {
- err = errors.New(fmt.Sprintf("struc: Could not resolve field '%v' type '%v'.", f.Name, f.Type))
+ releaseField(fieldDesc)
+ err = fmt.Errorf("struc: Could not resolve field '%v' type '%v'.", structField.Name, structField.Type)
+ fieldDesc = nil
}
}
return
}
-func parseFieldsLocked(v reflect.Value) (Fields, error) {
- // we need to repeat this logic because parseFields() below can't be recursively called due to locking
- for v.Kind() == reflect.Ptr {
- v = v.Elem()
+// handleSizeofTag 处理字段的 sizeof 标签
+func handleSizeofTag(fieldDesc *Field, fieldTag *strucTag, structType reflect.Type, field reflect.StructField, sizeofMap map[string][]int) error {
+ if fieldTag.Sizeof != "" {
+ targetField, ok := structType.FieldByName(fieldTag.Sizeof)
+ if !ok {
+ return fmt.Errorf("struc: `sizeof=%s` field does not exist", fieldTag.Sizeof)
+ }
+ fieldDesc.Sizeof = targetField.Index
+ sizeofMap[fieldTag.Sizeof] = field.Index
}
- t := v.Type()
- if v.NumField() < 1 {
- return nil, errors.New("struc: Struct has no fields.")
+ return nil
+}
+
+// handleSizefromTag 处理字段的 sizefrom 标签
+func handleSizefromTag(fieldDesc *Field, fieldTag *strucTag, structType reflect.Type, field reflect.StructField, sizeofMap map[string][]int) error {
+ if sizefrom, ok := sizeofMap[field.Name]; ok {
+ fieldDesc.Sizefrom = sizefrom
}
- sizeofMap := make(map[string][]int)
- fields := make(Fields, v.NumField())
- for i := 0; i < t.NumField(); i++ {
- field := t.Field(i)
- f, tag, err := parseField(field)
- if tag.Skip {
- continue
+ if fieldTag.Sizefrom != "" {
+ sourceField, ok := structType.FieldByName(fieldTag.Sizefrom)
+ if !ok {
+ return fmt.Errorf("struc: `sizefrom=%s` field does not exist", fieldTag.Sizefrom)
}
+ fieldDesc.Sizefrom = sourceField.Index
+ }
+ return nil
+}
+
+// handleNestedStruct 处理嵌套结构体字段
+func handleNestedStruct(fieldDesc *Field, field reflect.StructField) error {
+ if fieldDesc.Type == Struct {
+ fieldType := field.Type
+ if fieldDesc.IsPointer {
+ fieldType = fieldType.Elem()
+ }
+ if fieldDesc.IsSlice {
+ fieldType = fieldType.Elem()
+ }
+ tempValue := reflect.New(fieldType)
+ nestedFields, err := parseFields(tempValue.Elem())
if err != nil {
+ return err
+ }
+ fieldDesc.NestFields = nestedFields
+ }
+ return nil
+}
+
+// validateSliceLength 验证切片长度
+func validateSliceLength(fieldDesc *Field, field reflect.StructField) error {
+ if fieldDesc.Length == -1 && fieldDesc.Sizefrom == nil {
+ return fmt.Errorf("struc: field `%s` is a slice with no length or sizeof field", field.Name)
+ }
+ return nil
+}
+
+// parseFieldsLocked 在加锁状态下解析结构体的所有字段
+func parseFieldsLocked(structValue reflect.Value) (Fields, error) {
+ for structValue.Kind() == reflect.Ptr {
+ structValue = structValue.Elem()
+ }
+ structType := structValue.Type()
+
+ if structValue.NumField() < 1 {
+ return nil, errors.New("struc: Struct has no fields.")
+ }
+
+ sizeofMap := acquireSizeofMap()
+ defer releaseSizeofMap(sizeofMap)
+
+ fields := make(Fields, structValue.NumField())
+
+ for i := 0; i < structType.NumField(); i++ {
+ field := structType.Field(i)
+
+ fieldDesc, fieldTag, err := parseStructField(field)
+ if err != nil {
+ releaseFields(fields)
return nil, err
}
- if !v.Field(i).CanSet() {
+
+ if fieldTag.Skip || !structValue.Field(i).CanSet() {
continue
}
- f.Index = i
- if tag.Sizeof != "" {
- target, ok := t.FieldByName(tag.Sizeof)
- if !ok {
- return nil, fmt.Errorf("struc: `sizeof=%s` field does not exist", tag.Sizeof)
- }
- f.Sizeof = target.Index
- sizeofMap[tag.Sizeof] = field.Index
- }
- if sizefrom, ok := sizeofMap[field.Name]; ok {
- f.Sizefrom = sizefrom
+
+ fieldDesc.Index = i
+
+ if err := handleSizeofTag(fieldDesc, fieldTag, structType, field, sizeofMap); err != nil {
+ releaseFields(fields)
+ return nil, err
}
- if tag.Sizefrom != "" {
- source, ok := t.FieldByName(tag.Sizefrom)
- if !ok {
- return nil, fmt.Errorf("struc: `sizefrom=%s` field does not exist", tag.Sizefrom)
- }
- f.Sizefrom = source.Index
+
+ if err := handleSizefromTag(fieldDesc, fieldTag, structType, field, sizeofMap); err != nil {
+ releaseFields(fields)
+ return nil, err
}
- if f.Len == -1 && f.Sizefrom == nil {
- return nil, fmt.Errorf("struc: field `%s` is a slice with no length or sizeof field", field.Name)
+
+ if err := validateSliceLength(fieldDesc, field); err != nil {
+ releaseFields(fields)
+ return nil, err
}
- // recurse into nested structs
- // TODO: handle loops (probably by indirecting the []Field and putting pointer in cache)
- if f.Type == Struct {
- typ := field.Type
- if f.Ptr {
- typ = typ.Elem()
- }
- if f.Slice {
- typ = typ.Elem()
- }
- f.Fields, err = parseFieldsLocked(reflect.New(typ))
- if err != nil {
- return nil, err
- }
+
+ if err := handleNestedStruct(fieldDesc, field); err != nil {
+ releaseFields(fields)
+ return nil, err
}
- fields[i] = f
+
+ fields[i] = fieldDesc
}
return fields, nil
}
-var fieldCache = make(map[reflect.Type]Fields)
-var fieldCacheLock sync.RWMutex
-var parseLock sync.Mutex
+// parsedStructFieldCache 存储每个结构体类型的已解析字段 (并发安全)
+var (
+ parsedStructFieldCache = sync.Map{}
+)
-func fieldCacheLookup(t reflect.Type) Fields {
- fieldCacheLock.RLock()
- defer fieldCacheLock.RUnlock()
- if cached, ok := fieldCache[t]; ok {
- return cached
+// fieldCacheLookup 查找类型的缓存字段
+func fieldCacheLookup(structType reflect.Type) Fields {
+ if cached, ok := parsedStructFieldCache.Load(structType); ok {
+ return cached.(Fields)
}
return nil
}
-func parseFields(v reflect.Value) (Fields, error) {
- for v.Kind() == reflect.Ptr {
- v = v.Elem()
- }
- t := v.Type()
-
- // fast path: hopefully the field parsing is already cached
- if cached := fieldCacheLookup(t); cached != nil {
- return cached, nil
- }
-
- // hold a global lock so multiple goroutines can't parse (the same) fields at once
- parseLock.Lock()
- defer parseLock.Unlock()
-
- // check cache a second time, in case parseLock was just released by
- // another thread who filled the cache for us
- if cached := fieldCacheLookup(t); cached != nil {
+// parseFields 解析结构体的所有字段
+// 首先尝试从缓存中获取，如果未命中则进行解析并缓存结果
+func parseFields(structValue reflect.Value) (Fields, error) {
+ structType := structValue.Type()
+ if cached := fieldCacheLookup(structType); cached != nil {
return cached, nil
}
- // no luck, time to parse and fill the cache ourselves
- fields, err := parseFieldsLocked(v)
+ fields, err := parseFieldsLocked(structValue)
if err != nil {
return nil, err
}
- fieldCacheLock.Lock()
- fieldCache[t] = fields
- fieldCacheLock.Unlock()
+
+ parsedStructFieldCache.Store(structType, fields)
+
return fields, nil
}
diff --git a/parse_test.go b/parse_test.go
index 861fdd1..c32736c 100644
--- a/parse_test.go
+++ b/parse_test.go
@@ -60,3 +60,53 @@ func TestNestedParseError(t *testing.T) {
t.Fatal("failed to error on bad nested struct")
}
}
+
+// 测试忽略字段的结构体
+// Test struct with ignored fields
+type ignoreFieldsStruct struct {
+ Public int `struc:"int32"`
+ Ignored bool `struc:"-"`
+ Compat string `struct:"-"`
+ Private float64 `struc:"float64"`
+}
+
+// TestIgnoreFields 测试 struc:"-" 标签的功能
+// 验证带有 "-" 标签的字段会被正确忽略
+//
+// TestIgnoreFields tests the struc:"-" tag functionality
+// Verifies that fields with "-" tag are correctly ignored
+func TestIgnoreFields(t *testing.T) {
+ val := reflect.ValueOf(&ignoreFieldsStruct{})
+ fields, err := parseFields(val.Elem())
+ if err != nil {
+ t.Fatalf("Failed to parse struct with ignored fields: %v", err)
+ }
+
+ // 检查字段数量是否正确（应该只有 Public 和 Private 两个字段）
+ // Check if the number of fields is correct (should only have Public and Private fields)
+ expectedFields := 2
+ actualFields := 0
+ for _, field := range fields {
+ if field != nil {
+ actualFields++
+ }
+ }
+ if actualFields != expectedFields {
+ t.Errorf("Expected %d fields, got %d fields", expectedFields, actualFields)
+ }
+
+ // 验证 Ignored 和 Compat 字段被正确标记为跳过
+ // Verify that Ignored and Compat fields are correctly marked as skipped
+ if fields[1] != nil || fields[2] != nil {
+ t.Error("Fields marked with '-' tag were not properly ignored")
+ }
+
+ // 验证 Public 和 Private 字段被正确解析
+ // Verify that Public and Private fields are correctly parsed
+ if fields[0] == nil || fields[0].Type != Int32 {
+ t.Error("Public field was not properly parsed")
+ }
+ if fields[3] == nil || fields[3].Type != Float64 {
+ t.Error("Private field was not properly parsed")
+ }
+}
diff --git a/pool.go b/pool.go
new file mode 100644
index 0000000..e57b42b
--- /dev/null
+++ b/pool.go
@@ -0,0 +1,187 @@
+package struc
+
+import (
+ "bytes"
+ "encoding/binary"
+ "reflect"
+ "runtime"
+ "sync"
+ "sync/atomic"
+)
+
+// MaxBufferCapSize 定义了缓冲区的最大容量限制
+// 超过此限制的缓冲区不会被放入对象池
+const MaxBufferCapSize = 1 << 20
+
+// MaxBytesSliceSize 定义了字节切片的最大容量限制
+// 超过此限制的字节切片不会被放入对象池
+const MaxBytesSliceSize = 4096
+
+// bufferPool 用于减少[]byte的内存分配
+var bufferPool = sync.Pool{
+ New: func() interface{} {
+ return bytes.NewBuffer(make([]byte, 0, 1024))
+ },
+}
+
+// fieldPool 是 Field 对象的全局池
+var fieldPool = sync.Pool{
+ New: func() interface{} {
+ return &Field{
+ Length: 1,
+ ByteOrder: binary.BigEndian, // 默认使用大端字节序
+ }
+ },
+}
+
+// sizeofMapPool 是用于复用 sizeofMap 的对象池
+var sizeofMapPool = sync.Pool{
+ New: func() interface{} {
+ return make(map[string][]int)
+ },
+}
+
+// acquireSizeofMap 从对象池获取一个 sizeofMap
+func acquireSizeofMap() map[string][]int {
+ return sizeofMapPool.Get().(map[string][]int)
+}
+
+// releaseSizeofMap 将 sizeofMap 放回对象池
+func releaseSizeofMap(m map[string][]int) {
+ if m == nil {
+ return
+ }
+ // 清空 map
+ for k := range m {
+ delete(m, k)
+ }
+ sizeofMapPool.Put(m)
+}
+
+// acquireBuffer 从对象池获取缓冲区
+func acquireBuffer() *bytes.Buffer {
+ return bufferPool.Get().(*bytes.Buffer)
+}
+
+// releaseBuffer 将缓冲区放回对象池
+func releaseBuffer(buf *bytes.Buffer) {
+ if buf == nil || buf.Cap() > MaxBufferCapSize {
+ return
+ }
+
+ buf.Reset()
+ bufferPool.Put(buf)
+}
+
+// acquireField 从对象池获取一个 Field 对象
+func acquireField() *Field {
+ return fieldPool.Get().(*Field)
+}
+
+// releaseField 将 Field 对象放回对象池
+func releaseField(f *Field) {
+ if f == nil {
+ return
+ }
+ // 重置字段状态
+ f.Name = ""
+ f.IsPointer = false
+ f.Index = 0
+ f.Type = 0
+ f.defType = 0
+ f.IsArray = false
+ f.IsSlice = false
+ f.Length = 1
+ f.ByteOrder = binary.BigEndian
+ f.Sizeof = nil
+ f.Sizefrom = nil
+ f.NestFields = nil
+ f.kind = reflect.Invalid
+
+ fieldPool.Put(f)
+}
+
+// releaseFields 将 Fields 切片中的所有 Field 对象放回对象池
+func releaseFields(fields Fields) {
+ if fields == nil {
+ return
+ }
+ for _, f := range fields {
+ releaseField(f)
+ }
+}
+
+// BytesSlicePool 是一个用于管理共享字节切片的结构体
+// 它提供了线程安全的切片分配和重用功能
+type BytesSlicePool struct {
+ bytes []byte // 底层字节数组
+ offset int32 // 当前偏移量
+ size int // 当前块大小
+ mu sync.Mutex // 互斥锁用于保护并发访问
+}
+
+// NewBytesSlicePool 创建一个新的 BytesSlicePool 实例
+// 初始化时，会分配一个 4096 字节的字节数组
+func NewBytesSlicePool(size int) *BytesSlicePool {
+ // 如果 size 小于等于 0 或者大于 MaxBytesSliceSize，则使用 MaxBytesSliceSize
+ if size > MaxBytesSliceSize || size <= 0 {
+ size = MaxBytesSliceSize
+ }
+
+ return &BytesSlicePool{
+ bytes: make([]byte, size),
+ offset: 0,
+ size: size,
+ mu: sync.Mutex{},
+ }
+}
+
+// GetSlice 返回指定大小的字节切片
+// 如果当前块空间不足，会分配新的块并重置偏移量
+func (b *BytesSlicePool) GetSlice(size int) []byte {
+ // 如果请求的大小超过了最大限制，直接分配新的切片
+ if size > b.size {
+ return make([]byte, size)
+ }
+
+ // 快速路径：尝试有限次数的原子操作，使用退避策略减少 CPU 压力
+ for i := 0; i < 4; i++ { // 最多尝试 4 次 / Maximum 4 attempts
+ currentOffset := atomic.LoadInt32(&b.offset)
+
+ if int(currentOffset)+size > b.size {
+ break
+ }
+
+ newOffset := currentOffset + int32(size)
+ if atomic.CompareAndSwapInt32(&b.offset, currentOffset, newOffset) {
+ return b.bytes[currentOffset:newOffset]
+ }
+
+ // 简单的退避策略，防止 CPU 过热
+ if i > 0 {
+ for j := 0; j < (1 << i); j++ {
+ // 让出 CPU，允许其他 goroutine 执行
+ runtime.Gosched()
+ }
+ }
+ }
+
+ // 慢路径：多次尝试失败或空间不足时使用
+ return b.getSliceSlow(size)
+}
+
+// getSliceSlow 是 GetSlice 的慢路径实现
+// 使用互斥锁保护重置操作，减少竞争
+func (b *BytesSlicePool) getSliceSlow(size int) []byte {
+ b.mu.Lock()
+ defer b.mu.Unlock()
+
+ if int(b.offset)+size > b.size {
+ b.bytes = make([]byte, b.size)
+ b.offset = 0
+ }
+ start := b.offset
+ b.offset += int32(size)
+
+ return b.bytes[start:b.offset]
+}
diff --git a/pprof/bench_pprof.sh b/pprof/bench_pprof.sh
new file mode 100644
index 0000000..9324637
--- /dev/null
+++ b/pprof/bench_pprof.sh
@@ -0,0 +1,32 @@
+
+# 运行解码基准测试
+go test -bench=Decode -benchmem -cpuprofile=cpu_decode.prof -memprofile=mem_decode.prof -trace=trace_decode.out
+
+# 运行编码基准测试
+go test -bench=Encode -benchmem -cpuprofile=cpu_encode.prof -memprofile=mem_encode.prof -trace=trace_encode.out
+
+# 查看基准测试结果
+go tool pprof -http=:8080 cpu_decode.prof
+go tool pprof -http=:8080 mem_decode.prof
+go tool trace trace_decode.out
+
+go tool pprof -http=:8080 cpu_encode.prof
+go tool pprof -http=:8080 mem_encode.prof
+go tool trace trace_encode.out
+
+# 转换为svg
+go tool pprof -svg cpu_decode.prof > cpu_decode.svg
+go tool pprof -svg mem_decode.prof > mem_decode.svg
+go tool pprof -svg cpu_encode.prof > cpu_encode.svg
+go tool pprof -svg mem_encode.prof > mem_encode.svg
+
+
+# 查看trace
+go tool trace trace_decode.out
+go tool trace trace_encode.out
+
+# 查看 text
+go tool pprof -text cpu_decode.prof
+go tool pprof -text mem_decode.prof
+go tool pprof -text cpu_encode.prof
+go tool pprof -text mem_encode.prof
diff --git a/pprof/cpu_decode.svg b/pprof/cpu_decode.svg
new file mode 100644
index 0000000..d66767f
--- /dev/null
+++ b/pprof/cpu_decode.svg
@@ -0,0 +1,2824 @@
+
+
+
+
+
+
+struc.test.exe
+
+cluster_L
+
+
+
+File: struc.test.exe
+
+File: struc.test.exe
+Build ID: B:\Temp\go-build495253450\b001\struc.test.exe2025-01-19 09:51:38 +0800 CST
+Type: cpu
+Time: Jan 19, 2025 at 9:51am (CST)
+Duration: 8.95s, Total samples = 9.48s (105.95%)
+Showing nodes accounting for 8.09s, 85.34% of 9.48s total
+Dropped 173 nodes (cum <= 0.05s)
+Showing top 80 nodes out of 118
+See https://git.io/JfYMW for how to read the graph
+
+
+
+
+N1
+
+testing
+(*B)
+runN
+0 of 8.62s (90.93%)
+
+
+
+
+N13
+
+struc
+BenchmarkStdlibDecode
+0.03s (0.32%)
+of 1.39s (14.66%)
+
+
+
+
+N1->N13
+
+
+
+ 1.39s
+
+
+
+
+N16
+
+struc
+BenchmarkManualDecode
+0.28s (2.95%)
+of 1.15s (12.13%)
+
+
+
+
+N1->N16
+
+
+
+ 1.15s
+
+
+
+
+N27
+
+struc
+BenchmarkSliceDecode
+0.02s (0.21%)
+of 1.66s (17.51%)
+
+
+
+
+N1->N27
+
+
+
+ 1.66s
+
+
+
+
+N28
+
+struc
+BenchmarkDecode
+0.01s (0.11%)
+of 1.59s (16.77%)
+
+
+
+
+N1->N28
+
+
+
+ 1.59s
+
+
+
+
+N38
+
+struc
+BenchmarkArrayDecode
+0 of 1.60s (16.88%)
+
+
+
+
+N1->N38
+
+
+
+ 1.60s
+
+
+
+
+N78
+
+runtime
+newstack
+0 of 0.13s (1.37%)
+
+
+
+
+N1->N78
+
+
+
+ 0.01s
+
+
+
+
+N2
+
+struc
+Unpack
+0 of 5.75s (60.65%)
+
+
+
+
+N8
+
+struc
+UnpackWithOptions
+0.09s (0.95%)
+of 5.75s (60.65%)
+
+
+
+
+N2->N8
+
+
+
+ 5.75s
+
+
+
+
+N3
+
+struc
+Fields
+Unpack
+0.32s (3.38%)
+of 5.05s (53.27%)
+
+
+
+
+N6
+
+struc
+Fields
+unpackBasicType
+0.21s (2.22%)
+of 2.19s (23.10%)
+
+
+
+
+N3->N6
+
+
+
+ 2.19s
+
+
+
+
+N26
+
+reflect
+Value
+Field
+0.17s (1.79%)
+of 0.31s (3.27%)
+
+
+
+
+N3->N26
+
+
+
+ 0.23s
+
+
+
+
+N33
+
+struc
+Fields
+unpackStruct
+0.01s (0.11%)
+of 2.46s (25.95%)
+
+
+
+
+N3->N33
+
+
+
+ 2.46s
+
+
+
+
+N49
+
+reflect
+Value
+Kind
+0.05s (0.53%)
+of 0.11s (1.16%)
+
+
+
+
+N3->N49
+
+
+
+ 0.07s
+ (inline)
+
+
+
+
+N4
+
+testing
+(*B)
+launch
+0 of 8.61s (90.82%)
+
+
+
+
+N4->N1
+
+
+
+ 8.61s
+
+
+
+
+N5
+
+runtime
+mallocgc
+0.66s (6.96%)
+of 1.73s (18.25%)
+
+
+
+
+N34
+
+runtime
+nextFreeFast
+0.27s (2.85%)
+
+
+
+
+N5->N34
+
+
+
+ 0.27s
+ (inline)
+
+
+
+
+N51
+
+runtime
+memclrNoHeapPointers
+0.12s (1.27%)
+
+
+
+
+N5->N51
+
+
+
+ 0.12s
+
+
+
+
+N54
+
+runtime
+add
+0.09s (0.95%)
+
+
+
+
+N5->N54
+
+
+
+ 0.01s
+ (inline)
+
+
+
+
+N58
+
+runtime
+acquirem
+0.10s (1.05%)
+
+
+
+
+N5->N58
+
+
+
+ 0.10s
+ (inline)
+
+
+
+
+N63
+
+runtime
+getMCache
+0.08s (0.84%)
+
+
+
+
+N5->N63
+
+
+
+ 0.08s
+ (inline)
+
+
+
+
+N70
+
+runtime
+(*mspan)
+writeHeapBitsSmall
+0.06s (0.63%)
+of 0.08s (0.84%)
+
+
+
+
+N5->N70
+
+
+
+ 0.08s
+
+
+
+
+N74
+
+runtime
+deductAssistCredit
+0.06s (0.63%)
+of 0.08s (0.84%)
+
+
+
+
+N5->N74
+
+
+
+ 0.08s
+
+
+
+
+N14
+
+struc
+(*BytesSlicePool)
+GetSlice
+0.53s (5.59%)
+of 0.97s (10.23%)
+
+
+
+
+N6->N14
+
+
+
+ 0.97s
+
+
+
+
+N19
+
+struc
+(*Field)
+Unpack
+0.10s (1.05%)
+of 0.71s (7.49%)
+
+
+
+
+N6->N19
+
+
+
+ 0.71s
+
+
+
+
+N41
+
+struc
+Type
+Resolve
+0.10s (1.05%)
+
+
+
+
+N6->N41
+
+
+
+ 0.04s
+
+
+
+
+N59
+
+io
+ReadFull
+0 of 0.31s (3.27%)
+
+
+
+
+N6->N59
+
+
+
+ 0.26s
+ (inline)
+
+
+
+
+N7
+
+struc
+Fields
+unpackStructSlice
+0.16s (1.69%)
+of 2.39s (25.21%)
+
+
+
+
+N7->N3
+
+
+
+ 0.26s
+
+
+
+
+N12
+
+struc
+parseFields
+0.02s (0.21%)
+of 1.94s (20.46%)
+
+
+
+
+N7->N12
+
+
+
+ 1.63s
+
+
+
+
+N21
+
+reflect
+Value
+Index
+0.22s (2.32%)
+of 0.33s (3.48%)
+
+
+
+
+N7->N21
+
+
+
+ 0.09s
+
+
+
+
+N46
+
+reflect
+MakeSlice
+0.04s (0.42%)
+of 0.19s (2.00%)
+
+
+
+
+N7->N46
+
+
+
+ 0.19s
+
+
+
+
+N8->N3
+
+
+
+ 5.05s
+
+
+
+
+N23
+
+struc
+prepareValueForPacking
+0.03s (0.32%)
+of 0.57s (6.01%)
+
+
+
+
+N8->N23
+
+
+
+ 0.57s
+
+
+
+
+N9
+
+runtime
+mapaccess2
+0.83s (8.76%)
+of 1.50s (15.82%)
+
+
+
+
+N32
+
+runtime
+nilinterhash
+0.15s (1.58%)
+of 0.44s (4.64%)
+
+
+
+
+N9->N32
+
+
+
+ 0.44s
+
+
+
+
+N50
+
+runtime
+nilinterequal
+0.10s (1.05%)
+of 0.15s (1.58%)
+
+
+
+
+N9->N50
+
+
+
+ 0.15s
+
+
+
+
+N9->N54
+
+
+
+ 0.08s
+ (inline)
+
+
+
+
+N10
+
+sync
+(*Map)
+Load
+0.11s (1.16%)
+of 1.79s (18.88%)
+
+
+
+
+N10->N9
+
+
+
+ 1.50s
+
+
+
+
+N45
+
+sync
+(*entry)
+load
+0.17s (1.79%)
+
+
+
+
+N10->N45
+
+
+
+ 0.17s
+ (inline)
+
+
+
+
+N11
+
+binary
+(*decoder)
+value
+0.25s (2.64%)
+of 0.74s (7.81%)
+
+
+
+
+N11->N21
+
+
+
+ 0.16s
+
+
+
+
+N11->N26
+
+
+
+ 0.08s
+
+
+
+
+N11->N49
+
+
+
+ 0.04s
+ (inline)
+
+
+
+
+N57
+
+reflect
+Value
+SetUint
+0.07s (0.74%)
+
+
+
+
+N11->N57
+
+
+
+ 0.05s
+
+
+
+
+N67
+
+reflect
+Value
+SetInt
+0.05s (0.53%)
+
+
+
+
+N11->N67
+
+
+
+ 0.03s
+
+
+
+
+N76
+
+binary
+(*decoder)
+uint16
+0.06s (0.63%)
+
+
+
+
+N11->N76
+
+
+
+ 0.06s
+ (inline)
+
+
+
+
+N22
+
+struc
+fieldCacheLookup
+0.16s (1.69%)
+of 1.85s (19.51%)
+
+
+
+
+N12->N22
+
+
+
+ 1.85s
+ (inline)
+
+
+
+
+N69
+
+reflect
+Value
+Type
+0.07s (0.74%)
+
+
+
+
+N12->N69
+
+
+
+ 0.07s
+ (inline)
+
+
+
+
+N15
+
+runtime
+makeslice
+0.08s (0.84%)
+of 1.03s (10.86%)
+
+
+
+
+N13->N15
+
+
+
+ 0.10s
+
+
+
+
+N18
+
+binary
+Read
+0 of 1.05s (11.08%)
+
+
+
+
+N13->N18
+
+
+
+ 1.05s
+
+
+
+
+N44
+
+bytes
+NewReader
+0.01s (0.11%)
+of 0.28s (2.95%)
+
+
+
+
+N13->N44
+
+
+
+ 0.17s
+ (inline)
+
+
+
+
+N48
+
+bytes
+(*Reader)
+Read
+0.06s (0.63%)
+of 0.13s (1.37%)
+
+
+
+
+N13->N48
+
+
+
+ 0.04s
+ (inline)
+
+
+
+
+N14->N15
+
+
+
+ 0.04s
+
+
+
+
+N24
+
+sync
+(*Mutex)
+Unlock
+0.40s (4.22%)
+
+
+
+
+N14->N24
+
+
+
+ 0.40s
+ (inline)
+
+
+
+
+N15->N5
+
+
+
+ 0.95s
+
+
+
+
+N16->N15
+
+
+
+ 0.79s
+
+
+
+
+N36
+
+runtime
+memmove
+0.14s (1.48%)
+
+
+
+
+N16->N36
+
+
+
+ 0.05s
+
+
+
+
+N17
+
+runtime
+systemstack
+0 of 0.59s (6.22%)
+
+
+
+
+N80
+
+runtime
+gcBgMarkWorker
+func2
+0 of 0.36s (3.80%)
+
+
+
+
+N17->N80
+
+
+
+ 0.36s
+
+
+
+
+N18->N11
+
+
+
+ 0.74s
+
+
+
+
+N18->N15
+
+
+
+ 0.10s
+
+
+
+
+N18->N59
+
+
+
+ 0.05s
+ (inline)
+
+
+
+
+N72
+
+binary
+dataSize
+0.03s (0.32%)
+of 0.13s (1.37%)
+
+
+
+
+N18->N72
+
+
+
+ 0.13s
+
+
+
+
+N20
+
+struc
+(*Field)
+unpackSingleValue
+0.13s (1.37%)
+of 0.41s (4.32%)
+
+
+
+
+N19->N20
+
+
+
+ 0.27s
+
+
+
+
+N35
+
+struc
+(*Field)
+unpackSliceValue
+0.05s (0.53%)
+of 0.30s (3.16%)
+
+
+
+
+N19->N35
+
+
+
+ 0.30s
+
+
+
+
+N19->N41
+
+
+
+ 0.03s
+
+
+
+
+N20->N41
+
+
+
+ 0.03s
+
+
+
+
+N42
+
+struc
+(*Field)
+unpackIntegerValue
+0.13s (1.37%)
+of 0.22s (2.32%)
+
+
+
+
+N20->N42
+
+
+
+ 0.22s
+
+
+
+
+N29
+
+abi
+(*Type)
+Kind
+0.19s (2.00%)
+
+
+
+
+N21->N29
+
+
+
+ 0.05s
+ (inline)
+
+
+
+
+N22->N10
+
+
+
+ 1.69s
+
+
+
+
+N23->N5
+
+
+
+ 0.20s
+
+
+
+
+N23->N12
+
+
+
+ 0.26s
+
+
+
+
+N23->N29
+
+
+
+ 0.03s
+ (inline)
+
+
+
+
+N25
+
+runtime
+newobject
+0.01s (0.11%)
+of 0.51s (5.38%)
+
+
+
+
+N25->N5
+
+
+
+ 0.50s
+
+
+
+
+N26->N29
+
+
+
+ 0.11s
+ (inline)
+
+
+
+
+N27->N2
+
+
+
+ 1.55s
+ (inline)
+
+
+
+
+N53
+
+bytes
+NewBuffer
+0 of 0.18s (1.90%)
+
+
+
+
+N27->N53
+
+
+
+ 0.09s
+ (inline)
+
+
+
+
+N28->N2
+
+
+
+ 1.47s
+ (inline)
+
+
+
+
+N28->N44
+
+
+
+ 0.11s
+ (inline)
+
+
+
+
+N30
+
+io
+ReadAtLeast
+0.14s (1.48%)
+of 0.31s (3.27%)
+
+
+
+
+N30->N48
+
+
+
+ 0.09s
+
+
+
+
+N73
+
+bytes
+(*Buffer)
+Read
+0.06s (0.63%)
+of 0.08s (0.84%)
+
+
+
+
+N30->N73
+
+
+
+ 0.08s
+
+
+
+
+N31
+
+runtime
+gcDrain
+0 of 0.36s (3.80%)
+
+
+
+
+N52
+
+runtime
+scanobject
+0.07s (0.74%)
+of 0.14s (1.48%)
+
+
+
+
+N31->N52
+
+
+
+ 0.13s
+
+
+
+
+N56
+
+runtime
+markroot
+0 of 0.15s (1.58%)
+
+
+
+
+N31->N56
+
+
+
+ 0.13s
+
+
+
+
+N61
+
+runtime
+preemptone
+0 of 0.17s (1.79%)
+
+
+
+
+N31->N61
+
+
+
+ 0.10s
+
+
+
+
+N43
+
+runtime
+typehash
+0.09s (0.95%)
+of 0.29s (3.06%)
+
+
+
+
+N32->N43
+
+
+
+ 0.29s
+
+
+
+
+N33->N7
+
+
+
+ 2.39s
+
+
+
+
+N35->N20
+
+
+
+ 0.14s
+
+
+
+
+N35->N21
+
+
+
+ 0.08s
+
+
+
+
+N37
+
+runtime
+stdcall2
+0.17s (1.79%)
+
+
+
+
+N38->N2
+
+
+
+ 1.52s
+ (inline)
+
+
+
+
+N38->N53
+
+
+
+ 0.08s
+ (inline)
+
+
+
+
+N39
+
+runtime
+gcBgMarkWorker
+0.02s (0.21%)
+of 0.29s (3.06%)
+
+
+
+
+N39->N17
+
+
+
+ 0.27s
+
+
+
+
+N40
+
+runtime
+memhash64
+0.20s (2.11%)
+
+
+
+
+N42->N57
+
+
+
+ 0.02s
+
+
+
+
+N42->N67
+
+
+
+ 0.02s
+
+
+
+
+N43->N40
+
+
+
+ 0.20s
+
+
+
+
+N44->N25
+
+
+
+ 0.27s
+
+
+
+
+N46->N25
+
+
+
+ 0.07s
+
+
+
+
+N47
+
+runtime
+schedule
+0 of 0.21s (2.22%)
+
+
+
+
+N55
+
+runtime
+stdcall1
+0.06s (0.63%)
+
+
+
+
+N47->N55
+
+
+
+ 0.02s
+
+
+
+
+N65
+
+runtime
+findRunnable
+0.01s (0.11%)
+of 0.18s (1.90%)
+
+
+
+
+N47->N65
+
+
+
+ 0.18s
+
+
+
+
+N48->N36
+
+
+
+ 0.07s
+
+
+
+
+N77
+
+reflect
+flag
+kind
+0.06s (0.63%)
+
+
+
+
+N49->N77
+
+
+
+ 0.06s
+ (inline)
+
+
+
+
+N68
+
+runtime
+findObject
+0.05s (0.53%)
+
+
+
+
+N52->N68
+
+
+
+ 0.02s
+
+
+
+
+N53->N25
+
+
+
+ 0.17s
+
+
+
+
+N56->N52
+
+
+
+ 0.01s
+
+
+
+
+N62
+
+runtime
+scanblock
+0.06s (0.63%)
+of 0.11s (1.16%)
+
+
+
+
+N56->N62
+
+
+
+ 0.11s
+
+
+
+
+N75
+
+runtime
+(*mheap)
+allocSpan
+0.01s (0.11%)
+of 0.07s (0.74%)
+
+
+
+
+N56->N75
+
+
+
+ 0.01s
+
+
+
+
+N59->N30
+
+
+
+ 0.31s
+
+
+
+
+N60
+
+runtime
+preemptM
+0 of 0.17s (1.79%)
+
+
+
+
+N60->N37
+
+
+
+ 0.13s
+
+
+
+
+N60->N55
+
+
+
+ 0.02s
+
+
+
+
+N66
+
+runtime
+lock
+0 of 0.10s (1.05%)
+
+
+
+
+N60->N66
+
+
+
+ 0.02s
+ (inline)
+
+
+
+
+N61->N60
+
+
+
+ 0.17s
+
+
+
+
+N62->N68
+
+
+
+ 0.03s
+
+
+
+
+N64
+
+runtime
+mcall
+0 of 0.16s (1.69%)
+
+
+
+
+N64->N47
+
+
+
+ 0.16s
+
+
+
+
+N65->N66
+
+
+
+ 0.03s
+ (inline)
+
+
+
+
+N79
+
+runtime
+lock2
+0.01s (0.11%)
+of 0.10s (1.05%)
+
+
+
+
+N66->N79
+
+
+
+ 0.10s
+
+
+
+
+N71
+
+runtime
+goschedImpl
+0 of 0.09s (0.95%)
+
+
+
+
+N71->N47
+
+
+
+ 0.02s
+
+
+
+
+N71->N55
+
+
+
+ 0.02s
+
+
+
+
+N71->N66
+
+
+
+ 0.04s
+ (inline)
+
+
+
+
+N72->N10
+
+
+
+ 0.10s
+
+
+
+
+N73->N36
+
+
+
+ 0.02s
+
+
+
+
+N74->N17
+
+
+
+ 0.02s
+
+
+
+
+N78->N47
+
+
+
+ 0.03s
+
+
+
+
+N78->N71
+
+
+
+ 0.09s
+
+
+
+
+N79->N37
+
+
+
+ 0.04s
+
+
+
+
+N80->N31
+
+
+
+ 0.36s
+
+
+
+
diff --git a/pprof/cpu_encode.svg b/pprof/cpu_encode.svg
new file mode 100644
index 0000000..0ee0655
--- /dev/null
+++ b/pprof/cpu_encode.svg
@@ -0,0 +1,2800 @@
+
+
+
+
+
+
+struc.test.exe
+
+cluster_L
+
+
+
+File: struc.test.exe
+
+File: struc.test.exe
+Build ID: D:\progames\GolandProjects\struc\struc.test.exe2025-01-19 09:36:36 +0800 CST
+Type: cpu
+Time: Jan 19, 2025 at 9:39am (CST)
+Duration: 9.21s, Total samples = 10.58s (114.92%)
+Showing nodes accounting for 8.80s, 83.18% of 10.58s total
+Dropped 179 nodes (cum <= 0.05s)
+Dropped 14 edges (freq <= 0.01s)
+Showing top 80 nodes out of 120
+See https://git.io/JfYMW for how to read the graph
+
+
+
+
+N1
+
+testing
+(*B)
+runN
+0 of 8.79s (83.08%)
+
+
+
+
+N23
+
+struc
+BenchmarkStdlibEncode
+0.01s (0.095%)
+of 1.36s (12.85%)
+
+
+
+
+N1->N23
+
+
+
+ 1.36s
+
+
+
+
+N29
+
+struc
+BenchmarkManualEncode
+0.12s (1.13%)
+of 1.60s (15.12%)
+
+
+
+
+N1->N29
+
+
+
+ 1.60s
+
+
+
+
+N34
+
+struc
+BenchmarkEncode
+0.01s (0.095%)
+of 1.65s (15.60%)
+
+
+
+
+N1->N34
+
+
+
+ 1.65s
+
+
+
+
+N43
+
+struc
+BenchmarkArrayEncode
+0 of 1.53s (14.46%)
+
+
+
+
+N1->N43
+
+
+
+ 1.53s
+
+
+
+
+N47
+
+struc
+BenchmarkSliceEncode
+0 of 1.58s (14.93%)
+
+
+
+
+N1->N47
+
+
+
+ 1.58s
+
+
+
+
+N59
+
+struc
+BenchmarkFullEncode
+0 of 1.07s (10.11%)
+
+
+
+
+N1->N59
+
+
+
+ 1.07s
+
+
+
+
+N2
+
+struc
+Pack
+0.01s (0.095%)
+of 5.56s (52.55%)
+
+
+
+
+N4
+
+struc
+PackWithOptions
+0.05s (0.47%)
+of 5.55s (52.46%)
+
+
+
+
+N2->N4
+
+
+
+ 5.55s
+
+
+
+
+N3
+
+runtime
+mallocgc
+0.92s (8.70%)
+of 2.43s (22.97%)
+
+
+
+
+N31
+
+runtime
+nextFreeFast
+0.43s (4.06%)
+
+
+
+
+N3->N31
+
+
+
+ 0.43s
+ (inline)
+
+
+
+
+N42
+
+runtime
+memclrNoHeapPointers
+0.18s (1.70%)
+
+
+
+
+N3->N42
+
+
+
+ 0.17s
+
+
+
+
+N56
+
+runtime
+acquirem
+0.11s (1.04%)
+
+
+
+
+N3->N56
+
+
+
+ 0.11s
+ (inline)
+
+
+
+
+N66
+
+runtime
+gcmarknewobject
+0.04s (0.38%)
+of 0.13s (1.23%)
+
+
+
+
+N3->N66
+
+
+
+ 0.13s
+
+
+
+
+N67
+
+runtime
+(*mcache)
+refill
+0.01s (0.095%)
+of 0.12s (1.13%)
+
+
+
+
+N3->N67
+
+
+
+ 0.12s
+
+
+
+
+N70
+
+runtime
+heapSetType
+0.03s (0.28%)
+of 0.16s (1.51%)
+
+
+
+
+N3->N70
+
+
+
+ 0.16s
+
+
+
+
+N74
+
+runtime
+deductAssistCredit
+0.06s (0.57%)
+of 0.08s (0.76%)
+
+
+
+
+N3->N74
+
+
+
+ 0.08s
+
+
+
+
+N75
+
+runtime
+publicationBarrier
+0.06s (0.57%)
+
+
+
+
+N3->N75
+
+
+
+ 0.06s
+
+
+
+
+N6
+
+struc
+Fields
+Pack
+0.42s (3.97%)
+of 3.08s (29.11%)
+
+
+
+
+N4->N6
+
+
+
+ 3.08s
+
+
+
+
+N7
+
+bytes
+(*Buffer)
+Write
+0.22s (2.08%)
+of 2.15s (20.32%)
+
+
+
+
+N4->N7
+
+
+
+ 0.42s
+
+
+
+
+N14
+
+struc
+Fields
+Sizeof
+0.24s (2.27%)
+of 1.05s (9.92%)
+
+
+
+
+N4->N14
+
+
+
+ 1.05s
+
+
+
+
+N16
+
+runtime
+makeslice
+0.09s (0.85%)
+of 1.81s (17.11%)
+
+
+
+
+N4->N16
+
+
+
+ 0.16s
+
+
+
+
+N21
+
+struc
+prepareValueForPacking
+0.05s (0.47%)
+of 0.78s (7.37%)
+
+
+
+
+N4->N21
+
+
+
+ 0.78s
+
+
+
+
+N5
+
+testing
+(*B)
+launch
+0 of 8.79s (83.08%)
+
+
+
+
+N5->N1
+
+
+
+ 8.79s
+
+
+
+
+N11
+
+struc
+(*Field)
+Pack
+0.07s (0.66%)
+of 2.42s (22.87%)
+
+
+
+
+N6->N11
+
+
+
+ 2.42s
+
+
+
+
+N13
+
+reflect
+Value
+Field
+0.31s (2.93%)
+of 0.64s (6.05%)
+
+
+
+
+N6->N13
+
+
+
+ 0.28s
+
+
+
+
+N77
+
+reflect
+Value
+FieldByIndex
+0.02s (0.19%)
+of 0.06s (0.57%)
+
+
+
+
+N6->N77
+
+
+
+ 0.06s
+
+
+
+
+N22
+
+bytes
+(*Buffer)
+grow
+0.08s (0.76%)
+of 1.77s (16.73%)
+
+
+
+
+N7->N22
+
+
+
+ 1.77s
+
+
+
+
+N38
+
+runtime
+memmove
+0.17s (1.61%)
+
+
+
+
+N7->N38
+
+
+
+ 0.14s
+
+
+
+
+N8
+
+runtime
+systemstack
+0.01s (0.095%)
+of 1.48s (13.99%)
+
+
+
+
+N76
+
+runtime
+stdcall3
+0.06s (0.57%)
+
+
+
+
+N8->N76
+
+
+
+ 0.06s
+
+
+
+
+N79
+
+runtime
+(*sweepLocked)
+sweep
+(*mheap)
+freeSpan
+func3
+0 of 0.13s (1.23%)
+
+
+
+
+N8->N79
+
+
+
+ 0.12s
+
+
+
+
+N80
+
+runtime
+gcBgMarkWorker
+func2
+0 of 0.97s (9.17%)
+
+
+
+
+N8->N80
+
+
+
+ 0.97s
+
+
+
+
+N9
+
+struc
+(*Field)
+packSingleValue
+0.36s (3.40%)
+of 1.06s (10.02%)
+
+
+
+
+N9->N6
+
+
+
+ 0.20s
+
+
+
+
+N27
+
+struc
+Type
+Resolve
+0.24s (2.27%)
+
+
+
+
+N9->N27
+
+
+
+ 0.10s
+
+
+
+
+N37
+
+struc
+(*Field)
+packIntegerValue
+0.15s (1.42%)
+of 0.34s (3.21%)
+
+
+
+
+N9->N37
+
+
+
+ 0.34s
+
+
+
+
+N63
+
+struc
+(*Field)
+determineByteOrder
+0.09s (0.85%)
+
+
+
+
+N9->N63
+
+
+
+ 0.09s
+ (inline)
+
+
+
+
+N10
+
+struc
+(*Field)
+packGenericSlice
+0.48s (4.54%)
+of 1.62s (15.31%)
+
+
+
+
+N10->N9
+
+
+
+ 0.63s
+
+
+
+
+N12
+
+reflect
+Value
+Index
+0.53s (5.01%)
+of 0.80s (7.56%)
+
+
+
+
+N10->N12
+
+
+
+ 0.49s
+
+
+
+
+N10->N27
+
+
+
+ 0.02s
+
+
+
+
+N11->N9
+
+
+
+ 0.45s
+
+
+
+
+N19
+
+struc
+(*Field)
+packSliceValue
+0.09s (0.85%)
+of 1.83s (17.30%)
+
+
+
+
+N11->N19
+
+
+
+ 1.83s
+
+
+
+
+N11->N27
+
+
+
+ 0.09s
+
+
+
+
+N20
+
+abi
+(*Type)
+Kind
+0.34s (3.21%)
+
+
+
+
+N12->N20
+
+
+
+ 0.10s
+ (inline)
+
+
+
+
+N64
+
+reflect
+add
+0.09s (0.85%)
+
+
+
+
+N12->N64
+
+
+
+ 0.09s
+ (inline)
+
+
+
+
+N71
+
+reflect
+arrayAt
+0.07s (0.66%)
+
+
+
+
+N12->N71
+
+
+
+ 0.07s
+ (inline)
+
+
+
+
+N13->N20
+
+
+
+ 0.22s
+ (inline)
+
+
+
+
+N58
+
+abi
+Name
+IsExported
+0.10s (0.95%)
+
+
+
+
+N13->N58
+
+
+
+ 0.10s
+ (inline)
+
+
+
+
+N14->N13
+
+
+
+ 0.21s
+
+
+
+
+N24
+
+struc
+(*Field)
+Size
+0.10s (0.95%)
+of 0.77s (7.28%)
+
+
+
+
+N14->N24
+
+
+
+ 0.77s
+
+
+
+
+N15
+
+binary
+Write
+0.02s (0.19%)
+of 1.13s (10.68%)
+
+
+
+
+N15->N7
+
+
+
+ 0.26s
+
+
+
+
+N15->N16
+
+
+
+ 0.06s
+
+
+
+
+N18
+
+binary
+(*encoder)
+value
+0.29s (2.74%)
+of 0.70s (6.62%)
+
+
+
+
+N15->N18
+
+
+
+ 0.70s
+
+
+
+
+N41
+
+sync
+(*Map)
+Load
+0.02s (0.19%)
+of 0.43s (4.06%)
+
+
+
+
+N15->N41
+
+
+
+ 0.07s
+
+
+
+
+N16->N3
+
+
+
+ 1.72s
+
+
+
+
+N17
+
+runtime
+gcDrain
+0.03s (0.28%)
+of 0.97s (9.17%)
+
+
+
+
+N28
+
+runtime
+scanobject
+0.12s (1.13%)
+of 0.46s (4.35%)
+
+
+
+
+N17->N28
+
+
+
+ 0.46s
+
+
+
+
+N49
+
+runtime
+preemptone
+0 of 0.36s (3.40%)
+
+
+
+
+N17->N49
+
+
+
+ 0.27s
+
+
+
+
+N78
+
+runtime
+markroot
+0 of 0.20s (1.89%)
+
+
+
+
+N17->N78
+
+
+
+ 0.19s
+
+
+
+
+N18->N12
+
+
+
+ 0.06s
+
+
+
+
+N18->N13
+
+
+
+ 0.11s
+
+
+
+
+N45
+
+reflect
+flag
+kind
+0.10s (0.95%)
+
+
+
+
+N18->N45
+
+
+
+ 0.05s
+ (inline)
+
+
+
+
+N19->N10
+
+
+
+ 1.62s
+
+
+
+
+N19->N27
+
+
+
+ 0.02s
+
+
+
+
+N19->N45
+
+
+
+ 0.03s
+ (inline)
+
+
+
+
+N61
+
+struc
+parseFields
+0.03s (0.28%)
+of 0.42s (3.97%)
+
+
+
+
+N21->N61
+
+
+
+ 0.42s
+
+
+
+
+N65
+
+runtime
+convTslice
+0.03s (0.28%)
+of 0.24s (2.27%)
+
+
+
+
+N21->N65
+
+
+
+ 0.24s
+
+
+
+
+N22->N16
+
+
+
+ 1.59s
+
+
+
+
+N23->N7
+
+
+
+ 0.02s
+
+
+
+
+N23->N15
+
+
+
+ 1.13s
+
+
+
+
+N25
+
+runtime
+newobject
+0 of 0.46s (4.35%)
+
+
+
+
+N23->N25
+
+
+
+ 0.20s
+
+
+
+
+N26
+
+struc
+(*Field)
+calculateStructSize
+0.12s (1.13%)
+of 0.54s (5.10%)
+
+
+
+
+N24->N26
+
+
+
+ 0.54s
+
+
+
+
+N73
+
+struc
+(*Field)
+calculateBasicSize
+0.06s (0.57%)
+of 0.07s (0.66%)
+
+
+
+
+N24->N73
+
+
+
+ 0.07s
+
+
+
+
+N25->N3
+
+
+
+ 0.46s
+
+
+
+
+N26->N12
+
+
+
+ 0.25s
+
+
+
+
+N26->N14
+
+
+
+ 0.17s
+
+
+
+
+N33
+
+runtime
+findObject
+0.16s (1.51%)
+of 0.20s (1.89%)
+
+
+
+
+N28->N33
+
+
+
+ 0.12s
+
+
+
+
+N57
+
+runtime
+typePointers
+next
+0.10s (0.95%)
+of 0.11s (1.04%)
+
+
+
+
+N28->N57
+
+
+
+ 0.11s
+
+
+
+
+N29->N7
+
+
+
+ 1.45s
+
+
+
+
+N29->N38
+
+
+
+ 0.02s
+
+
+
+
+N30
+
+runtime
+gcBgMarkWorker
+0.01s (0.095%)
+of 0.79s (7.47%)
+
+
+
+
+N30->N8
+
+
+
+ 0.76s
+
+
+
+
+N32
+
+runtime
+stdcall2
+0.30s (2.84%)
+
+
+
+
+N34->N2
+
+
+
+ 1.54s
+ (inline)
+
+
+
+
+N34->N25
+
+
+
+ 0.10s
+
+
+
+
+N35
+
+runtime
+mapaccess2
+0.23s (2.17%)
+of 0.39s (3.69%)
+
+
+
+
+N36
+
+runtime
+preemptM
+0.01s (0.095%)
+of 0.36s (3.40%)
+
+
+
+
+N36->N32
+
+
+
+ 0.22s
+
+
+
+
+N39
+
+runtime
+lock
+0 of 0.21s (1.98%)
+
+
+
+
+N36->N39
+
+
+
+ 0.06s
+ (inline)
+
+
+
+
+N46
+
+runtime
+stdcall1
+0.11s (1.04%)
+
+
+
+
+N36->N46
+
+
+
+ 0.05s
+
+
+
+
+N55
+
+struc
+(*Field)
+writeInteger
+0.09s (0.85%)
+of 0.13s (1.23%)
+
+
+
+
+N37->N55
+
+
+
+ 0.13s
+
+
+
+
+N44
+
+runtime
+lock2
+0.06s (0.57%)
+of 0.21s (1.98%)
+
+
+
+
+N39->N44
+
+
+
+ 0.21s
+
+
+
+
+N40
+
+runtime
+(*sweepLocked)
+sweep
+0.03s (0.28%)
+of 0.22s (2.08%)
+
+
+
+
+N40->N8
+
+
+
+ 0.11s
+
+
+
+
+N68
+
+runtime
+(*spanSet)
+push
+0.03s (0.28%)
+of 0.06s (0.57%)
+
+
+
+
+N40->N68
+
+
+
+ 0.03s
+
+
+
+
+N41->N35
+
+
+
+ 0.39s
+
+
+
+
+N43->N2
+
+
+
+ 1.46s
+ (inline)
+
+
+
+
+N43->N25
+
+
+
+ 0.07s
+
+
+
+
+N44->N32
+
+
+
+ 0.08s
+
+
+
+
+N72
+
+runtime
+procyield
+0.07s (0.66%)
+
+
+
+
+N44->N72
+
+
+
+ 0.07s
+
+
+
+
+N47->N2
+
+
+
+ 1.52s
+ (inline)
+
+
+
+
+N47->N25
+
+
+
+ 0.06s
+
+
+
+
+N48
+
+runtime
+bgsweep
+0 of 0.27s (2.55%)
+
+
+
+
+N48->N40
+
+
+
+ 0.21s
+
+
+
+
+N49->N36
+
+
+
+ 0.36s
+
+
+
+
+N50
+
+runtime
+scanblock
+0.13s (1.23%)
+of 0.18s (1.70%)
+
+
+
+
+N50->N33
+
+
+
+ 0.05s
+
+
+
+
+N51
+
+runtime
+goschedImpl
+0 of 0.11s (1.04%)
+
+
+
+
+N51->N39
+
+
+
+ 0.03s
+ (inline)
+
+
+
+
+N51->N46
+
+
+
+ 0.05s
+
+
+
+
+N69
+
+runtime
+schedule
+0 of 0.19s (1.80%)
+
+
+
+
+N51->N69
+
+
+
+ 0.02s
+
+
+
+
+N52
+
+runtime
+findRunnable
+0.01s (0.095%)
+of 0.18s (1.70%)
+
+
+
+
+N52->N39
+
+
+
+ 0.06s
+ (inline)
+
+
+
+
+N53
+
+runtime
+(*mspan)
+writeHeapBitsSmall
+0.10s (0.95%)
+of 0.13s (1.23%)
+
+
+
+
+N54
+
+runtime
+(*mspan)
+base
+0.09s (0.85%)
+
+
+
+
+N59->N2
+
+
+
+ 1.04s
+ (inline)
+
+
+
+
+N59->N25
+
+
+
+ 0.03s
+
+
+
+
+N60
+
+runtime
+mcall
+0 of 0.19s (1.80%)
+
+
+
+
+N60->N69
+
+
+
+ 0.17s
+
+
+
+
+N62
+
+struc
+fieldCacheLookup
+0.03s (0.28%)
+of 0.39s (3.69%)
+
+
+
+
+N61->N62
+
+
+
+ 0.39s
+ (inline)
+
+
+
+
+N62->N41
+
+
+
+ 0.36s
+
+
+
+
+N65->N3
+
+
+
+ 0.21s
+
+
+
+
+N66->N54
+
+
+
+ 0.08s
+ (inline)
+
+
+
+
+N67->N8
+
+
+
+ 0.07s
+
+
+
+
+N67->N68
+
+
+
+ 0.03s
+
+
+
+
+N69->N52
+
+
+
+ 0.18s
+
+
+
+
+N70->N53
+
+
+
+ 0.13s
+
+
+
+
+N74->N8
+
+
+
+ 0.02s
+
+
+
+
+N77->N13
+
+
+
+ 0.04s
+
+
+
+
+N78->N50
+
+
+
+ 0.18s
+
+
+
+
+N79->N39
+
+
+
+ 0.05s
+
+
+
+
+N80->N17
+
+
+
+ 0.97s
+
+
+
+
diff --git a/struc.go b/struc.go
index d83d9f6..2c38036 100644
--- a/struc.go
+++ b/struc.go
@@ -1,122 +1,150 @@
+// Package struc 实现了 Go 结构体的二进制打包和解包功能。
+// 它提供了高效的序列化和反序列化方法，支持自定义类型、字节对齐和不同的字节序。
+//
+// Features:
+// - 支持基本类型和复杂结构体的序列化
+// - 支持自定义类型的序列化接口
+// - 支持字节对齐和字节序控制
+// - 提供高性能的内存管理
+// - 支持指针和嵌套结构
package struc
import (
- "encoding/binary"
"fmt"
"io"
"reflect"
)
-type Options struct {
- ByteAlign int
- PtrSize int
- Order binary.ByteOrder
-}
+// packingSlicePool 是用于打包和解包的切片池
+// 用于存储和重用字节切片, 提高性能
+var packingSlicePool = NewBytesSlicePool(0)
-func (o *Options) Validate() error {
- if o.PtrSize == 0 {
- o.PtrSize = 32
- } else {
- switch o.PtrSize {
- case 8, 16, 32, 64:
- default:
- return fmt.Errorf("Invalid Options.PtrSize: %d. Must be in (8, 16, 32, 64)", o.PtrSize)
- }
- }
- return nil
+// Pack 使用默认选项将数据打包到写入器中
+// 这是一个便捷方法，内部调用 PackWithOptions
+func Pack(writer io.Writer, data interface{}) error {
+ return PackWithOptions(writer, data, nil)
}
-var emptyOptions = &Options{}
-
-func init() {
- // fill default values to avoid data race to be reported by race detector.
- emptyOptions.Validate()
-}
-
-func prep(data interface{}) (reflect.Value, Packer, error) {
- value := reflect.ValueOf(data)
- for value.Kind() == reflect.Ptr {
- next := value.Elem().Kind()
- if next == reflect.Struct || next == reflect.Ptr {
- value = value.Elem()
- } else {
- break
- }
- }
- switch value.Kind() {
- case reflect.Struct:
- fields, err := parseFields(value)
- return value, fields, err
- default:
- if !value.IsValid() {
- return reflect.Value{}, nil, fmt.Errorf("Invalid reflect.Value for %+v", data)
- }
- if c, ok := data.(Custom); ok {
- return value, customFallback{c}, nil
- }
- return value, binaryFallback(value), nil
- }
-}
-
-func Pack(w io.Writer, data interface{}) error {
- return PackWithOptions(w, data, nil)
-}
-
-func PackWithOptions(w io.Writer, data interface{}, options *Options) error {
+// PackWithOptions 使用指定的选项将数据打包到写入器中
+// 支持自定义选项，如字节对齐和字节序
+func PackWithOptions(writer io.Writer, data interface{}, options *Options) error {
if options == nil {
- options = emptyOptions
+ options = defaultPackingOptions
}
if err := options.Validate(); err != nil {
- return err
+ return fmt.Errorf("invalid options: %w", err)
}
- val, packer, err := prep(data)
+
+ value, packer, err := prepareValueForPacking(data)
if err != nil {
- return err
+ return fmt.Errorf("preparation failed: %w", err)
+ }
+
+ if value.Type().Kind() == reflect.String {
+ value = value.Convert(reflect.TypeOf([]byte{}))
}
- if val.Type().Kind() == reflect.String {
- val = val.Convert(reflect.TypeOf([]byte{}))
+
+ bufferSize := packer.Sizeof(value, options)
+ buffer := packingSlicePool.GetSlice(bufferSize)
+
+ if _, err := packer.Pack(buffer, value, options); err != nil {
+ return fmt.Errorf("packing failed: %w", err)
}
- size := packer.Sizeof(val, options)
- buf := make([]byte, size)
- if _, err := packer.Pack(buf, val, options); err != nil {
- return err
+
+ if _, err = writer.Write(buffer); err != nil {
+ return fmt.Errorf("writing failed: %w", err)
}
- _, err = w.Write(buf)
- return err
+
+ return nil
}
-func Unpack(r io.Reader, data interface{}) error {
- return UnpackWithOptions(r, data, nil)
+// Unpack 使用默认选项从读取器中解包数据
+// 这是一个便捷方法，内部调用 UnpackWithOptions
+func Unpack(reader io.Reader, data interface{}) error {
+ return UnpackWithOptions(reader, data, nil)
}
-func UnpackWithOptions(r io.Reader, data interface{}, options *Options) error {
+// UnpackWithOptions 使用指定的选项从读取器中解包数据
+// 支持自定义选项，如字节对齐和字节序
+func UnpackWithOptions(reader io.Reader, data interface{}, options *Options) error {
if options == nil {
- options = emptyOptions
+ options = defaultPackingOptions
}
if err := options.Validate(); err != nil {
- return err
+ return fmt.Errorf("invalid options: %w", err)
}
- val, packer, err := prep(data)
+
+ value, packer, err := prepareValueForPacking(data)
if err != nil {
- return err
+ return fmt.Errorf("preparation failed: %w", err)
}
- return packer.Unpack(r, val, options)
+
+ return packer.Unpack(reader, value, options)
}
+// Sizeof 使用默认选项返回打包数据的大小
+// 这是一个便捷方法，内部调用 SizeofWithOptions
func Sizeof(data interface{}) (int, error) {
return SizeofWithOptions(data, nil)
}
+// SizeofWithOptions 使用指定的选项返回打包数据的大小
+// 支持自定义选项，如字节对齐和字节序
func SizeofWithOptions(data interface{}, options *Options) (int, error) {
if options == nil {
- options = emptyOptions
+ options = defaultPackingOptions
}
if err := options.Validate(); err != nil {
- return 0, err
+ return 0, fmt.Errorf("invalid options: %w", err)
}
- val, packer, err := prep(data)
+
+ value, packer, err := prepareValueForPacking(data)
if err != nil {
- return 0, err
+ return 0, fmt.Errorf("preparation failed: %w", err)
+ }
+
+ return packer.Sizeof(value, options), nil
+}
+
+// prepareValueForPacking 准备一个值用于打包或解包
+// 处理指针解引用、类型检查和打包器选择
+func prepareValueForPacking(data interface{}) (reflect.Value, Packer, error) {
+ if data == nil {
+ return reflect.Value{}, nil, fmt.Errorf("cannot pack/unpack nil data")
}
- return packer.Sizeof(val, options), nil
+
+ value := reflect.ValueOf(data)
+
+ // 解引用指针直到获取非指针类型
+ for value.Kind() == reflect.Ptr {
+ next := value.Elem().Kind()
+ if next == reflect.Struct || next == reflect.Ptr {
+ value = value.Elem()
+ } else {
+ break
+ }
+ }
+
+ var packer Packer
+ var err error
+
+ switch value.Kind() {
+ case reflect.Struct:
+ if fields, err := parseFields(value); err != nil {
+ return reflect.Value{}, nil, fmt.Errorf("failed to parse fields: %w", err)
+ } else {
+ packer = fields
+ }
+ default:
+ if !value.IsValid() {
+ return reflect.Value{}, nil, fmt.Errorf("invalid reflect.Value for %+v", data)
+ }
+ if customPacker, ok := data.(CustomBinaryer); ok {
+ packer = customBinaryerFallback{customPacker}
+ } else {
+ packer = binaryFallback(value)
+ }
+ }
+
+ return value, packer, err
}
diff --git a/struc_test.go b/struc_test.go
index f590bb2..f90307c 100644
--- a/struc_test.go
+++ b/struc_test.go
@@ -74,7 +74,7 @@ type Example struct {
CustomTypeSizeArr []byte // "ABCD"
}
-var five = 5
+var testFive = 5
type ExampleStructWithin struct {
a uint8
@@ -90,7 +90,7 @@ type ExampleArray struct {
Props [16]ExampleStructWithin `struc:"[16]ExampleStructWithin"`
}
-var arraySliceReferenceBytes = []byte{
+var testArraySliceBytes = []byte{
16,
0, 0, 0, 1,
0, 0, 0, 1,
@@ -111,51 +111,51 @@ var arraySliceReferenceBytes = []byte{
0, 0, 0, 16,
}
-var arrayReference = &ExampleArray{
+var testArrayExample = &ExampleArray{
16,
[16]ExampleStructWithin{
- ExampleStructWithin{1},
- ExampleStructWithin{2},
- ExampleStructWithin{3},
- ExampleStructWithin{4},
- ExampleStructWithin{5},
- ExampleStructWithin{6},
- ExampleStructWithin{7},
- ExampleStructWithin{8},
- ExampleStructWithin{9},
- ExampleStructWithin{10},
- ExampleStructWithin{11},
- ExampleStructWithin{12},
- ExampleStructWithin{13},
- ExampleStructWithin{14},
- ExampleStructWithin{15},
- ExampleStructWithin{16},
+ {1},
+ {2},
+ {3},
+ {4},
+ {5},
+ {6},
+ {7},
+ {8},
+ {9},
+ {10},
+ {11},
+ {12},
+ {13},
+ {14},
+ {15},
+ {16},
},
}
-var sliceReference = &ExampleSlice{
+var testSliceExample = &ExampleSlice{
16,
[]ExampleStructWithin{
- ExampleStructWithin{1},
- ExampleStructWithin{2},
- ExampleStructWithin{3},
- ExampleStructWithin{4},
- ExampleStructWithin{5},
- ExampleStructWithin{6},
- ExampleStructWithin{7},
- ExampleStructWithin{8},
- ExampleStructWithin{9},
- ExampleStructWithin{10},
- ExampleStructWithin{11},
- ExampleStructWithin{12},
- ExampleStructWithin{13},
- ExampleStructWithin{14},
- ExampleStructWithin{15},
- ExampleStructWithin{16},
+ {1},
+ {2},
+ {3},
+ {4},
+ {5},
+ {6},
+ {7},
+ {8},
+ {9},
+ {10},
+ {11},
+ {12},
+ {13},
+ {14},
+ {15},
+ {16},
},
}
-var reference = &Example{
+var testExample = &Example{
nil,
1, 2, 3, 4, 5, 6, 7, 8, 0, []byte{'a', 'b', 'c', 'd'},
9, 10, 11, 12, 13, 14, 15, 16, true, false, [4]byte{'e', 'f', 'g', 'h'},
@@ -168,13 +168,13 @@ var reference = &Example{
4, []byte("5678"),
7, "ijklmno", "pqrstuv",
4, []byte("5678"),
- Nested{1}, &Nested{2}, &five,
+ Nested{1}, &Nested{2}, &testFive,
6, []Nested{{3}, {4}, {5}, {6}, {7}, {8}},
0,
Int3(4), []byte("ABCD"),
}
-var referenceBytes = []byte{
+var testExampleBytes = []byte{
0, 0, 0, 0, 0, // pad(5)
1, 0, 2, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 4, // fake int8-int64(1-4)
5, 6, 0, 7, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, // fake little-endian uint8-uint64(5-8)
@@ -215,49 +215,49 @@ var referenceBytes = []byte{
func TestCodec(t *testing.T) {
var buf bytes.Buffer
- if err := Pack(&buf, reference); err != nil {
+ if err := Pack(&buf, testExample); err != nil {
t.Fatal(err)
}
out := &Example{}
if err := Unpack(&buf, out); err != nil {
t.Fatal(err)
}
- if !reflect.DeepEqual(reference, out) {
- fmt.Printf("got: %#v\nwant: %#v\n", out, reference)
+ if !reflect.DeepEqual(testExample, out) {
+ fmt.Printf("got: %#v\nwant: %#v\n", out, testExample)
t.Fatal("encode/decode failed")
}
}
func TestEncode(t *testing.T) {
var buf bytes.Buffer
- if err := Pack(&buf, reference); err != nil {
+ if err := Pack(&buf, testExample); err != nil {
t.Fatal(err)
}
- if !bytes.Equal(buf.Bytes(), referenceBytes) {
- fmt.Printf("got: %#v\nwant: %#v\n", buf.Bytes(), referenceBytes)
+ if !bytes.Equal(buf.Bytes(), testExampleBytes) {
+ fmt.Printf("got: %#v\nwant: %#v\n", buf.Bytes(), testExampleBytes)
t.Fatal("encode failed")
}
}
func TestDecode(t *testing.T) {
- buf := bytes.NewReader(referenceBytes)
+ buf := bytes.NewReader(testExampleBytes)
out := &Example{}
if err := Unpack(buf, out); err != nil {
t.Fatal(err)
}
- if !reflect.DeepEqual(reference, out) {
- fmt.Printf("got: %#v\nwant: %#v\n", out, reference)
+ if !reflect.DeepEqual(testExample, out) {
+ fmt.Printf("got: %#v\nwant: %#v\n", out, testExample)
t.Fatal("decode failed")
}
}
func TestSizeof(t *testing.T) {
- size, err := Sizeof(reference)
+ size, err := Sizeof(testExample)
if err != nil {
t.Fatal(err)
}
- if size != len(referenceBytes) {
- t.Fatalf("sizeof failed; expected %d, got %d", len(referenceBytes), size)
+ if size != len(testExampleBytes) {
+ t.Fatalf("sizeof failed; expected %d, got %d", len(testExampleBytes), size)
}
}
@@ -268,11 +268,11 @@ type ExampleEndian struct {
func TestEndianSwap(t *testing.T) {
var buf bytes.Buffer
big := &ExampleEndian{1}
- if err := PackWithOrder(&buf, big, binary.BigEndian); err != nil {
+ if err := PackWithOptions(&buf, big, &Options{Order: binary.BigEndian}); err != nil {
t.Fatal(err)
}
little := &ExampleEndian{}
- if err := UnpackWithOrder(&buf, little, binary.LittleEndian); err != nil {
+ if err := UnpackWithOptions(&buf, little, &Options{Order: binary.LittleEndian}); err != nil {
t.Fatal(err)
}
if little.T != 256 {
diff --git a/test_pack_init/pack_init_test.go b/test_pack_init/pack_init_test.go
index b280aa3..89e960f 100644
--- a/test_pack_init/pack_init_test.go
+++ b/test_pack_init/pack_init_test.go
@@ -2,9 +2,10 @@ package test_pack_init
import (
"bytes"
- "github.com/lunixbochs/struc"
"sync"
"testing"
+
+ "github.com/shengyanli1982/struc/v2"
)
type Example struct {
diff --git a/type_adapter.go b/type_adapter.go
new file mode 100644
index 0000000..3fc7d0c
--- /dev/null
+++ b/type_adapter.go
@@ -0,0 +1,89 @@
+package struc
+
+import (
+ "reflect"
+)
+
+// TypeAdapter 提供类型系统的适配层
+// 将现有的硬编码类型系统迁移到新的注册器系统
+type TypeAdapter struct {
+ registry *TypeRegistry
+}
+
+// NewTypeAdapter 创建一个新的类型适配器
+func NewTypeAdapter() *TypeAdapter {
+ return &TypeAdapter{
+ registry: GlobalTypeRegistry,
+ }
+}
+
+// String 返回类型的字符串表示
+// 使用注册器查找类型名称
+func (a *TypeAdapter) String(t Type) string {
+ if name, exists := a.registry.LookupNameByType(t); exists {
+ return name
+ }
+ return "unknown"
+}
+
+// ParseType 解析类型字符串
+// 使用注册器查找类型枚举
+func (a *TypeAdapter) ParseType(typeStr string) (Type, bool) {
+ return a.registry.LookupTypeByName(typeStr)
+}
+
+// KindToType 将 reflect.Kind 转换为 Type
+// 使用注册器查找类型映射
+func (a *TypeAdapter) KindToType(kind reflect.Kind) (Type, bool) {
+ return a.registry.LookupTypeByKind(kind)
+}
+
+// RegisterType 注册新类型（便捷方法）
+func (a *TypeAdapter) RegisterType(name string, typ Type) error {
+ return a.registry.RegisterType(name, typ)
+}
+
+// RegisterKindMapping 注册类型映射（便捷方法）
+func (a *TypeAdapter) RegisterKindMapping(kind reflect.Kind, typ Type) error {
+ return a.registry.RegisterKindMapping(kind, typ)
+}
+
+// RegisterCustomType 注册自定义类型（便捷方法）
+func (a *TypeAdapter) RegisterCustomType(typ reflect.Type, info CustomTypeInfo) error {
+ return a.registry.RegisterCustomType(typ, info)
+}
+
+// GetRegisteredTypes 获取已注册的类型列表
+func (a *TypeAdapter) GetRegisteredTypes() []string {
+ return a.registry.GetRegisteredTypes()
+}
+
+// GetRegisteredKinds 获取已注册的类型映射
+func (a *TypeAdapter) GetRegisteredKinds() map[reflect.Kind]Type {
+ return a.registry.GetRegisteredKinds()
+}
+
+// GetRegisteredCustomTypes 获取已注册的自定义类型
+func (a *TypeAdapter) GetRegisteredCustomTypes() map[reflect.Type]CustomTypeInfo {
+ return a.registry.GetRegisteredCustomTypes()
+}
+
+// ==================== 向后兼容的全局函数 ====================
+
+// GlobalTypeAdapter 全局类型适配器实例
+var GlobalTypeAdapter = NewTypeAdapter()
+
+// TypeToString 全局类型到字符串转换函数
+func TypeToString(t Type) string {
+ return GlobalTypeAdapter.String(t)
+}
+
+// ParseTypeString 全局类型字符串解析函数
+func ParseTypeString(typeStr string) (Type, bool) {
+ return GlobalTypeAdapter.ParseType(typeStr)
+}
+
+// KindToTypeString 全局类型映射函数
+func KindToTypeString(kind reflect.Kind) (Type, bool) {
+ return GlobalTypeAdapter.KindToType(kind)
+}
\ No newline at end of file
diff --git a/type_registry.go b/type_registry.go
new file mode 100644
index 0000000..90188ef
--- /dev/null
+++ b/type_registry.go
@@ -0,0 +1,234 @@
+package struc
+
+import (
+ "fmt"
+ "reflect"
+ "sync"
+)
+
+// TypeRegistry 是类型系统注册器
+// 提供动态注册和查找类型的功能，支持自定义类型扩展
+type TypeRegistry struct {
+ mu sync.RWMutex
+
+ // 类型名称到 Type 枚举的映射
+ nameToType map[string]Type
+
+ // Type 枚举到类型名称的映射
+ typeToName map[Type]string
+
+ // reflect.Kind 到 Type 枚举的映射
+ kindToType map[reflect.Kind]Type
+
+ // 自定义类型注册表
+ customTypes map[reflect.Type]CustomTypeInfo
+}
+
+// CustomTypeInfo 包含自定义类型的注册信息
+type CustomTypeInfo struct {
+ Name string
+ SizeFunc func(options *Options) int
+ PackFunc func(value reflect.Value, buffer []byte, options *Options) (int, error)
+ UnpackFunc func(buffer []byte, value reflect.Value, options *Options) error
+}
+
+// GlobalTypeRegistry 全局类型注册器实例
+var GlobalTypeRegistry = NewTypeRegistry()
+
+// NewTypeRegistry 创建一个新的类型注册器
+func NewTypeRegistry() *TypeRegistry {
+ registry := &TypeRegistry{
+ nameToType: make(map[string]Type),
+ typeToName: make(map[Type]string),
+ kindToType: make(map[reflect.Kind]Type),
+ customTypes: make(map[reflect.Type]CustomTypeInfo),
+ }
+
+ // 初始化内置类型
+ registry.initBuiltinTypes()
+
+ return registry
+}
+
+// initBuiltinTypes 初始化内置类型
+func (r *TypeRegistry) initBuiltinTypes() {
+ // 注册内置类型名称映射
+ builtinTypes := map[string]Type{
+ "pad": Pad,
+ "bool": Bool,
+ "byte": Uint8,
+ "int8": Int8,
+ "uint8": Uint8,
+ "int16": Int16,
+ "uint16": Uint16,
+ "int32": Int32,
+ "uint32": Uint32,
+ "int64": Int64,
+ "uint64": Uint64,
+ "float32": Float32,
+ "float64": Float64,
+ "size_t": SizeType,
+ "off_t": OffType,
+ }
+
+ for name, typ := range builtinTypes {
+ r.nameToType[name] = typ
+ r.typeToName[typ] = name
+ }
+
+ // 注册内置类型字符串映射
+ additionalTypeNames := map[Type]string{
+ Invalid: "invalid",
+ String: "string",
+ Struct: "struct",
+ Ptr: "ptr",
+ CustomType: "custom",
+ }
+
+ for typ, name := range additionalTypeNames {
+ r.typeToName[typ] = name
+ }
+
+ // 注册 reflect.Kind 到 Type 的映射
+ builtinKindMappings := map[reflect.Kind]Type{
+ reflect.Bool: Bool,
+ reflect.Int8: Int8,
+ reflect.Int16: Int16,
+ reflect.Int: Int32,
+ reflect.Int32: Int32,
+ reflect.Int64: Int64,
+ reflect.Uint8: Uint8,
+ reflect.Uint16: Uint16,
+ reflect.Uint: Uint32,
+ reflect.Uint32: Uint32,
+ reflect.Uint64: Uint64,
+ reflect.Float32: Float32,
+ reflect.Float64: Float64,
+ reflect.String: String,
+ reflect.Struct: Struct,
+ reflect.Ptr: Ptr,
+ }
+
+ for kind, typ := range builtinKindMappings {
+ r.kindToType[kind] = typ
+ }
+}
+
+// RegisterType 注册一个新的类型
+func (r *TypeRegistry) RegisterType(name string, typ Type) error {
+ r.mu.Lock()
+ defer r.mu.Unlock()
+
+ if existing, exists := r.nameToType[name]; exists {
+ return fmt.Errorf("type name '%s' already registered to type %v", name, existing)
+ }
+
+ if existing, exists := r.typeToName[typ]; exists {
+ return fmt.Errorf("type %v already registered with name '%s'", typ, existing)
+ }
+
+ r.nameToType[name] = typ
+ r.typeToName[typ] = name
+
+ return nil
+}
+
+// RegisterKindMapping 注册 reflect.Kind 到 Type 的映射
+func (r *TypeRegistry) RegisterKindMapping(kind reflect.Kind, typ Type) error {
+ r.mu.Lock()
+ defer r.mu.Unlock()
+
+ if existing, exists := r.kindToType[kind]; exists {
+ return fmt.Errorf("kind %v already mapped to type %v", kind, existing)
+ }
+
+ r.kindToType[kind] = typ
+ return nil
+}
+
+// RegisterCustomType 注册自定义类型
+func (r *TypeRegistry) RegisterCustomType(typ reflect.Type, info CustomTypeInfo) error {
+ r.mu.Lock()
+ defer r.mu.Unlock()
+
+ if _, exists := r.customTypes[typ]; exists {
+ return fmt.Errorf("custom type %v already registered", typ)
+ }
+
+ r.customTypes[typ] = info
+ return nil
+}
+
+// LookupTypeByName 根据类型名称查找 Type
+func (r *TypeRegistry) LookupTypeByName(name string) (Type, bool) {
+ r.mu.RLock()
+ defer r.mu.RUnlock()
+
+ typ, exists := r.nameToType[name]
+ return typ, exists
+}
+
+// LookupNameByType 根据 Type 查找类型名称
+func (r *TypeRegistry) LookupNameByType(typ Type) (string, bool) {
+ r.mu.RLock()
+ defer r.mu.RUnlock()
+
+ name, exists := r.typeToName[typ]
+ return name, exists
+}
+
+// LookupTypeByKind 根据 reflect.Kind 查找 Type
+func (r *TypeRegistry) LookupTypeByKind(kind reflect.Kind) (Type, bool) {
+ r.mu.RLock()
+ defer r.mu.RUnlock()
+
+ typ, exists := r.kindToType[kind]
+ return typ, exists
+}
+
+// LookupCustomType 查找自定义类型信息
+func (r *TypeRegistry) LookupCustomType(typ reflect.Type) (CustomTypeInfo, bool) {
+ r.mu.RLock()
+ defer r.mu.RUnlock()
+
+ info, exists := r.customTypes[typ]
+ return info, exists
+}
+
+// GetRegisteredTypes 返回所有已注册的类型名称
+func (r *TypeRegistry) GetRegisteredTypes() []string {
+ r.mu.RLock()
+ defer r.mu.RUnlock()
+
+ names := make([]string, 0, len(r.nameToType))
+ for name := range r.nameToType {
+ names = append(names, name)
+ }
+ return names
+}
+
+// GetRegisteredKinds 返回所有已注册的 reflect.Kind 映射
+func (r *TypeRegistry) GetRegisteredKinds() map[reflect.Kind]Type {
+ r.mu.RLock()
+ defer r.mu.RUnlock()
+
+ // 返回副本以避免并发访问问题
+ result := make(map[reflect.Kind]Type)
+ for kind, typ := range r.kindToType {
+ result[kind] = typ
+ }
+ return result
+}
+
+// GetRegisteredCustomTypes 返回所有已注册的自定义类型
+func (r *TypeRegistry) GetRegisteredCustomTypes() map[reflect.Type]CustomTypeInfo {
+ r.mu.RLock()
+ defer r.mu.RUnlock()
+
+ // 返回副本以避免并发访问问题
+ result := make(map[reflect.Type]CustomTypeInfo)
+ for typ, info := range r.customTypes {
+ result[typ] = info
+ }
+ return result
+}
\ No newline at end of file
diff --git a/types.go b/types.go
index 6ca97f4..465ce92 100644
--- a/types.go
+++ b/types.go
@@ -5,32 +5,34 @@ import (
"reflect"
)
+// Type 定义了支持的数据类型枚举
type Type int
const (
- Invalid Type = iota
- Pad
- Bool
- Int
- Int8
- Uint8
- Int16
- Uint16
- Int32
- Uint32
- Int64
- Uint64
- Float32
- Float64
- String
- Struct
- Ptr
-
- SizeType
- OffType
- CustomType
+ Invalid Type = iota // 无效类型
+ Pad // 填充类型
+ Bool // 布尔类型
+ Int // 整数类型
+ Int8 // 8位整数
+ Uint8 // 8位无符号整数
+ Int16 // 16位整数
+ Uint16 // 16位无符号整数
+ Int32 // 32位整数
+ Uint32 // 32位无符号整数
+ Int64 // 64位整数
+ Uint64 // 64位无符号整数
+ Float32 // 32位浮点数
+ Float64 // 64位浮点数
+ String // 字符串类型
+ Struct // 结构体类型
+ Ptr // 指针类型
+ SizeType // size_t 类型
+ OffType // off_t 类型
+ CustomType // 自定义类型
)
+// Resolve 根据选项解析实际类型
+// 主要用于处理 SizeType 和 OffType 这样的平台相关类型
func (t Type) Resolve(options *Options) Type {
switch t {
case OffType:
@@ -63,10 +65,12 @@ func (t Type) Resolve(options *Options) Type {
return t
}
+// String 返回类型的字符串表示
func (t Type) String() string {
- return typeNames[t]
+ return typeToString[t]
}
+// Size 返回类型的字节大小
func (t Type) Size() int {
switch t {
case SizeType, OffType:
@@ -79,12 +83,28 @@ func (t Type) Size() int {
return 4
case Int64, Uint64, Float64:
return 8
+ case Struct:
+ return 0 // 结构体大小需要通过字段计算
default:
panic("Cannot resolve size of type:" + t.String())
}
}
-var typeLookup = map[string]Type{
+// IsBasicType 判断是否为基本类型
+// 基本类型包括：整数、浮点数、布尔值
+func (t Type) IsBasicType() bool {
+ switch t {
+ case Int8, Int16, Int32, Int64,
+ Uint8, Uint16, Uint32, Uint64,
+ Float32, Float64, Bool:
+ return true
+ default:
+ return false
+ }
+}
+
+// typeStrToType 定义了字符串到类型的映射关系
+var typeStrToType = map[string]Type{
"pad": Pad,
"bool": Bool,
"byte": Uint8,
@@ -103,20 +123,45 @@ var typeLookup = map[string]Type{
"off_t": OffType,
}
-var typeNames = map[Type]string{
- CustomType: "Custom",
+// typeToString 定义了类型到字符串的映射关系
+var typeToString = map[Type]string{
+ Invalid: "invalid",
+ Pad: "pad",
+ Bool: "bool",
+ Int8: "int8",
+ Int16: "int16",
+ Int32: "int32",
+ Int64: "int64",
+ Uint8: "uint8",
+ Uint16: "uint16",
+ Uint32: "uint32",
+ Uint64: "uint64",
+ Float32: "float32",
+ Float64: "float64",
+ String: "string",
+ Struct: "struct",
+ Ptr: "ptr",
+ SizeType: "size_t",
+ OffType: "off_t",
+ CustomType: "custom",
}
+// init 初始化类型到字符串的映射
func init() {
- for name, enum := range typeLookup {
- typeNames[enum] = name
+ for name, enum := range typeStrToType {
+ typeToString[enum] = name
}
}
+// Size_t 是平台相关的无符号整数类型，用于表示大小
type Size_t uint64
+
+// Off_t 是平台相关的有符号整数类型，用于表示偏移量
type Off_t int64
-var reflectTypeMap = map[reflect.Kind]Type{
+// typeKindToType 定义了 reflect.Kind 到 Type 的映射关系
+// 用于将 Go 的反射类型转换为 struc 包的类型系统
+var typeKindToType = map[reflect.Kind]Type{
reflect.Bool: Bool,
reflect.Int8: Int8,
reflect.Int16: Int16,
diff --git a/unsafe.go b/unsafe.go
new file mode 100644
index 0000000..fb69e5c
--- /dev/null
+++ b/unsafe.go
@@ -0,0 +1,158 @@
+package struc
+
+import (
+ "encoding/binary"
+ "math"
+ "reflect"
+ "unsafe"
+)
+
+//go:linkname memclrNoHeapPointers runtime.memclrNoHeapPointers
+func memclrNoHeapPointers(ptr unsafe.Pointer, n uintptr)
+
+// typedmemmove 是一个底层的内存移动函数
+//
+//go:linkname typedmemmove runtime.typedmemmove
+func typedmemmove(dst unsafe.Pointer, src unsafe.Pointer, size uintptr)
+
+// memclr 使用 runtime 的内存清零函数, 比循环清零更高效
+func memclr(b []byte) {
+ if len(b) == 0 {
+ return
+ }
+ memclrNoHeapPointers(unsafe.Pointer(&b[0]), uintptr(len(b)))
+}
+
+// unsafeSliceHeader 是切片的内部表示
+type unsafeSliceHeader struct {
+ Data uintptr
+ Len int
+ Cap int
+}
+
+// unsafeBytes2String 使用 unsafe 将字节切片转换为字符串, 避免内存拷贝
+func unsafeBytes2String(b []byte) string {
+ return *(*string)(unsafe.Pointer(&b))
+}
+
+// unsafeString2Bytes 使用 unsafe 将字符串转换为字节切片, 避免内存拷贝
+func unsafeString2Bytes(s string) []byte {
+ x := (*[2]uintptr)(unsafe.Pointer(&s))
+ h := [3]uintptr{x[0], x[1], x[1]}
+ return *(*[]byte)(unsafe.Pointer(&h))
+}
+
+// unsafeSetSlice 使用 unsafe 直接设置切片的底层数据, 避免内存拷贝
+func unsafeSetSlice(fieldValue reflect.Value, buffer []byte, length int) {
+ sh := (*unsafeSliceHeader)(unsafe.Pointer(fieldValue.UnsafeAddr()))
+ sh.Data = uintptr(unsafe.Pointer(&buffer[0]))
+ sh.Len = length
+ sh.Cap = length
+}
+
+// unsafeSetString 使用 unsafe 将字节切片转换为字符串并设置到字段, 避免内存拷贝
+func unsafeSetString(fieldValue reflect.Value, buffer []byte, length int) {
+ str := unsafeBytes2String(buffer[:length])
+ fieldValue.SetString(str)
+}
+
+// unsafeGetUint64 使用 unsafe 直接读取 uint64 值, 避免内存拷贝
+func unsafeGetUint64(buffer []byte, byteOrder binary.ByteOrder) uint64 {
+ if byteOrder == binary.LittleEndian {
+ return *(*uint64)(unsafe.Pointer(&buffer[0]))
+ }
+ // 大端序使用 binary 包，可能被编译器优化
+ return binary.BigEndian.Uint64(buffer)
+}
+
+// unsafeGetUint32 使用 unsafe 直接读取 uint32 值, 避免内存拷贝
+func unsafeGetUint32(buffer []byte, byteOrder binary.ByteOrder) uint32 {
+ if byteOrder == binary.LittleEndian {
+ return *(*uint32)(unsafe.Pointer(&buffer[0]))
+ }
+ // 大端序使用 binary 包，可能被编译器优化
+ return binary.BigEndian.Uint32(buffer)
+}
+
+// unsafeGetUint16 使用 unsafe 直接读取 uint16 值, 避免内存拷贝
+func unsafeGetUint16(buffer []byte, byteOrder binary.ByteOrder) uint16 {
+ if byteOrder == binary.LittleEndian {
+ return *(*uint16)(unsafe.Pointer(&buffer[0]))
+ }
+ // 大端序使用 binary 包，可能被编译器优化
+ return binary.BigEndian.Uint16(buffer)
+}
+
+// unsafePutUint64 使用 unsafe 直接写入 uint64 值, 避免内存拷贝
+func unsafePutUint64(buffer []byte, value uint64, byteOrder binary.ByteOrder) {
+ if byteOrder == binary.LittleEndian {
+ *(*uint64)(unsafe.Pointer(&buffer[0])) = value
+ return
+ }
+ // 大端序使用 binary 包，可能被编译器优化
+ binary.BigEndian.PutUint64(buffer, value)
+}
+
+// unsafePutUint32 使用 unsafe 直接写入 uint32 值, 避免内存拷贝
+func unsafePutUint32(buffer []byte, value uint32, byteOrder binary.ByteOrder) {
+ if byteOrder == binary.LittleEndian {
+ *(*uint32)(unsafe.Pointer(&buffer[0])) = value
+ return
+ }
+ // 大端序使用 binary 包，可能被编译器优化
+ binary.BigEndian.PutUint32(buffer, value)
+}
+
+// unsafePutUint16 使用 unsafe 直接写入 uint16 值, 避免内存拷贝
+func unsafePutUint16(buffer []byte, value uint16, byteOrder binary.ByteOrder) {
+ if byteOrder == binary.LittleEndian {
+ *(*uint16)(unsafe.Pointer(&buffer[0])) = value
+ return
+ }
+ // 大端序使用 binary 包，可能被编译器优化
+ binary.BigEndian.PutUint16(buffer, value)
+}
+
+// unsafeGetFloat64 使用 unsafe 直接读取 float64 值
+// 通过转换为 uint64 位模式实现
+func unsafeGetFloat64(buffer []byte, byteOrder binary.ByteOrder) float64 {
+ bits := unsafeGetUint64(buffer, byteOrder)
+ return math.Float64frombits(bits)
+}
+
+// unsafeGetFloat32 使用 unsafe 直接读取 float32 值
+// 通过转换为 uint32 位模式实现
+func unsafeGetFloat32(buffer []byte, byteOrder binary.ByteOrder) float32 {
+ bits := unsafeGetUint32(buffer, byteOrder)
+ return math.Float32frombits(bits)
+}
+
+// unsafePutFloat64 使用 unsafe 直接写入 float64 值
+// 通过转换为 uint64 位模式实现
+func unsafePutFloat64(buffer []byte, value float64, byteOrder binary.ByteOrder) {
+ bits := math.Float64bits(value)
+ unsafePutUint64(buffer, bits, byteOrder)
+}
+
+// unsafePutFloat32 使用 unsafe 直接写入 float32 值
+// 通过转换为 uint32 位模式实现
+func unsafePutFloat32(buffer []byte, value float32, byteOrder binary.ByteOrder) {
+ bits := math.Float32bits(value)
+ unsafePutUint32(buffer, bits, byteOrder)
+}
+
+// unsafeMoveSlice 使用 typedmemmove 移动切片数据
+// 直接操作切片的底层数据，避免内存拷贝
+func unsafeMoveSlice(dst, src reflect.Value) {
+ dstPtr := unsafe.Pointer(dst.Pointer())
+ srcPtr := unsafe.Pointer(src.Pointer())
+
+ // The length of data to copy is the length of the source slice in bytes.
+ // Since src is always a []byte slice from reflect.ValueOf(buffer),
+ // src.Len() is the number of bytes.
+ dataLen := uintptr(src.Len())
+ if dataLen == 0 {
+ return
+ }
+ typedmemmove(dstPtr, srcPtr, dataLen)
+}
+