print - ¿Cómo vuelco la estructura en la matriz de bytes sin reflexión?

python read bytes from binary file

Question

Ya encontré el paquete de encoding/binary para manejarlo, pero dependía del paquete reflect, por lo que no funcionaba con campos de estructura no capitalizados (es decir, no exportados). Sin embargo, pasé una semana para encontrar el problema, todavía tengo una pregunta: si los campos de estructura no deben exportarse, ¿cómo los vuelco fácilmente en datos binarios?

EDITAR: Aquí está el ejemplo. Si escribe con mayúscula el nombre de los campos de la estructura de Data , eso funciona correctamente. Pero la estructura de Data estaba pensada para ser un tipo abstracto, por lo que no quiero exportar estos campos.

package main
import (
    "fmt"
    "encoding/binary"
    "bytes"
)

type Data struct {
    id int32
    name [16]byte
}


func main() {
    d := Data{Id: 1}
    copy(d.Name[:], []byte("tree"))
    buffer := new(bytes.Buffer)
    binary.Write(buffer, binary.LittleEndian, d)
    // d was written properly
    fmt.Println(buffer.Bytes())
    // try to read...
    buffer = bytes.NewBuffer(buffer.Bytes())
    var e = new(Data)
    err := binary.Read(buffer, binary.LittleEndian, e)
    fmt.Println(e, err)
}

Answer 1

Su mejor opción probablemente sería utilizar el paquete gob y permitir que su estructura implemente las interfaces GobDecoder y GobEncoder para serializar y deserializar campos privados.

Esto sería seguro, independiente de la plataforma y eficiente. Y debe agregar esas funciones GobEncode y GobDecode solo en estructuras con campos no exportados, lo que significa que no desordena el resto de su código.

func (d *Data) GobEncode() ([]byte, error) {
    w := new(bytes.Buffer)
    encoder := gob.NewEncoder(w)
    err := encoder.Encode(d.id)
    if err!=nil {
        return nil, err
    }
    err = encoder.Encode(d.name)
    if err!=nil {
        return nil, err
    }
    return w.Bytes(), nil
}

func (d *Data) GobDecode(buf []byte) error {
    r := bytes.NewBuffer(buf)
    decoder := gob.NewDecoder(r)
    err := decoder.Decode(&d.id)
    if err!=nil {
        return err
    }
    return decoder.Decode(&d.name)
}

func main() {
    d := Data{id: 7}
    copy(d.name[:], []byte("tree"))
    buffer := new(bytes.Buffer)
    // writing
    enc := gob.NewEncoder(buffer)
    err := enc.Encode(d)
    if err != nil {
        log.Fatal("encode error:", err)
    }
    // reading
    buffer = bytes.NewBuffer(buffer.Bytes())
    e := new(Data)
    dec := gob.NewDecoder(buffer)
    err = dec.Decode(e)
    fmt.Println(e, err)
}