How to marshal array to binary and unmarshal binary to array in golang?

I want to use gob to encode and decode object, I do it like this:

type transProp struct {
    a []int
    b []float64
}

func (p transProp) MarshalBinary() ([]byte, error) {
    // A simple encoding: plain text.
    var b bytes.Buffer
    fmt.Fprintln(&b, p.a, p.b)
    return b.Bytes(), nil
}

// UnmarshalBinary modifies the receiver so it must take a pointer receiver.
func (p *transProp) UnmarshalBinary(data []byte) error {
    // A simple encoding: plain text.
    b := bytes.NewBuffer(data)
    _, err := fmt.Fscanln(b, &p.a, &p.b)
    return err
}

func TestGobEncode(t *testing.T) {
    p := transProp{
        a: []int{3, 4, 5},
        b: []float64{1.0, 2.0},
    }

    var network bytes.Buffer
    enc := gob.NewEncoder(&network)
    err := enc.Encode(p)
    if err != nil {
        log.Fatal("encode:", err)
    }
    dec := gob.NewDecoder(&network)
    var p1 transProp
    err = dec.Decode(&p1)
    if err != nil {
        log.Fatal("decode:", err)
    }
    fmt.Println(p1)
}

But, this report error like this:

decode:can't scan type: *[]int

If you can change the visibility of transProp fields to public, e.g.

type transProp struct {
    A []int
    B []float64
}

then you don't need to implement custom binary marshaller/unmarshaller. You can use default gob decoder/encoder.

However, if you can't, there are many options.

The simplest one, define another wrapper struct that export related fields, wrap transProp, then use default gob encoder/decoder, e.g.

type wrapTransProp struct {
    A []int
    B []float64
}

func (p transProp) MarshalBinary() ([]byte, error) {
    //Wrap struct
    w := wrapTransProp{p.a, p.b}

    //use default gob encoder
    var buf bytes.Buffer
    enc := gob.NewEncoder(&buf)
    if err := enc.Encode(w); err != nil {
        return nil, err
    }
    return buf.Bytes(), nil
}
func (p *transProp) UnmarshalBinary(data []byte) error {
    w := wrapTransProp{}

    //Use default gob decoder
    reader := bytes.NewReader(data)
    dec := gob.NewDecoder(reader)
    if err := dec.Decode(&w); err != nil {
        return err
    }

    p.a = w.A
    p.b = w.B
    return nil
}

Custom marshaller/unmarshaller with custom data layout. There are many implementation possibilities. Several considerations:

Byte order, little/big endian?
Packet/stream layout?

An example implementation of big-endian with stream format:

// Big-Endian
// Size  : 4,         4,      1,        n,     4,       n
// Types : uint32,    uint32, uint8,    []int, uint32,  []float64
// Data  : #numbytes, #nInt,  #intSize, p.a,   #nFloat, p.b

The challenge is in how to represent int since it's architecture dependent. Sample implementation will be:

func (p transProp) MarshalBinary() ([]byte, error) {
    //Get sizeof int (in bits) from strconv package
    szInt := strconv.IntSize / 8
    nInt := len(p.a)
    nFloat := len(p.b)

    nStream := 4 + 4 + 1 + nInt*szInt + 4 + nFloat*8
    stream := make([]byte, nStream)
    pos := 0

    //total number of bytes
    binary.BigEndian.PutUint32(stream, uint32(nStream))
    pos += 4

    //num of items in p.a
    binary.BigEndian.PutUint32(stream[pos:], uint32(nInt))
    pos += 4

    //int size
    stream[pos] = uint8(szInt)
    pos++

    //items in a
    switch szInt {
    case 1:
        for _, v := range p.a {
            stream[pos] = uint8(v)
            pos++
        }
    case 2: //16-bit
        for _, v := range p.a {
            binary.BigEndian.PutUint16(stream[pos:], uint16(v))
            pos += 2
        }
    case 4: //32-bit
        for _, v := range p.a {
            binary.BigEndian.PutUint32(stream[pos:], uint32(v))
            pos += 4
        }
    case 8: //64-bit
        for _, v := range p.a {
            binary.BigEndian.PutUint64(stream[pos:], uint64(v))
            pos += 8
        }
    }

    //number of items in p.b
    binary.BigEndian.PutUint32(stream[pos:], uint32(nFloat))
    pos += 4

    //items in b
    s := stream[pos:pos] //slice len=0, capacity=nFloat
    buf := bytes.NewBuffer(s)
    if err := binary.Write(buf, binary.BigEndian, p.b); err != nil {
        return nil, err
    }

    return stream, nil
}

func (p *transProp) UnmarshalBinary(data []byte) error {
    buf := bytes.NewBuffer(data)

    var intSize uint8
    var k, nBytes, nInt, nFloat uint32

    //num bytes
    if err := binary.Read(buf, binary.BigEndian, &nBytes); err != nil {
        return err
    }
    if len(data) < int(nBytes) {
        return errors.New("len(data) < #Bytes")
    }

    //num of int items
    if err := binary.Read(buf, binary.BigEndian, &nInt); err != nil {
        return err
    }

    //int size
    if err := binary.Read(buf, binary.BigEndian, &intSize); err != nil {
        return err
    }

    //read int into p.a
    pos := 0
    stream := buf.Bytes()
    p.a = make([]int, nInt)
    switch intSize {
    case 1:
        for pos = 0; pos < int(nInt); pos++ {
            p.a[pos] = int(stream[pos])
        }
    case 2:
        for k = 0; k < nInt; k++ {
            p.a[k] = int(binary.BigEndian.Uint16(stream[pos:]))
            pos += 2
        }
    case 4:
        for k = 0; k < nInt; k++ {
            p.a[k] = int(binary.BigEndian.Uint32(stream[pos:]))
            pos += 4
        }
    case 8:
        for k = 0; k < nInt; k++ {
            p.a[k] = int(binary.BigEndian.Uint64(stream[pos:]))
            pos += 8
        }
    }

    //advance buffer
    buf.Next(pos)

    //num of float64 items
    if err := binary.Read(buf, binary.BigEndian, &nFloat); err != nil {
        return err
    }

    //items in b
    p.b = make([]float64, nFloat)
    if err := binary.Read(buf, binary.BigEndian, p.b); err != nil {
        return err
    }

    return nil
}

Recommended topics

Hot tags