starpc 0.45.0 → 0.46.0

package/echo/echo_srpc.pb.rs

@@ -0,0 +1,312 @@
+// Code generated by protoc-gen-starpc-rust. DO NOT EDIT.
+// protoc-gen-starpc-rust version: v0.45.1-0.20260203090429-3e915608d4e8
+// source: github.com/aperturerobotics/starpc/echo/echo.proto
+
+#[allow(unused_imports)]
+use starpc::StreamExt;
+
+/// Service ID for Echoer.
+pub const ECHOER_SERVICE_ID: &str = "echo.Echoer";
+
+/// Stream trait for Echoer.EchoServerStream.
+#[starpc::async_trait]
+pub trait EchoerEchoServerStreamStream: Send + Sync {
+    /// Returns the context for this stream.
+    fn context(&self) -> &starpc::Context;
+    /// Receives a message from the stream.
+    async fn recv(&self) -> starpc::Result<EchoMsg>;
+    /// Closes the stream.
+    async fn close(&self) -> starpc::Result<()>;
+}
+
+/// Stream trait for Echoer.EchoClientStream.
+#[starpc::async_trait]
+pub trait EchoerEchoClientStreamStream: Send + Sync {
+    /// Returns the context for this stream.
+    fn context(&self) -> &starpc::Context;
+    /// Sends a message on the stream.
+    async fn send(&self, msg: &EchoMsg) -> starpc::Result<()>;
+    /// Closes the send side and receives the response.
+    async fn close_and_recv(&self) -> starpc::Result<EchoMsg>;
+}
+
+/// Stream trait for Echoer.EchoBidiStream.
+#[starpc::async_trait]
+pub trait EchoerEchoBidiStreamStream: Send + Sync {
+    /// Returns the context for this stream.
+    fn context(&self) -> &starpc::Context;
+    /// Sends a message on the stream.
+    async fn send(&self, msg: &EchoMsg) -> starpc::Result<()>;
+    /// Receives a message from the stream.
+    async fn recv(&self) -> starpc::Result<EchoMsg>;
+    /// Closes the stream.
+    async fn close(&self) -> starpc::Result<()>;
+}
+
+/// Stream trait for Echoer.RpcStream.
+#[starpc::async_trait]
+pub trait EchoerRpcStreamStream: Send + Sync {
+    /// Returns the context for this stream.
+    fn context(&self) -> &starpc::Context;
+    /// Sends a message on the stream.
+    async fn send(&self, msg: &RpcStreamPacket) -> starpc::Result<()>;
+    /// Receives a message from the stream.
+    async fn recv(&self) -> starpc::Result<RpcStreamPacket>;
+    /// Closes the stream.
+    async fn close(&self) -> starpc::Result<()>;
+}
+
+/// Client trait for Echoer.
+#[starpc::async_trait]
+pub trait EchoerClient: Send + Sync {
+    /// Echo.
+    async fn echo(&self, request: &EchoMsg) -> starpc::Result<EchoMsg>;
+    /// EchoServerStream.
+    async fn echo_server_stream(&self, request: &EchoMsg) -> starpc::Result<Box<dyn EchoerEchoServerStreamStream>>;
+    /// EchoClientStream.
+    async fn echo_client_stream(&self) -> starpc::Result<Box<dyn EchoerEchoClientStreamStream>>;
+    /// EchoBidiStream.
+    async fn echo_bidi_stream(&self) -> starpc::Result<Box<dyn EchoerEchoBidiStreamStream>>;
+    /// RpcStream.
+    async fn rpc_stream(&self) -> starpc::Result<Box<dyn EchoerRpcStreamStream>>;
+    /// DoNothing.
+    async fn do_nothing(&self, request: &Empty) -> starpc::Result<Empty>;
+}
+
+/// Client implementation for Echoer.
+pub struct EchoerClientImpl<C> {
+    client: C,
+}
+
+impl<C: starpc::Client> EchoerClientImpl<C> {
+    /// Creates a new client.
+    pub fn new(client: C) -> Self {
+        Self { client }
+    }
+}
+
+#[starpc::async_trait]
+impl<C: starpc::Client + 'static> EchoerClient for EchoerClientImpl<C> {
+    async fn echo(&self, request: &EchoMsg) -> starpc::Result<EchoMsg> {
+        self.client.exec_call("echo.Echoer", "Echo", request).await
+    }
+    async fn echo_server_stream(&self, request: &EchoMsg) -> starpc::Result<Box<dyn EchoerEchoServerStreamStream>> {
+        use starpc::ProstMessage;
+        let data = request.encode_to_vec();
+        let stream = self.client.new_stream("echo.Echoer", "EchoServerStream", Some(&data)).await?;
+        stream.close_send().await?;
+        Ok(Box::new(EchoerEchoServerStreamStreamImpl { stream }))
+    }
+    async fn echo_client_stream(&self) -> starpc::Result<Box<dyn EchoerEchoClientStreamStream>> {
+        let stream = self.client.new_stream("echo.Echoer", "EchoClientStream", None).await?;
+        Ok(Box::new(EchoerEchoClientStreamStreamImpl { stream }))
+    }
+    async fn echo_bidi_stream(&self) -> starpc::Result<Box<dyn EchoerEchoBidiStreamStream>> {
+        let stream = self.client.new_stream("echo.Echoer", "EchoBidiStream", None).await?;
+        Ok(Box::new(EchoerEchoBidiStreamStreamImpl { stream }))
+    }
+    async fn rpc_stream(&self) -> starpc::Result<Box<dyn EchoerRpcStreamStream>> {
+        let stream = self.client.new_stream("echo.Echoer", "RpcStream", None).await?;
+        Ok(Box::new(EchoerRpcStreamStreamImpl { stream }))
+    }
+    async fn do_nothing(&self, request: &Empty) -> starpc::Result<Empty> {
+        self.client.exec_call("echo.Echoer", "DoNothing", request).await
+    }
+}
+
+struct EchoerEchoServerStreamStreamImpl {
+    stream: Box<dyn starpc::Stream>,
+}
+
+#[starpc::async_trait]
+impl EchoerEchoServerStreamStream for EchoerEchoServerStreamStreamImpl {
+    fn context(&self) -> &starpc::Context {
+        self.stream.context()
+    }
+    async fn recv(&self) -> starpc::Result<EchoMsg> {
+        self.stream.msg_recv().await
+    }
+    async fn close(&self) -> starpc::Result<()> {
+        self.stream.close().await
+    }
+}
+
+struct EchoerEchoClientStreamStreamImpl {
+    stream: Box<dyn starpc::Stream>,
+}
+
+#[starpc::async_trait]
+impl EchoerEchoClientStreamStream for EchoerEchoClientStreamStreamImpl {
+    fn context(&self) -> &starpc::Context {
+        self.stream.context()
+    }
+    async fn send(&self, msg: &EchoMsg) -> starpc::Result<()> {
+        self.stream.msg_send(msg).await
+    }
+    async fn close_and_recv(&self) -> starpc::Result<EchoMsg> {
+        self.stream.close_send().await?;
+        self.stream.msg_recv().await
+    }
+}
+
+struct EchoerEchoBidiStreamStreamImpl {
+    stream: Box<dyn starpc::Stream>,
+}
+
+#[starpc::async_trait]
+impl EchoerEchoBidiStreamStream for EchoerEchoBidiStreamStreamImpl {
+    fn context(&self) -> &starpc::Context {
+        self.stream.context()
+    }
+    async fn send(&self, msg: &EchoMsg) -> starpc::Result<()> {
+        self.stream.msg_send(msg).await
+    }
+    async fn recv(&self) -> starpc::Result<EchoMsg> {
+        self.stream.msg_recv().await
+    }
+    async fn close(&self) -> starpc::Result<()> {
+        self.stream.close().await
+    }
+}
+
+struct EchoerRpcStreamStreamImpl {
+    stream: Box<dyn starpc::Stream>,
+}
+
+#[starpc::async_trait]
+impl EchoerRpcStreamStream for EchoerRpcStreamStreamImpl {
+    fn context(&self) -> &starpc::Context {
+        self.stream.context()
+    }
+    async fn send(&self, msg: &RpcStreamPacket) -> starpc::Result<()> {
+        self.stream.msg_send(msg).await
+    }
+    async fn recv(&self) -> starpc::Result<RpcStreamPacket> {
+        self.stream.msg_recv().await
+    }
+    async fn close(&self) -> starpc::Result<()> {
+        self.stream.close().await
+    }
+}
+
+/// Server trait for Echoer.
+#[starpc::async_trait]
+pub trait EchoerServer: Send + Sync {
+    /// Echo.
+    async fn echo(&self, request: EchoMsg) -> starpc::Result<EchoMsg>;
+    /// EchoServerStream.
+    async fn echo_server_stream(&self, request: EchoMsg, stream: Box<dyn starpc::Stream>) -> starpc::Result<()>;
+    /// EchoClientStream.
+    async fn echo_client_stream(&self, stream: &dyn starpc::Stream) -> starpc::Result<EchoMsg>;
+    /// EchoBidiStream.
+    async fn echo_bidi_stream(&self, stream: Box<dyn starpc::Stream>) -> starpc::Result<()>;
+    /// RpcStream.
+    async fn rpc_stream(&self, stream: Box<dyn starpc::Stream>) -> starpc::Result<()>;
+    /// DoNothing.
+    async fn do_nothing(&self, request: Empty) -> starpc::Result<Empty>;
+}
+
+const ECHOER_METHOD_IDS: &[&str] = &[
+    "Echo",
+    "EchoServerStream",
+    "EchoClientStream",
+    "EchoBidiStream",
+    "RpcStream",
+    "DoNothing",
+];
+
+/// Handler for Echoer.
+pub struct EchoerHandler<S: EchoerServer> {
+    server: std::sync::Arc<S>,
+}
+
+impl<S: EchoerServer + 'static> EchoerHandler<S> {
+    /// Creates a new handler wrapping the server implementation.
+    pub fn new(server: S) -> Self {
+        Self { server: std::sync::Arc::new(server) }
+    }
+
+    /// Creates a new handler with a shared server.
+    pub fn with_arc(server: std::sync::Arc<S>) -> Self {
+        Self { server }
+    }
+}
+
+#[starpc::async_trait]
+impl<S: EchoerServer + 'static> starpc::Invoker for EchoerHandler<S> {
+    async fn invoke_method(
+        &self,
+        _service_id: &str,
+        method_id: &str,
+        stream: Box<dyn starpc::Stream>,
+    ) -> (bool, starpc::Result<()>) {
+        match method_id {
+            "Echo" => {
+                let request: EchoMsg = match stream.msg_recv().await {
+                    Ok(r) => r,
+                    Err(e) => return (true, Err(e)),
+                };
+                match self.server.echo(request).await {
+                    Ok(response) => {
+                        if let Err(e) = stream.msg_send(&response).await {
+                            return (true, Err(e));
+                        }
+                        (true, Ok(()))
+                    }
+                    Err(e) => (true, Err(e)),
+                }
+            }
+            "EchoServerStream" => {
+                let request: EchoMsg = match stream.msg_recv().await {
+                    Ok(r) => r,
+                    Err(e) => return (true, Err(e)),
+                };
+                (true, self.server.echo_server_stream(request, stream).await)
+            }
+            "EchoClientStream" => {
+                match self.server.echo_client_stream(stream.as_ref()).await {
+                    Ok(response) => {
+                        if let Err(e) = stream.msg_send(&response).await {
+                            return (true, Err(e));
+                        }
+                        (true, Ok(()))
+                    }
+                    Err(e) => (true, Err(e)),
+                }
+            }
+            "EchoBidiStream" => {
+                (true, self.server.echo_bidi_stream(stream).await)
+            }
+            "RpcStream" => {
+                (true, self.server.rpc_stream(stream).await)
+            }
+            "DoNothing" => {
+                let request: Empty = match stream.msg_recv().await {
+                    Ok(r) => r,
+                    Err(e) => return (true, Err(e)),
+                };
+                match self.server.do_nothing(request).await {
+                    Ok(response) => {
+                        if let Err(e) = stream.msg_send(&response).await {
+                            return (true, Err(e));
+                        }
+                        (true, Ok(()))
+                    }
+                    Err(e) => (true, Err(e)),
+                }
+            }
+            _ => (false, Err(starpc::Error::Unimplemented)),
+        }
+    }
+}
+
+impl<S: EchoerServer + 'static> starpc::Handler for EchoerHandler<S> {
+    fn service_id(&self) -> &'static str {
+        "echo.Echoer"
+    }
+
+    fn method_ids(&self) -> &'static [&'static str] {
+        ECHOER_METHOD_IDS
+    }
+}
+

