Module Async_rpc_kernel.Rpc.Rpc.Expert

module Responder : sig ... end
val schedule_dispatch : Connection.t ‑> rpc_tag:string ‑> version:int ‑> Core_kernel.Bigstring.t ‑> pos:int ‑> len:int ‑> handle_response:(Core_kernel.Bigstring.t ‑> pos:int ‑> len:int ‑> unit Async_kernel.Deferred.t) ‑> handle_error:(Core_kernel.Error.t ‑> unit) ‑> [ `Flushed of unit Async_kernel.Deferred.t | `Connection_closed ]

This just schedules a write, so the Bigstring.t should not be overwritten until the flushed Deferred.t is determined.

The return value of handle_response has the same meaning as in the function argument of Implementations.Expert.create.

val dispatch : Connection.t ‑> rpc_tag:string ‑> version:int ‑> Core_kernel.Bigstring.t ‑> pos:int ‑> len:int ‑> handle_response:(Core_kernel.Bigstring.t ‑> pos:int ‑> len:int ‑> unit Async_kernel.Deferred.t) ‑> handle_error:(Core_kernel.Error.t ‑> unit) ‑> [ `Ok | `Connection_closed ]
type implementation_result =
| Replied
| Delayed_response of unit Async_kernel.Deferred.t

Result of callbacks passed to implement and implement':

Note: it is NOT OK for an implementation to return:

          Delayed_response (Responder.schedule responder buf ~pos:... ~len:...)

where buf is the same bigstring as the one containing the query. This is because it would indicate that buf can be overwritten even though it is still being used by Responder.schedule.

val implement : (__t ‑> ('connection_state ‑> Responder.t ‑> Core_kernel.Bigstring.t ‑> pos:int ‑> len:int ‑> implementation_result Async_kernel.Deferred.t) ‑> 'connection_state Implementation.t
val implement' : (__t ‑> ('connection_state ‑> Responder.t ‑> Core_kernel.Bigstring.t ‑> pos:int ‑> len:int ‑> implementation_result) ‑> 'connection_state Implementation.t