2.1 .proto file to Lisp conversion
2.2 CLOS classes to .proto conversion
2.3 Using .proto files directly
+ 2.3.1 A note on Lisp packages
2.4 Using the Protobufs macros
2.4.1 Protobufs types
2.4.2 Protobufs service stubs
system.)
+A note on Lisp packages
+~~~~~~~~~~~~~~~~~~~~~~~
+
+When using an existing .proto file directly, it will likely contain a
+``package`` line, but not a ``lisp_package`` line. CL-Protobufs needs
+to choose some package to use. Here is what it does:
+
+ - The package name from the ``package`` line is converted to a more
+ Lisp-like name, e.g., ``fortune_teller`` becomes ``fortune-teller``.
+ - If the Lisp package exists (i.e., you have previously used
+ ``defpackage`` to define the packaged), then CL-Protobufs just
+ uses it.
+ - If the Lisp package does not exist, CL-Protobufs creates a new
+ package of the given name that uses no other packages, not even
+ the ``common-lisp`` package. In addition, the symbols naming all
+ of the enum types, message types, field name and service method
+ names are exported from the new package.
+
+
Using the Protobufs macros
--------------------------
Protobufs types
----------------
+~~~~~~~~~~~~~~~
The following types are defined in the ``protobufs`` package:
Protobufs service stubs
------------------------
+~~~~~~~~~~~~~~~~~~~~~~~
When you use the ``proto:define-service`` macro to define a service
with some methods, the macro defines "stubs" (CLOS generic functions)
for each of the methods in the service. Each method named ``foo`` gets
a client stub and a server stub whose signatures are, respectively::
- foo (rpc-channel request &key callback) => response
- do-foo (rpc-channel request) => response
+ call-foo (rpc-channel request &key callback) => response
+ foo-impl (rpc-channel request) => response
+
+These methods are interned in a different lisp package, ``XXX-RPC``,
+where ``XXX`` is the name of the lisp package into which the rest of
+the schema's symbols are interned. This is done so that message field
+accessors methods can't collide with the stubs.
The type of *rpc-channel* is unspecified, but is meant to be a
"channel" over which the RPC call will be done. The types of *request*
(get-color (get-color-request color))
(add-color (add-color-request color)))
-The client stubs are ``get-color`` and ``add-color``, the server stubs
-are ``do-get-color`` and ``do-add-color``. An RPC library will implement
-a method for the client stub. You must fill in the server stub yourself;
-it will implement the desired functionality.
+The client stubs are ``call-get-color`` and ``call-add-color``, the
+server stubs are ``get-color-impl`` and ``add-color-impl``. An RPC
+library will implement a method for the client stub. You must fill in
+the server stub yourself; it will implement the desired functionality.
The client stub also gets a single method defined for it that looks like
something like this::
- (defmethod foo (rpc-channel (request input-type) &key callback)
+ (defmethod call-foo (rpc-channel (request input-type) &key callback)
(let ((call (and *rpc-package* *rpc-call-function*)))
(funcall call rpc-channel method request :callback callback)))
counterpart in Protobufs, but which "ground out" to compatible
Protobufs code.
+
Type aliases
------------