package/echo/gen/mod.rs

@@ -1,3 +1,16 @@
-//! Generated code - do not edit.
+//! Generated code for the echo service.
+//!
+//! This module includes pre-generated protobuf types and service stubs.
 
-include!(concat!(env!("OUT_DIR"), "/echo.rs"));
+// Re-export starpc's RpcStreamPacket types for use by the service stubs.
+pub use starpc::rpcstream::RpcStreamPacket;
+
+// Empty type for google.protobuf.Empty
+#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
+pub struct Empty {}
+
+// Include the generated message types.
+include!("../echo.pb.rs");
+
+// Include the generated service stubs.
+include!("../echo_srpc.pb.rs");

package/echo/main.rs

@@ -89,6 +89,15 @@ impl EchoerServer for EchoServerImpl {
 
         Ok(())
     }
+
+    async fn rpc_stream(&self, _stream: Box<dyn Stream>) -> Result<()> {
+        // RPC stream is not implemented in this example.
+        Err(Error::Unimplemented)
+    }
+
+    async fn do_nothing(&self, _request: gen::Empty) -> Result<gen::Empty> {
+        Ok(gen::Empty {})
+    }
 }
 
 #[tokio::main]

package/go.mod

@@ -11,8 +11,8 @@ replace (
 )
 
 require (
-	github.com/aperturerobotics/common v0.29.0 // latest
-	github.com/aperturerobotics/protobuf-go-lite v0.12.0 // latest
+	github.com/aperturerobotics/common v0.30.1-0.20260203095300-e0754eb22a37 // latest
+	github.com/aperturerobotics/protobuf-go-lite v0.12.1 // latest
 	github.com/aperturerobotics/util v1.32.3 // latest
 )
 
