Protocol buffers and enums combinations?

Question

This is my proto file :

message MSG {

  required MsgCodes MsgCode = 1;
  optional int64 Serial = 2;        // Unique ID number for this person.
  required int32 From = 3;  
  required int32 To = 4;  
  //bla bla...
        enum MsgCodes
        {
            MSG = 1;
            FILE = 2;
            APPROVE=4;
            ACK=8;
            ERROR_SENDING=16;
            WORLD=32;
        }
}

In my C# I'm trying to :

 msg = msg.ToBuilder().SetMsgCode(msg.MsgCode | MSG.Types.MsgCodes.ACK | MSG.Types.MsgCodes.APPROVE).Build();
 SendToJava(msg);

But the JAVA tells me : missing MsgCode ( which is a required)

Removing the combination - does solve it

But I need to specify combinations

Question

How can I solve it ?

nb :

The weird thing is that if I create a msg and set multiple enums , and then reads it in C# again - it does work...:-(

Answer 1

In Protobufs, an enum-typed field is only allowed to have one of the exact numeric values specified in the enum. That is to say, you cannot use an enum-typed field as a bitfield. If you want a bitfield, you need to use an integer type like int32. This rule actually applies even in languages that have numeric enum types, like C++ -- if an enum-typed protobuf field read from the wire has an invalid value, it will be treated like an unknown field and thus hidden.

If you switch to integers, you of course now have the problem of how to declare flag values. Unfortunately Protobufs provides no good way to define constants. As you suggested in your self-answer, you can use a dummy enum definition as a hack, but note that the numeric value won't necessarily be available in all languages. It works in C++ and Python since they use numeric enums (and apparently C# too?). In Java, Protobuf enums have a .getNumber() method which you can use to get the numeric value; otherwise, normal Java enums are not numeric.

(Aside: I'm the author of most of Google's open source Protobuf code. I'm also the author of Cap'n Proto, a newer non-Google project aimed at replacing Protobufs. Among other advantages, Cap'n Proto supports defining constants in schema files. But, as of this writing C# support is not ready yet (though being worked on!).)

Answer 2

If you don't need to squeeze out every last inch of efficiency (hint: you probably don't), then just use an array of enum values.

message Msg {
    // ...
    enum Code
    {
        CODE_UNSPECIFIED = 0;
        CODE_MSG = 1;
        CODE_FILE = 2;
        CODE_APPROVE = 3;
        CODE_ACK = 4;
        CODE_ERROR_SENDING = 5;
        CODE_WORLD = 6;
    }
    repeated Code codes = 5;
}

The official protobuf docs recommend you reserve an enum entry equal to 0 to mean something like "unknown". It's really targeted at enums that are used as non-repeated values (because in proto3 there's no difference between the 0 enum value and unset) but worth following for all enums, as well as the convention of prefixing enum values with the enum name, as above.

Answer 3

I found a solution (sort of)

need an int holder.

message Foo {
  enum Flags {
    FLAG1 = 0x01;
    FLAG2 = 0x02;
    FLAG3 = 0x04;
  }

  // Bitwise-OR of Flags.
  optional uint32 flags = 1;

• Mmm, Is it the only solution ?

Answer 4

You can use message instead of enums, and use bool type for the flags you need.

Here's an example for a simple Alarm Clock schema where it can be set for multiple days in the week:

message Alarm {
    uint32 hour = 1;
    uint32 minute = 2;
    bool repeat = 3;
    DaysOfWeek daysOfWeek = 4;
    message DaysOfWeek {
        bool sunday = 1;
        bool monday = 2;
        bool tuesday = 3;
        bool wednesday = 4;
        bool thursday = 5;
        bool friday = 6;
        bool saturday = 7;
    }
}

Answer 5

Define the field as an integer:

required int32 MsgCode = 1;

Define the enum as in your question, even though nothing in the .proto file will reference it.

Use the enum fields in your code. In C#, it's like your example (although it depends on which library you use, e.g. protobuf-net is excellent and has a lightweight Enum.Field syntax). In Java, use the fields with the _VALUE suffix, e.g. MsgCodes.APPROVE_VALUE.