I'm glad to be of help. You're definitely over thinking the problem.
File descriptor set- a protobuf describing one put more proto files.
Contains file descriptor proto (s)
File descriptor proto- a protobuf describing a Single proto file
File descriptor-a java class containing the descriptor information for
a proto file in a format usable by the dynamic message class and for
other "reflection" over a proto message. These can be created by
getting them from a compiled proto "root"class or built at run time
from a file descriptor proto (how you're getting them).
Descriptor- a Java class that provides descriptor information for a
particular message type that can be serialized or parsed. You get
these from a file descriptor.
Dynamic message is a class provided to build and parse messages for
which you have no compiled Java proto you must provide a descriptor
to parse messages but not for serialization.
You should not need to parse from text unless the messages are passed
as proto strings which would be an awful waste of bandwidth and
i'm not in front of a computer (on my way home from a vacation) and I
can't recall the exact method signatures but look at the dynamic
message class closer. There should be a parse our build method that
takes bytes or input stream, a descriptor (for a message type), and
optionally an extension registry. If you jabber extensions to deal
with let me know and I'll explain that better as It works differently
in Java than in cpp.
:) good luck
Sorry about grammar in places i'm on my phone.... That was a lot to
type using Swype.
On Oct 10, 9:22 am, Dale Durham <geny...@gmail.com> wrote:
> Hi All,
> Again I am new to this, so please continue to bear with me and thanks
> to Benjamin Wright for all the help so far!! I think that I am
> thinking myself into a circle between the FileDescriptors,
> FileDescriptorSets, FileDescriptorProtos, and so on. It is not yet
> really clear what is what between them all.
> So, with help from Benjamin, I can get all the base proto and
> dependency file names and field names in one way or another. Also, I
> am creating the descriptors files "on the fly" if they do not already
> exist for each message type (I have not control over the messsages
> being passed and cannot add the deccriptors to the messages
> themselves). I am still fuzzy on if I should put all the fields into
> one Desriptor proto and pass that or all the files in one
> DescriptorSet and pass that, or something else, but I'll figure that
> out eventually.
> Then I need to (or at least I THINK that I need to):
> 1) Create a new protobuf message based on the definition defined for
> the protobuf files and fields based on all the Descriptor and
> dependency stuff above (I think this should be a DynamicMessage based
> on what I have seen and read)
> 2) Do something similar to the C++ equivalent of
> protobuf->ParseFromString(message.getData()); to deserialize and get the byte
> array I have containing the actual message data into it
> I suspect that since there is protobuf no parsing in Java, I'll have
> to call out to protoc again, but if so am not sure what to pass it or
> even if my steps above are where I really need to go next. It may be
> that I need to iterate through each field, get it's type, and then
> parse from the byte stream based on that iteration.
> I also wonder if it would be faster and easier to just create a Java
> version of the message based on the C++ version that I am being passed
> in the byte array and use that instead?
> The overall base steps I need to do are:
> 1) Get a byte array containing protobuf message that was was compiled
> and serialized in C++
> 2) Get the structure of that message (base type and dependency files
> and fields in order and I can get this now, but not sure what I am
> doing is optimal)
> 3) Glue the message data into #2 above and display the it (again I
> think this may require a protoc call out, but maybe not)
> Getting the files and fields is great and cool considering that I just
> started playing with these - not because I wanted to but because I
> have to! Now I just want to be sure am doing it the best way and need
> to figure out how best to glue it all together. Most of the examples I
> can find assume the message was compiled for Java and that I know the
> type (the infamous Person Class in most of them) in advance and I do
> not. Any additional help or thoughts are appreciated.
> Thanks again,
You received this message because you are subscribed to the Google Groups
"Protocol Buffers" group.
To post to this group, send email to email@example.com.
To unsubscribe from this group, send email to
For more options, visit this group at