@@ -34,6 +34,7 @@ require (
 )
 
 require (
+	github.com/aperturerobotics/go-protoc-gen-prost v0.0.0-20260203094828-3faf47d2c868 // indirect
 	github.com/ipfs/go-cid v0.4.1 // indirect
 	github.com/klauspost/cpuid/v2 v2.2.8 // indirect
 	github.com/libp2p/go-buffer-pool v0.1.0 // indirect

package/go.sum

@@ -2,18 +2,20 @@ github.com/aperturerobotics/abseil-cpp v0.0.0-20260131110040-4bb56e2f9017 h1:3U7
 github.com/aperturerobotics/abseil-cpp v0.0.0-20260131110040-4bb56e2f9017/go.mod h1:lNSJTKECIUFAnfeSqy01kXYTYe1BHubW7198jNX3nEw=
 github.com/aperturerobotics/cli v1.1.0 h1:7a+YRC+EY3npAnTzhHV5gLCiw91KS0Ts3XwLILGOsT8=
 github.com/aperturerobotics/cli v1.1.0/go.mod h1:M7BFP9wow5ytTzMyJQOOO991fGfsUqdTI7gGEsHfTQ8=
-github.com/aperturerobotics/common v0.29.0 h1:zSRERLPqmOD0RNs0I/Jr0YVv2Top0oKoDojEdxJEu38=
-github.com/aperturerobotics/common v0.29.0/go.mod h1:q8ix+7nLZZ0FQ1j5w/EXI5S0FbVUX8k+eJkw83pPTT4=
+github.com/aperturerobotics/common v0.30.1-0.20260203095300-e0754eb22a37 h1:ia/PiOkGovJUA2Evo3Qjn6mARVbpeACO5ENs5EKH3aQ=
+github.com/aperturerobotics/common v0.30.1-0.20260203095300-e0754eb22a37/go.mod h1:o3LkfVkdyNtWz31nGkCKuMP7H2dxarmYCYgXmy1zjtg=
 github.com/aperturerobotics/go-libp2p v0.37.1-0.20241111002741-5cfbb50b74e0 h1:tGwbeDoEeQCrUQL+ClUywldqvz9eRmhcVrGwGxz2xJg=
 github.com/aperturerobotics/go-libp2p v0.37.1-0.20241111002741-5cfbb50b74e0/go.mod h1:FJkAtQcP9XxqG1NNLNHKm+wLVIGSCQX2s6CEoD+w97g=
+github.com/aperturerobotics/go-protoc-gen-prost v0.0.0-20260203094828-3faf47d2c868 h1:r2j7F1tGHkchPBLL55e44g/DfYqK2JV0Ed8suMAxmlU=
+github.com/aperturerobotics/go-protoc-gen-prost v0.0.0-20260203094828-3faf47d2c868/go.mod h1:OBb/beWmr/pDIZAUfi86j/4tBh2v5ctTxKMqSnh9c/4=
 github.com/aperturerobotics/go-protoc-wasi v0.0.0-20260131050911-b5f94b044584 h1:ER8DYYL71cTg39uZ+Gi699tL/hZoscUWDOw4DbizqhI=
 github.com/aperturerobotics/go-protoc-wasi v0.0.0-20260131050911-b5f94b044584/go.mod h1:vEq8i7EKb32+KXGtIEZjjhNns+BdsL2dUMw4uhy3578=
 github.com/aperturerobotics/json-iterator-lite v1.0.1-0.20251104042408-0c9eb8a3f726 h1:4B1F0DzuqPzb6WqgCjWaqDD7JU9RDsevQG5OP0DFBgs=
 github.com/aperturerobotics/json-iterator-lite v1.0.1-0.20251104042408-0c9eb8a3f726/go.mod h1:SvGGBv3OVxUyqO0ZxA/nvs6z3cg7NIbZ64TnbV2OISo=
 github.com/aperturerobotics/protobuf v0.0.0-20260203024654-8201686529c4 h1:4Dy3BAHh2kgVdHAqtlwcFsgY0kAwUe2m3rfFcaGwGQg=
 github.com/aperturerobotics/protobuf v0.0.0-20260203024654-8201686529c4/go.mod h1:tMgO7y6SJo/d9ZcvrpNqIQtdYT9de+QmYaHOZ4KnhOg=
-github.com/aperturerobotics/protobuf-go-lite v0.12.0 h1:ZPPokQtm/NPhgGv+vYD9AhInvkrzQal6MDnqcYLWvlg=
-github.com/aperturerobotics/protobuf-go-lite v0.12.0/go.mod h1:lGH3s5ArCTXKI4wJdlNpaybUtwSjfAG0vdWjxOfMcF8=
+github.com/aperturerobotics/protobuf-go-lite v0.12.1 h1:o9of87F/LFS2p5xfq32CrU99dvfqIAalTP7ZzoZK6Kg=
+github.com/aperturerobotics/protobuf-go-lite v0.12.1/go.mod h1:lGH3s5ArCTXKI4wJdlNpaybUtwSjfAG0vdWjxOfMcF8=
 github.com/aperturerobotics/util v1.32.3 h1:wBc6L2guYMgLEzFwORH3CLMoMpfEqbV6pDqYervo3S0=
 github.com/aperturerobotics/util v1.32.3/go.mod h1:qfRZZUDn0sEfc43JRA6rKP8bwFxliqGqJZX+p1jeOnQ=
 github.com/coder/websocket v1.8.14 h1:9L0p0iKiNOibykf283eHkKUHHrpG7f65OE3BhhO7v9g=

package/mock/mock.pb.go

@@ -1,5 +1,5 @@
 // Code generated by protoc-gen-go-lite. DO NOT EDIT.
-// protoc-gen-go-lite version: v0.12.0
+// protoc-gen-go-lite version: v0.12.1
 // source: github.com/aperturerobotics/starpc/mock/mock.proto
 
 package e2e_mock

package/mock/mock.pb.rs

@@ -0,0 +1,9 @@
+// @generated
+// This file is @generated by prost-build.
+/// MockMsg is the mock message body.
+#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
+pub struct MockMsg {
+    #[prost(string, tag="1")]
+    pub body: ::prost::alloc::string::String,
+}
+// @@protoc_insertion_point(module)

package/mock/mock.pb.ts

@@ -1,4 +1,4 @@
-// @generated by protoc-gen-es-lite unknown with parameter "ts_nocheck=false,target=ts"
+// @generated by protoc-gen-es-lite unknown with parameter "target=ts,ts_nocheck=false"
 // @generated from file github.com/aperturerobotics/starpc/mock/mock.proto (package e2e.mock, syntax proto3)
 /* eslint-disable */
 

package/mock/mock_srpc.pb.cpp

@@ -1,28 +1,27 @@
-// go:build deps_only
+//go:build deps_only
 
 // Code generated by protoc-gen-starpc-cpp. DO NOT EDIT.
-// protoc-gen-starpc-cpp version: v0.43.2-0.20260131104303-1de77bff6409+dirty
+// protoc-gen-starpc-cpp version: v0.45.1-0.20260203090429-3e915608d4e8
 // source: github.com/aperturerobotics/starpc/mock/mock.proto
 
 #include "mock_srpc.pb.hpp"
 
 namespace e2e::mock {
 
-starpc::Error SRPCMockClientImpl::MockRequest(const e2e::mock::MockMsg &in,
-                                              e2e::mock::MockMsg *out) {
+starpc::Error SRPCMockClientImpl::MockRequest(const e2e::mock::MockMsg& in, e2e::mock::MockMsg* out) {
   return cc_->ExecCall(service_id_, "MockRequest", in, out);
 }
 
 std::vector<std::string> SRPCMockHandler::GetMethodIDs() const {
   return {
-      "MockRequest",
+    "MockRequest",
   };
 }
 
-std::pair<bool, starpc::Error>
-SRPCMockHandler::InvokeMethod(const std::string &service_id,
-                              const std::string &method_id,
-                              starpc::Stream *strm) {
+std::pair<bool, starpc::Error> SRPCMockHandler::InvokeMethod(
+    const std::string& service_id,
+    const std::string& method_id,
+    starpc::Stream* strm) {
   if (!service_id.empty() && service_id != service_id_) {
     return {false, starpc::Error::OK};
   }
@@ -30,16 +29,14 @@ SRPCMockHandler::InvokeMethod(const std::string &service_id,
   if (method_id == "MockRequest") {
     e2e::mock::MockMsg req;
     starpc::Error err = strm->MsgRecv(&req);
-    if (err != starpc::Error::OK)
-      return {true, err};
+    if (err != starpc::Error::OK) return {true, err};
     e2e::mock::MockMsg resp;
     err = impl_->MockRequest(req, &resp);
-    if (err != starpc::Error::OK)
-      return {true, err};
+    if (err != starpc::Error::OK) return {true, err};
     return {true, strm->MsgSend(resp)};
   }
 
   return {false, starpc::Error::OK};
 }
 
-} // namespace e2e::mock
+}  // namespace e2e::mock

package/mock/mock_srpc.pb.go

@@ -1,5 +1,5 @@
 // Code generated by protoc-gen-srpc. DO NOT EDIT.
-// protoc-gen-srpc version: v0.42.0
+// protoc-gen-srpc version: v0.45.1-0.20260203090429-3e915608d4e8
 // source: github.com/aperturerobotics/starpc/mock/mock.proto
 
 package e2e_mock

package/mock/mock_srpc.pb.hpp

@@ -1,5 +1,7 @@
+//go:build deps_only && cgo
+
 // Code generated by protoc-gen-starpc-cpp. DO NOT EDIT.
-// protoc-gen-starpc-cpp version: v0.43.2-0.20260131104303-1de77bff6409+dirty
+// protoc-gen-starpc-cpp version: v0.45.1-0.20260203090429-3e915608d4e8
 // source: github.com/aperturerobotics/starpc/mock/mock.proto
 
 #pragma once
@@ -16,83 +18,77 @@
 namespace e2e::mock {
 
 // Service ID for Mock
-constexpr const char *kSRPCMockServiceID = "e2e.mock.Mock";
+constexpr const char* kSRPCMockServiceID = "e2e.mock.Mock";
+
 
 // SRPCMockClient is the client API for Mock service.
 class SRPCMockClient {
-public:
+ public:
   virtual ~SRPCMockClient() = default;
 
   // SRPCClient returns the underlying SRPC client.
-  virtual starpc::Client *SRPCClient() = 0;
+  virtual starpc::Client* SRPCClient() = 0;
 
   // MockRequest
-  virtual starpc::Error MockRequest(const e2e::mock::MockMsg &in,
-                                    e2e::mock::MockMsg *out) = 0;
+  virtual starpc::Error MockRequest(const e2e::mock::MockMsg& in, e2e::mock::MockMsg* out) = 0;
 };
 
 // SRPCMockClientImpl implements SRPCMockClient.
 class SRPCMockClientImpl : public SRPCMockClient {
-public:
-  explicit SRPCMockClientImpl(starpc::Client *cc,
-                              const std::string &service_id = "")
-      : cc_(cc),
-        service_id_(service_id.empty() ? kSRPCMockServiceID : service_id) {}
+ public:
+  explicit SRPCMockClientImpl(starpc::Client* cc, const std::string& service_id = "")
+      : cc_(cc), service_id_(service_id.empty() ? kSRPCMockServiceID : service_id) {}
 
-  starpc::Client *SRPCClient() override { return cc_; }
+  starpc::Client* SRPCClient() override { return cc_; }
 
   // MockRequest
-  virtual starpc::Error MockRequest(const e2e::mock::MockMsg &in,
-                                    e2e::mock::MockMsg *out) override;
+  virtual starpc::Error MockRequest(const e2e::mock::MockMsg& in, e2e::mock::MockMsg* out) override;
 
-private:
-  starpc::Client *cc_;
+ private:
+  starpc::Client* cc_;
   std::string service_id_;
 };
 
 // NewSRPCMockClient creates a new client.
-inline std::unique_ptr<SRPCMockClient> NewSRPCMockClient(starpc::Client *cc) {
+inline std::unique_ptr<SRPCMockClient> NewSRPCMockClient(starpc::Client* cc) {
   return std::make_unique<SRPCMockClientImpl>(cc);
 }
 
 // SRPCMockServer is the server API for Mock service.
 class SRPCMockServer {
-public:
+ public:
   virtual ~SRPCMockServer() = default;
 
   // MockRequest
-  virtual starpc::Error MockRequest(const e2e::mock::MockMsg &req,
-                                    e2e::mock::MockMsg *resp) = 0;
+  virtual starpc::Error MockRequest(const e2e::mock::MockMsg& req, e2e::mock::MockMsg* resp) = 0;
 };
 
 // SRPCMockHandler implements starpc::Handler for Mock.
 class SRPCMockHandler : public starpc::Handler {
-public:
-  SRPCMockHandler(SRPCMockServer *impl, const std::string &service_id = "")
-      : impl_(impl),
-        service_id_(service_id.empty() ? kSRPCMockServiceID : service_id) {}
+ public:
+  SRPCMockHandler(SRPCMockServer* impl, const std::string& service_id = "")
+      : impl_(impl), service_id_(service_id.empty() ? kSRPCMockServiceID : service_id) {}
 
-  const std::string &GetServiceID() const override { return service_id_; }
+  const std::string& GetServiceID() const override { return service_id_; }
   std::vector<std::string> GetMethodIDs() const override;
-  std::pair<bool, starpc::Error> InvokeMethod(const std::string &service_id,
-                                              const std::string &method_id,
-                                              starpc::Stream *strm) override;
+  std::pair<bool, starpc::Error> InvokeMethod(
+      const std::string& service_id,
+      const std::string& method_id,
+      starpc::Stream* strm) override;
 
-private:
-  SRPCMockServer *impl_;
+ private:
+  SRPCMockServer* impl_;
   std::string service_id_;
 };
 
 // NewSRPCMockHandler creates a new handler for the given implementation.
-inline std::unique_ptr<SRPCMockHandler>
-NewSRPCMockHandler(SRPCMockServer *impl) {
+inline std::unique_ptr<SRPCMockHandler> NewSRPCMockHandler(SRPCMockServer* impl) {
   return std::make_unique<SRPCMockHandler>(impl);
 }
 
 // SRPCRegisterMock registers the server implementation with the mux.
 // The returned handler must outlive the mux registration.
-inline std::pair<std::unique_ptr<SRPCMockHandler>, starpc::Error>
-SRPCRegisterMock(starpc::Mux *mux, SRPCMockServer *impl) {
+inline std::pair<std::unique_ptr<SRPCMockHandler>, starpc::Error> SRPCRegisterMock(starpc::Mux* mux, SRPCMockServer* impl) {
   auto handler = NewSRPCMockHandler(impl);
   starpc::Error err = mux->Register(handler.get());
   if (err != starpc::Error::OK) {
@@ -101,4 +97,4 @@ SRPCRegisterMock(starpc::Mux *mux, SRPCMockServer *impl) {
   return {std::move(handler), starpc::Error::OK};
 }
 
-} // namespace e2e::mock
+}  // namespace e2e::mock