Why do your protocol message types have to map 1:1 with your legacy classes? Generally, attempting to map inheritance onto Protocol Buffers doesn't work very well. You are right that you can use extensions, but unless you have a large number of subclasses of OParameter, this isn't helpful. If the only subclasses of OParameter are OStringParameter, OLongParameter, and OListParameter, then I highly recommend defining OParameter as:
message OParameter { // Only one of the following will be filled in. optional int64 long_value = 1; optional string string_value = 2; repeated OParameter list_value = 3; } If you really wanted to use extensions instead, you could do: message OParameter { // Only one extension will be filled in. extensions 1 to max; } extend OParameter { optional int64 oparameter_long_value = 1; optional string oparameter_string_value = 2; repeated OParameter oparameter_list_value = 3; } This is logically equivalent to the first definition. The only difference is logistical: you can define each extension field in a different .proto file, and your program only needs to compile in the definitions of extensions that it actually uses. So you can do: // oparameter.proto message OParameter { // Only one extension will be filled in. extensions 1 to max; } // olongparameter.proto import "oparameter.proto"; extend OParameter { optional int64 oparameter_long_value = 1; } // ostringparameter.proto import "oparameter.proto"; extend OParameter { optional string oparameter_string_value = 2; } // olistparameter.proto import "oparameter.proto"; extend OParameter { repeated OParameter oparameter_list_value = 3; } But again, if you only have these three subclasses, then this is overkill. If you actually have a lot more (say, at least 10), then it might be worthwhile. Again, keep in mind that extensions are not inheritance -- they are a very different concept which happens to be able to solve similar problems. On Wed, Aug 5, 2009 at 1:31 AM, Tai <maitai.tru...@gmail.com> wrote: > > Hi Kenton, > > Sorry the parameter classes are legacy code and persisted to the DB as > well. So I have to figure out what's the best approach defining my > proto classes. > > What I see is that there is the way of using extensions in the proto > files. As far as I understand it is an extension of members (an not > classes) in another proto file. Correct? > > So in my case the files in OStringParameterMessage.proto and > OLongParameterMessage.proto extends OParameterMessage.proto with a > member "value" of type string and int64. > > The OListParameterMessage.proto then extends it with a member value of > type List (containing OParameterMessage.OParameter instances). > > In the OListParameter.writeObject() I build OParameter messages. But > wouldn't there be a problem since the value is either of type String > or Quantity (depending on the subclass of OParameter)? Probably I have > to define different member names. > > Tai > > > On 5 Aug., 03:05, Kenton Varda <ken...@google.com> wrote: > > Can you just have the OParameter message contain optional fields of type > > string and int64, where only one of the two is ever set? Then don't have > > specific types corresponding to OStringParameter and OLongParameter. > > > > On Tue, Aug 4, 2009 at 5:07 PM, Tai <maitai.tru...@gmail.com> wrote: > > > > > Hi, > > > > > I have an (abstract) class: > > > - OParameter with a member String key > > > > > Now there are also two subclasses of OParameter: > > > - OStringParameter with a member String value > > > - OLongParameter with a member long value > > > > > By using Protocol Buffers I define the proto files: > > > - OParameterMessage.proto > > > - OStringParameterMessage.proto > > > - OLongParameterMessage.proto > > > > > The files are independent from each other (no extension is used). As > > > far as I understand this is how Protocol Buffers should be used. All > > > classes (OParameter, OStringParameter and OLongParameter) then > > > implements the writeObject() and readObject() and each class just uses > > > their Protocol message and sets their members. Like: > > > - Class OStringParameter.writeObject() builds a message and sets only > > > its member (value) > > > - The superclass OParameter.writeObject() builds a message and sets > > > only its member (key) > > > > > The same goes for the readObject(). > > > > > Okay. So far so good. But now I have a class called OListParameter and > > > its member (value) is a list of OParameter containing instances of > > > both types: OStringParameter and OLongParameter. > > > > > How do I describe this in a proto file? > > > > > Thanks Tai > > > --~--~---------~--~----~------------~-------~--~----~ You received this message because you are subscribed to the Google Groups "Protocol Buffers" group. To post to this group, send email to protobuf@googlegroups.com To unsubscribe from this group, send email to protobuf+unsubscr...@googlegroups.com For more options, visit this group at http://groups.google.com/group/protobuf?hl=en -~----------~----~----~----~------~----~------~--~---