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
