Generic Go function to save bytes into a fixed-size byte array buffer

Question

How do I to write a generic Go function to push bytes into a byte array?

I suppose appending to a slice is not a perfect fit, because the array should not grow. However the function should handle any array size. I am considering to slice the array just to make the function accept any array size. See my sketch below.

Is there a cleaner way?

Play: http://play.golang.org/p/Gii9-JM33E

func push(buf []byte, size int, b byte) (int, error) {
    max := len(buf)

    if max < 1 {
        return size, fmt.Errorf("buffer underflow: max=%d char=%d", max, b)
    }

    if size >= max {
        return size, fmt.Errorf("buffer overflow: size=%d max=%d char=%d", size, max, b)
    }

    buf[size] = b

    return size + 1, nil
}

Usage:

buf := [3]byte{}
size := 0
var err error
size, err = push(buf[:], size, 'a')

@OneOfOne it requires the slicing of the array just to accept any array size. i feel it is clumsy to pass a slice plus its underlying array size... i hope there is a cleaner idiomatic way. — Everton
– Everton, Commented May 30, 2014 at 14:46
@JimB the array plus its size appear in the usage pattern i added below the function. — Everton
– Everton, Commented May 30, 2014 at 14:48
Ok, I see it. but why are you using an array in the first place? — Mr_Pink
– Mr_Pink, Commented May 30, 2014 at 14:50
I have the feeling you are focusing on the wrong thing here. What are you trying to solve ? — fabmilo
– fabmilo, Commented May 30, 2014 at 17:43

Paul Hankin · Accepted Answer · 2014-05-30 15:59:37Z

2

You almost certainly want to use a slice instead of an array. A slice has three things: an underlying backing array, a capacity, and a length. The capacity "cap" tells you the size of the underlying backing array.

So, you can use append after checking that len(s) < cap(s) to avoid any reallocation. Or if you want to make a function, perhaps something like this:

func pushByte(s []byte, b byte) ([]byte, error) {
    if len(s) == cap(s) {
        return s, errors.New("capacity reached")
    }
    return append(s, b), nil
}

You'd use it something like this:

s := make([]byte, 0, 10)
var err error
if s, err = pushByte(s, 10); err != nil {
    ... handle error
}

answered May 30, 2014 at 15:59

Paul Hankin

58.8k11 gold badges99 silver badges125 bronze badges

Sign up to request clarification or add additional context in comments.

1 Comment

Everton Over a year ago

Thanks, I think your suggestion is indeed better.

Mr_Pink · Accepted Answer · 2014-05-30 15:46:33Z

1

The size of an array is part if its type.

If there's a set of sizes you know you are going to accept, you could take a buf interface{} with a type switch on the sizes you want. I would assume you know the array sizes, since they must be constant at compile time.

Other than that you would need to use reflection to actually find the array size, and store elements within the array.

It's very infrequent you need to use an array instead of a slice. You may want to reconsider why you have to pass arrays of varying sizes around.

edited May 30, 2014 at 15:46

answered May 30, 2014 at 14:55

Mr_Pink

110k17 gold badges287 silver badges275 bronze badges

1 Comment

Everton Over a year ago

I have few arrays sizes, and was worried about having some fixed-size types (say [200]byte, [1000]byte, [64000]byte) appearing multiple times in the code. From you answer I see it may be wiser to define some custom array types (as in type Buf1 [100]byte, type Buf2 [1000]byte, type Buf3 [64000]byte) or to only use slices and prevent them from growing (as suggested by @Anonymous).

Collectives™ on Stack Overflow

Generic Go function to save bytes into a fixed-size byte array buffer

2 Answers 2

1 Comment

1 Comment

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

1 Comment

1 Comment

Your Answer

Sign up or log in

Post as a guest

Related