Performance can be significantly improved using a strategy of precompiling the constant portions of your message. Enumerations for example, are excellent candidates for precompilation. Using protobuf_message/3, the precompiled portion of the message is inserted directly in the wire-stream on encode, and is unified with, and removed from the wire-stream on decode. The following shows how the "send_command" example above, can be converted to precompiled form:
:- dynamic precompiled_message/3.
send_precompiled_command(Command, Vector, Msg) :-
basic_vector(Vector, Proto1),
precompiled_message(commands(Command), Msg, Tail),
protobuf_message(protobuf([embedded(3, Proto1)]), Tail).
precompile_commands :-
abolish(precompiled_message/3),
forall(protobufs:commands(Key, _),
( Proto = protobuf([atom(1, command),
enum(2, commands(Key))]),
protobuf_message(Proto, Msg, Tail),
assert(precompiled_message(commands(Key), Msg, Tail))
)),
compile_predicates([precompiled_message/3]).
*
*
*
:- initialization
precompile_commands.
You can extend the parser to support your own compound host types.
These are treated as first class entities by the parser. That is they
can be used either by themselves, or in repeated and embedded
clauses just as any other host type would be. You do this by hooking
into the parser and adding your own message_sequence
productions. Your hook eventually calls back into the parser with your
substitution/expansion protobuf, which is then embedded in the wire
stream. Recursive structures can be defined this way. A simple example
of a recursive XML like structure is shown in the appendix.