How to set a protobuf2 enum using golang

Question

I'm trying to use protobuf2 enums in golang but I cannot figure it out.

I created a simple protobuf file:

syntax         =          "proto2" ;
package                    enum    ;
message Foo{
     enum Bar{
         LOL = 1;
     }
     optional Bar baz = 1;
}

And I created a simple golang file:

package main

import (
    enum "./enum"
    "github.com/golang/protobuf/proto"
)

func main() {
    msg := &enum.Foo{
        Baz: enum.Foo_LOL,
    }
    proto.Marshal(&msg)
}

I got an error.

./foo.go:10: cannot use enum.Foo_LOL (type enum.Foo_Bar) as type *enum.Foo_Bar in field value

It seemed simple enough to solve, just add a & in front of enum.Foo_Bar.

package main

import (
    enum "./enum"
    "github.com/golang/protobuf/proto"
)

func main() {
    msg := &enum.Foo{
        Baz: &enum.Foo_LOL,
    }
    proto.Marshal(&msg)
}

Nope:

./foo.go:10: cannot take the address of enum.Foo_LOL

I searched google and found this guy being trolled by a bot. He had some working code, but it was verbose enough to bore a bible scholar:

package main

import (
    enum "./enum"
    "github.com/golang/protobuf/proto"
)

var lolVar = enum.Foo_LOL

func main() {
    msg := &enum.Foo{
        Baz: &lolVar,
    }
    proto.Marshal(msg)
}

I looked in the generated code and found an Enum method, which also worked, but was verbose enough to bore a tax auditor:

package main

import (
    enum "./enum"
    "github.com/golang/protobuf/proto"
)

func main() {
    msg := &enum.Foo{
        Baz: enum.Foo_LOL.Enum(),
    }
    proto.Marshal(msg)
}

What is the intended method?

icza · Accepted Answer · 2018-05-22T12:04:44.100

2

Protobuf with syntax="proto2" generates enum fields with pointer type, so Foo.baz will be of type *Foo_Bar. You can't assign a non-pointer Foo_Bar value to this field, only a pointer value.

Also, the enum values you list in the protobuf files will be generated to be constants in Go. And you cannot take the address of constant values, for details see: Find address of constant in go

If your protobuf generates an Enum() method returning a pointer to the value, then that's fine, you can use that. But this method is not always generated, so don't be surprised if you don't find this to some type / enum.

If it's missing, the simplest is to create a (local) variable, and whose address you can take:

lol := enum.Foo_LOL
msg := &enum.Foo{
    Baz: &lol,
}
err := proto.Marshal(msg)

If you have to do this many times / many places, create a helper function which fills the purpose of the Enum() method. This is how you can create one:

func barPtr(b enum.Foo_Bar) *enum.Foo_Bar { return &b }

And using it:

msg := &enum.Foo{
    Baz: barPtr(enum.Foo_LOL),
}
err := proto.Marshal(msg)

There are many other options to obtain a pointer to an integer type, but they are not necessarily cleaner or more efficient. You can see a list of different methods here: How do I do a literal *int64 in Go?

edited May 22 '18 at 12:04

answered May 22 '18 at 09:37

icza

389,944
63
907
827

When and why would the Enum method not be created? – timthelion May 22 '18 at 10:05
@timthelion I'm not sure, but I use protobuf too, and I don't have this `Enum()` method generated to my enums. – icza May 22 '18 at 10:20
are you using proto3 by any chance? Looking at [the code](https://github.com/golang/protobuf/blob/b4deda0973fb4c70b50d226b1af49f3da59f5265/protoc-gen-go/generator/generator.go#L1424) I see that the Enum method is not created for proto3 files, perhaps because proto3 does not support optional fields. – timthelion May 22 '18 at 10:45
@timthelion Yes, was just about to comment. I've looked into it. If you use `syntax="proto2"`, the field is generated as pointer, and `Enum()` method is added to enums. When `syntax="proto3"`, the field is non-pointer, and no `Enum()` method is generated. So if you "upgrade" to `"proto3"`, you will "lose" the `Enum()` method. And yes, in `proto3`, fields are `optional` by default. – icza May 22 '18 at 10:46

How to set a protobuf2 enum using golang

1 Answers1