我的Golang课程"GPB"使用体验分享

这是一个非常有趣的序列化/反序列化库设计。让我来分析一下这个GPB类的实现思路，并提供一些代码示例。

从描述来看，GPB应该是一个二进制包构建器，支持两阶段操作：先计算大小，再实际写入。以下是基于你描述的实现示例：

package gpb

import (
	"encoding/binary"
	"errors"
)

type GPB struct {
	buffer     []byte
	offset     int
	sizeOnly   bool
	totalSize  int
	byteOrder  binary.ByteOrder
}

// NewGPB 创建新的GPB实例
func NewGPB() *GPB {
	return &GPB{
		byteOrder: binary.LittleEndian, // 默认使用小端序
		sizeOnly:  true,                // 第一阶段：仅计算大小
	}
}

// BeginWrite 开始实际写入阶段
func (g *GPB) BeginWrite(buffer []byte) {
	g.buffer = buffer
	g.offset = 0
	g.sizeOnly = false
}

// W8 写入8位整数
func (g *GPB) W8(value uint8) {
	if g.sizeOnly {
		g.totalSize += 1
		return
	}
	
	if g.offset+1 > len(g.buffer) {
		panic("buffer overflow")
	}
	
	g.buffer[g.offset] = value
	g.offset += 1
}

// W16 写入16位整数
func (g *GPB) W16(value uint16) {
	if g.sizeOnly {
		g.totalSize += 2
		return
	}
	
	if g.offset+2 > len(g.buffer) {
		panic("buffer overflow")
	}
	
	g.byteOrder.PutUint16(g.buffer[g.offset:], value)
	g.offset += 2
}

// W32 写入32位整数
func (g *GPB) W32(value uint32) {
	if g.sizeOnly {
		g.totalSize += 4
		return
	}
	
	if g.offset+4 > len(g.buffer) {
		panic("buffer overflow")
	}
	
	g.byteOrder.PutUint32(g.buffer[g.offset:], value)
	g.offset += 4
}

// W64 写入64位整数
func (g *GPB) W64(value uint64) {
	if g.sizeOnly {
		g.totalSize += 8
		return
	}
	
	if g.offset+8 > len(g.buffer) {
		panic("buffer overflow")
	}
	
	g.byteOrder.PutUint64(g.buffer[g.offset:], value)
	g.offset += 8
}

// WBytes 写入字节切片
func (g *GPB) WBytes(data []byte) {
	length := len(data)
	
	// 先写入长度
	g.W32(uint32(length))
	
	if g.sizeOnly {
		g.totalSize += length
		return
	}
	
	if g.offset+length > len(g.buffer) {
		panic("buffer overflow")
	}
	
	copy(g.buffer[g.offset:], data)
	g.offset += length
}

// TotalSize 获取包的总大小
func (g *GPB) TotalSize() int {
	return g.totalSize
}

// 读取部分的实现
type Reader struct {
	buffer    []byte
	offset    int
	byteOrder binary.ByteOrder
}

func NewReader(data []byte) *Reader {
	return &Reader{
		buffer:    data,
		byteOrder: binary.LittleEndian,
	}
}

// R8 读取8位整数
func (r *Reader) R8() (uint8, error) {
	if r.offset+1 > len(r.buffer) {
		return 0, errors.New("buffer underflow")
	}
	
	value := r.buffer[r.offset]
	r.offset += 1
	return value, nil
}

// R16 读取16位整数
func (r *Reader) R16() (uint16, error) {
	if r.offset+2 > len(r.buffer) {
		return 0, errors.New("buffer underflow")
	}
	
	value := r.byteOrder.Uint16(r.buffer[r.offset:])
	r.offset += 2
	return value, nil
}

// R32 读取32位整数
func (r *Reader) R32() (uint32, error) {
	if r.offset+4 > len(r.buffer) {
		return 0, errors.New("buffer underflow")
	}
	
	value := r.byteOrder.Uint32(r.buffer[r.offset:])
	r.offset += 4
	return value, nil
}

// RBytes 读取字节切片
func (r *Reader) RBytes() ([]byte, error) {
	length, err := r.R32()
	if err != nil {
		return nil, err
	}
	
	if r.offset+int(length) > len(r.buffer) {
		return nil, errors.New("buffer underflow")
	}
	
	data := r.buffer[r.offset : r.offset+int(length)]
	r.offset += int(length)
	return data, nil
}

使用示例：

package main

import (
	"fmt"
	"log"
)

func main() {
	// 第一阶段：计算包大小
	builder := gpb.NewGPB()
	
	// 构建包
	builder.W32(0x12345678)
	builder.W16(0xABCD)
	builder.W8(0xFF)
	builder.WBytes([]byte("Hello, World!"))
	
	// 获取所需缓冲区大小
	requiredSize := builder.TotalSize()
	fmt.Printf("Required buffer size: %d bytes\n", requiredSize)
	
	// 第二阶段：实际写入
	buffer := make([]byte, requiredSize)
	builder.BeginWrite(buffer)
	
	// 重新执行相同的写入操作
	builder.W32(0x12345678)
	builder.W16(0xABCD)
	builder.W8(0xFF)
	builder.WBytes([]byte("Hello, World!"))
	
	// 读取包
	reader := gpb.NewReader(buffer)
	
	val32, err := reader.R32()
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("R32: 0x%X\n", val32)
	
	val16, err := reader.R16()
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("R16: 0x%X\n", val16)
	
	val8, err := reader.R8()
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("R8: 0x%X\n", val8)
	
	data, err := reader.RBytes()
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("RBytes: %s\n", string(data))
}

这个设计模式在需要预分配缓冲区的场景中很有用，特别是在嵌入式系统或网络协议中。如果你有tar文件，我可以帮你分析具体的实现并提供更详细的优化建议。