starpc 0.44.0 → 0.46.0

package/srpc/client-rpc.cpp

@@ -6,7 +6,7 @@
 
 namespace starpc {
 
-ClientRPC::ClientRPC(const std::string& service, const std::string& method) {
+ClientRPC::ClientRPC(const std::string &service, const std::string &method) {
   Init();
   service_ = service;
   method_ = method;
@@ -14,7 +14,8 @@ ClientRPC::ClientRPC(const std::string& service, const std::string& method) {
 
 ClientRPC::~ClientRPC() = default;
 
-Error ClientRPC::Start(PacketWriter* writer, bool write_first_msg, const std::string& first_msg) {
+Error ClientRPC::Start(PacketWriter *writer, bool write_first_msg,
+                       const std::string &first_msg) {
   if (writer == nullptr) {
     return Error::NilWriter;
   }
@@ -36,7 +37,8 @@ Error ClientRPC::Start(PacketWriter* writer, bool write_first_msg, const std::st
       first_msg_empty = first_msg.empty();
     }
 
-    auto pkt = NewCallStartPacket(service_, method_, first_msg, first_msg_empty);
+    auto pkt =
+        NewCallStartPacket(service_, method_, first_msg, first_msg_empty);
     err = writer->WritePacket(*pkt);
     if (err != Error::OK) {
       Cancel();
@@ -48,7 +50,7 @@ Error ClientRPC::Start(PacketWriter* writer, bool write_first_msg, const std::st
   return err;
 }
 
-Error ClientRPC::HandlePacketData(const std::string& data) {
+Error ClientRPC::HandlePacketData(const std::string &data) {
   srpc::Packet pkt;
   if (!pkt.ParseFromString(data)) {
     return Error::InvalidMessage;
@@ -66,28 +68,28 @@ void ClientRPC::HandleStreamClose(Error close_err) {
   cv_.notify_all();
 }
 
-Error ClientRPC::HandlePacket(const srpc::Packet& msg) {
+Error ClientRPC::HandlePacket(const srpc::Packet &msg) {
   Error err = ValidatePacket(msg);
   if (err != Error::OK) {
     return err;
   }
 
   switch (msg.body_case()) {
-    case srpc::Packet::kCallStart:
-      return HandleCallStart(msg.call_start());
-    case srpc::Packet::kCallData:
-      return HandleCallData(msg.call_data());
-    case srpc::Packet::kCallCancel:
-      if (msg.call_cancel()) {
-        return HandleCallCancel();
-      }
-      return Error::OK;
-    default:
-      return Error::OK;
+  case srpc::Packet::kCallStart:
+    return HandleCallStart(msg.call_start());
+  case srpc::Packet::kCallData:
+    return HandleCallData(msg.call_data());
+  case srpc::Packet::kCallCancel:
+    if (msg.call_cancel()) {
+      return HandleCallCancel();
+    }
+    return Error::OK;
+  default:
+    return Error::OK;
   }
 }
 
-Error ClientRPC::HandleCallStart(const srpc::CallStart& pkt) {
+Error ClientRPC::HandleCallStart(const srpc::CallStart &pkt) {
   // server-to-client calls not supported
   return Error::UnrecognizedPacket;
 }
@@ -101,4 +103,4 @@ void ClientRPC::Close() {
   }
 }
 
-}  // namespace starpc
+} // namespace starpc

package/srpc/client-rpc.hpp

@@ -11,26 +11,27 @@
 namespace srpc {
 class Packet;
 class CallStart;
-}  // namespace srpc
+} // namespace srpc
 
 namespace starpc {
 
 // ClientRPC represents the client side of an on-going RPC call message stream.
 // Matches Go ClientRPC struct in client-rpc.go
 class ClientRPC : public CommonRPC, public MsgStreamRw {
- public:
+public:
   // Constructor matching NewClientRPC in Go
-  ClientRPC(const std::string& service, const std::string& method);
+  ClientRPC(const std::string &service, const std::string &method);
   ~ClientRPC() override;
 
   // Start sets the writer and writes the CallStart message.
   // Must only be called once!
   // Matches Go Start method in client-rpc.go
-  Error Start(PacketWriter* writer, bool write_first_msg, const std::string& first_msg);
+  Error Start(PacketWriter *writer, bool write_first_msg,
+              const std::string &first_msg);
 
   // HandlePacketData handles an incoming unparsed message packet.
   // Matches Go HandlePacketData in client-rpc.go
-  Error HandlePacketData(const std::string& data);
+  Error HandlePacketData(const std::string &data);
 
   // HandleStreamClose handles the stream closing optionally with an error.
   // Matches Go HandleStreamClose (overrides CommonRPC)
@@ -38,19 +39,20 @@ class ClientRPC : public CommonRPC, public MsgStreamRw {
 
   // HandlePacket handles an incoming parsed message packet.
   // Matches Go HandlePacket in client-rpc.go
-  Error HandlePacket(const srpc::Packet& pkt);
+  Error HandlePacket(const srpc::Packet &pkt);
 
   // HandleCallStart handles the call start packet.
   // Matches Go HandleCallStart in client-rpc.go
-  Error HandleCallStart(const srpc::CallStart& pkt);
+  Error HandleCallStart(const srpc::CallStart &pkt);
 
   // Close releases any resources held by the ClientRPC.
   // Matches Go Close in client-rpc.go
   void Close();
 
   // MsgStreamRw interface implementation
-  Error ReadOne(std::string* out) override { return CommonRPC::ReadOne(out); }
-  Error WriteCallData(const std::string& data, bool data_is_zero, bool complete, Error err) override {
+  Error ReadOne(std::string *out) override { return CommonRPC::ReadOne(out); }
+  Error WriteCallData(const std::string &data, bool data_is_zero, bool complete,
+                      Error err) override {
     return CommonRPC::WriteCallData(data, data_is_zero, complete, err);
   }
   Error WriteCallCancel() override { return CommonRPC::WriteCallCancel(); }
@@ -58,8 +60,9 @@ class ClientRPC : public CommonRPC, public MsgStreamRw {
 
 // NewClientRPC constructs a new ClientRPC session.
 // Matches Go NewClientRPC function in client-rpc.go
-inline std::unique_ptr<ClientRPC> NewClientRPC(const std::string& service, const std::string& method) {
+inline std::unique_ptr<ClientRPC> NewClientRPC(const std::string &service,
+                                               const std::string &method) {
   return std::make_unique<ClientRPC>(service, method);
 }
 
-}  // namespace starpc
+} // namespace starpc

package/srpc/client.cpp

@@ -4,11 +4,9 @@
 
 namespace starpc {
 
-Error ClientImpl::ExecCall(
-    const std::string& service,
-    const std::string& method,
-    const Message& in,
-    Message* out) {
+Error ClientImpl::ExecCall(const std::string &service,
+                           const std::string &method, const Message &in,
+                           Message *out) {
   std::string first_msg;
   if (!in.SerializeToString(&first_msg)) {
     return Error::InvalidMessage;
@@ -18,7 +16,7 @@ Error ClientImpl::ExecCall(
 
   // Open the stream with handlers
   auto [writer, err] = open_stream_(
-      [&client_rpc](const std::string& data) -> Error {
+      [&client_rpc](const std::string &data) -> Error {
         return client_rpc->HandlePacketData(data);
       },
       [&client_rpc](Error close_err) {
@@ -51,10 +49,9 @@ Error ClientImpl::ExecCall(
   return Error::OK;
 }
 
-std::pair<std::unique_ptr<Stream>, Error> ClientImpl::NewStream(
-    const std::string& service,
-    const std::string& method,
-    const Message* first_msg) {
+std::pair<std::unique_ptr<Stream>, Error>
+ClientImpl::NewStream(const std::string &service, const std::string &method,
+                      const Message *first_msg) {
   std::string first_msg_data;
   if (first_msg != nullptr) {
     if (!first_msg->SerializeToString(&first_msg_data)) {
@@ -66,7 +63,7 @@ std::pair<std::unique_ptr<Stream>, Error> ClientImpl::NewStream(
 
   // Open the stream with handlers
   auto [writer, err] = open_stream_(
-      [client_rpc](const std::string& data) -> Error {
+      [client_rpc](const std::string &data) -> Error {
         return client_rpc->HandlePacketData(data);
       },
       [client_rpc](Error close_err) {
@@ -85,9 +82,8 @@ std::pair<std::unique_ptr<Stream>, Error> ClientImpl::NewStream(
   // Create MsgStream with close callback
   // Note: We need to capture writer to extend its lifetime
   auto writer_ptr = writer.release();
-  auto stream = std::make_unique<MsgStream>(
-      client_rpc.get(),
-      [client_rpc, writer_ptr]() {
+  auto stream =
+      std::make_unique<MsgStream>(client_rpc.get(), [client_rpc, writer_ptr]() {
         client_rpc->Cancel();
         if (writer_ptr) {
           writer_ptr->Close();
@@ -102,4 +98,4 @@ std::pair<std::unique_ptr<Stream>, Error> ClientImpl::NewStream(
   return {std::move(stream), Error::OK};
 }
 
-}  // namespace starpc
+} // namespace starpc

package/srpc/client.hpp

@@ -18,50 +18,42 @@ namespace starpc {
 // OpenStreamFunc opens a stream with a remote.
 // msgHandler must not be called concurrently.
 // Matches Go OpenStreamFunc in client.go
-using OpenStreamFunc = std::function<std::pair<std::unique_ptr<PacketWriter>, Error>(
-    PacketDataHandler msg_handler,
-    CloseHandler close_handler)>;
+using OpenStreamFunc =
+    std::function<std::pair<std::unique_ptr<PacketWriter>, Error>(
+        PacketDataHandler msg_handler, CloseHandler close_handler)>;
 
 // Client implements a SRPC client which can initiate RPC streams.
 // Matches Go Client interface in client.go
 class Client {
- public:
+public:
   virtual ~Client() = default;
 
   // ExecCall executes a request/reply RPC with the remote.
-  virtual Error ExecCall(
-      const std::string& service,
-      const std::string& method,
-      const Message& in,
-      Message* out) = 0;
+  virtual Error ExecCall(const std::string &service, const std::string &method,
+                         const Message &in, Message *out) = 0;
 
   // NewStream starts a streaming RPC with the remote & returns the stream.
   // firstMsg is optional (can be nullptr).
-  virtual std::pair<std::unique_ptr<Stream>, Error> NewStream(
-      const std::string& service,
-      const std::string& method,
-      const Message* first_msg) = 0;
+  virtual std::pair<std::unique_ptr<Stream>, Error>
+  NewStream(const std::string &service, const std::string &method,
+            const Message *first_msg) = 0;
 };
 
 // ClientImpl is the default implementation of Client with a transport.
 // Matches Go client struct in client.go
 class ClientImpl : public Client {
- public:
+public:
   explicit ClientImpl(OpenStreamFunc open_stream)
       : open_stream_(std::move(open_stream)) {}
 
-  Error ExecCall(
-      const std::string& service,
-      const std::string& method,
-      const Message& in,
-      Message* out) override;
+  Error ExecCall(const std::string &service, const std::string &method,
+                 const Message &in, Message *out) override;
 
-  std::pair<std::unique_ptr<Stream>, Error> NewStream(
-      const std::string& service,
-      const std::string& method,
-      const Message* first_msg) override;
+  std::pair<std::unique_ptr<Stream>, Error>
+  NewStream(const std::string &service, const std::string &method,
+            const Message *first_msg) override;
 
- private:
+private:
   OpenStreamFunc open_stream_;
 };
 
@@ -71,4 +63,4 @@ inline std::unique_ptr<Client> NewClient(OpenStreamFunc open_stream) {
   return std::make_unique<ClientImpl>(std::move(open_stream));
 }
 
-}  // namespace starpc
+} // namespace starpc

package/srpc/common-rpc.cpp

@@ -24,23 +24,20 @@ void CommonRPC::Cancel() {
   cv_.notify_all();
 }
 
-bool CommonRPC::IsCanceled() const {
-  return canceled_.load();
-}
+bool CommonRPC::IsCanceled() const { return canceled_.load(); }
 
-void CommonRPC::SetWriter(PacketWriter* writer) {
+void CommonRPC::SetWriter(PacketWriter *writer) {
   std::lock_guard<std::mutex> lock(mtx_);
   writer_ = writer;
 }
 
-Error CommonRPC::ReadOne(std::string* out) {
+Error CommonRPC::ReadOne(std::string *out) {
   bool ctx_done = false;
 
   while (true) {
     std::unique_lock<std::mutex> lock(mtx_);
 
     if (ctx_done && !data_closed_) {
-      // context must have been canceled locally
       CloseLocked();
       return Error::Canceled;
     }
@@ -58,7 +55,6 @@ Error CommonRPC::ReadOne(std::string* out) {
       return Error::EOF_;
     }
 
-    // Wait for more data or state change
     cv_.wait(lock, [this, &ctx_done]() {
       if (canceled_.load()) {
         ctx_done = true;
@@ -73,7 +69,8 @@ Error CommonRPC::ReadOne(std::string* out) {
   }
 }
 
-Error CommonRPC::WriteCallData(const std::string& data, bool data_is_zero, bool complete, Error err) {
+Error CommonRPC::WriteCallData(const std::string &data, bool data_is_zero,
+                               bool complete, Error err) {
   // Check if already completed
   if (local_completed_.load()) {
     // If we're just marking completion and already completed, allow it (no-op)
@@ -94,7 +91,8 @@ Error CommonRPC::WriteCallData(const std::string& data, bool data_is_zero, bool
     return Error::NilWriter;
   }
 
-  auto pkt = NewCallDataPacket(data, data.empty() && data_is_zero, complete, err);
+  auto pkt =
+      NewCallDataPacket(data, data.empty() && data_is_zero, complete, err);
   return writer_->WritePacket(*pkt);
 }
 
@@ -116,7 +114,7 @@ Error CommonRPC::HandleCallCancel() {
   return Error::OK;
 }
 
-Error CommonRPC::HandleCallData(const srpc::CallData& pkt) {
+Error CommonRPC::HandleCallData(const srpc::CallData &pkt) {
   std::lock_guard<std::mutex> lock(mtx_);
 
   if (data_closed_) {
@@ -136,8 +134,9 @@ Error CommonRPC::HandleCallData(const srpc::CallData& pkt) {
   bool complete = pkt.complete();
   if (!pkt.error().empty()) {
     complete = true;
-    // Store remote error - in a full implementation we might parse the error string
-    remote_err_ = Error::Unimplemented;  // Generic remote error
+    // Store remote error - in a full implementation we might parse the error
+    // string
+    remote_err_ = Error::Unimplemented; // Generic remote error
   }
 
   if (complete) {
@@ -180,4 +179,4 @@ void CommonRPC::CloseLocked() {
   canceled_.store(true);
 }
 
-}  // namespace starpc
+} // namespace starpc

package/srpc/common-rpc.hpp

@@ -18,7 +18,7 @@ namespace starpc {
 // CommonRPC contains common logic between server/client RPC.
 // Matches Go commonRPC struct in common-rpc.go
 class CommonRPC {
- public:
+public:
   CommonRPC();
   virtual ~CommonRPC();
 
@@ -32,19 +32,20 @@ class CommonRPC {
   bool IsCanceled() const;
 
   // GetService returns the service name.
-  const std::string& GetService() const { return service_; }
+  const std::string &GetService() const { return service_; }
 
   // GetMethod returns the method name.
-  const std::string& GetMethod() const { return method_; }
+  const std::string &GetMethod() const { return method_; }
 
   // ReadOne reads a single message and returns.
   // Returns EOF_ if the stream ended without a packet.
   // Matches Go ReadOne in common-rpc.go
-  Error ReadOne(std::string* out);
+  Error ReadOne(std::string *out);
 
   // WriteCallData writes a call data packet.
   // Matches Go WriteCallData in common-rpc.go
-  Error WriteCallData(const std::string& data, bool data_is_zero, bool complete, Error err);
+  Error WriteCallData(const std::string &data, bool data_is_zero, bool complete,
+                      Error err);
 
   // HandleStreamClose handles the incoming stream closing with optional error.
   // Matches Go HandleStreamClose in common-rpc.go
@@ -56,23 +57,24 @@ class CommonRPC {
 
   // HandleCallData handles the call data packet.
   // Matches Go HandleCallData in common-rpc.go
-  Error HandleCallData(const srpc::CallData& pkt);
+  Error HandleCallData(const srpc::CallData &pkt);
 
   // WriteCallCancel writes a call cancel packet.
   // Matches Go WriteCallCancel in common-rpc.go
   Error WriteCallCancel();
 
-  // WriteCallCancelLocked is the same as WriteCallCancel but assumes mtx_ is held.
+  // WriteCallCancelLocked is the same as WriteCallCancel but assumes mtx_ is
+  // held.
   Error WriteCallCancelLocked();
 
- protected:
+protected:
   // CloseLocked releases resources held by the RPC.
   // Must be called with mutex held.
   // Matches Go closeLocked in common-rpc.go
   void CloseLocked();
 
   // SetWriter sets the packet writer.
-  void SetWriter(PacketWriter* writer);
+  void SetWriter(PacketWriter *writer);
 
   // Mutex and condition variable for synchronization (replaces Go broadcast)
   mutable std::mutex mtx_;
@@ -87,7 +89,7 @@ class CommonRPC {
   std::atomic<bool> local_completed_{false};
 
   // Writer to write messages to
-  PacketWriter* writer_ = nullptr;
+  PacketWriter *writer_ = nullptr;
 
   // dataQueue contains incoming data packets.
   // Note: packets may be empty
@@ -104,4 +106,4 @@ class CommonRPC {
   std::atomic<bool> canceled_{false};
 };
 
-}  // namespace starpc
+} // namespace starpc

package/srpc/errors.hpp

@@ -8,8 +8,8 @@ namespace starpc {
 // Error codes matching Go starpc errors (see errors.go)
 enum class Error {
   OK = 0,
-  Unimplemented,      // ErrUnimplemented - RPC method was not implemented
-  Completed,          // ErrCompleted - unexpected packet after rpc was completed
+  Unimplemented, // ErrUnimplemented - RPC method was not implemented
+  Completed,     // ErrCompleted - unexpected packet after rpc was completed
   UnrecognizedPacket, // ErrUnrecognizedPacket - unrecognized packet type
   EmptyPacket,        // ErrEmptyPacket - invalid empty packet
   InvalidMessage,     // ErrInvalidMessage - message failed to parse
@@ -22,37 +22,50 @@ enum class Error {
 };
 
 // Convert Error to string (matches Go error messages)
-inline const char* ErrorString(Error err) {
+inline const char *ErrorString(Error err) {
   switch (err) {
-    case Error::OK: return "ok";
-    case Error::Unimplemented: return "unimplemented";
-    case Error::Completed: return "unexpected packet after rpc was completed";
-    case Error::UnrecognizedPacket: return "unrecognized packet type";
-    case Error::EmptyPacket: return "invalid empty packet";
-    case Error::InvalidMessage: return "invalid message";
-    case Error::EmptyMethodID: return "method id empty";
-    case Error::EmptyServiceID: return "service id empty";
-    case Error::NoAvailableClients: return "no available rpc clients";
-    case Error::NilWriter: return "writer cannot be nil";
-    case Error::Canceled: return "canceled";
-    case Error::EOF_: return "EOF";
-    default: return "unknown error";
+  case Error::OK:
+    return "ok";
+  case Error::Unimplemented:
+    return "unimplemented";
+  case Error::Completed:
+    return "unexpected packet after rpc was completed";
+  case Error::UnrecognizedPacket:
+    return "unrecognized packet type";
+  case Error::EmptyPacket:
+    return "invalid empty packet";
+  case Error::InvalidMessage:
+    return "invalid message";
+  case Error::EmptyMethodID:
+    return "method id empty";
+  case Error::EmptyServiceID:
+    return "service id empty";
+  case Error::NoAvailableClients:
+    return "no available rpc clients";
+  case Error::NilWriter:
+    return "writer cannot be nil";
+  case Error::Canceled:
+    return "canceled";
+  case Error::EOF_:
+    return "EOF";
+  default:
+    return "unknown error";
   }
 }
 
 // StarpcError exception for error propagation
 class StarpcError : public std::runtime_error {
- public:
+public:
   explicit StarpcError(Error code)
       : std::runtime_error(ErrorString(code)), code_(code) {}
 
-  StarpcError(Error code, const std::string& message)
+  StarpcError(Error code, const std::string &message)
       : std::runtime_error(message), code_(code) {}
 
   Error code() const noexcept { return code_; }
 
- private:
+private:
   Error code_;
 };
 
-}  // namespace starpc
+} // namespace starpc

package/srpc/handler.hpp

@@ -10,14 +10,14 @@ namespace starpc {
 // Handler describes a SRPC call handler implementation.
 // Matches Go Handler interface in handler.go
 class Handler : public Invoker {
- public:
+public:
   ~Handler() override = default;
 
   // GetServiceID returns the ID of the service.
-  virtual const std::string& GetServiceID() const = 0;
+  virtual const std::string &GetServiceID() const = 0;
 
   // GetMethodIDs returns the list of methods for the service.
   virtual std::vector<std::string> GetMethodIDs() const = 0;
 };
 
-}  // namespace starpc
+} // namespace starpc

package/srpc/invoker.hpp

@@ -12,47 +12,47 @@ namespace starpc {
 // Invoker is a function for invoking SRPC service methods.
 // Matches Go Invoker interface in invoker.go
 class Invoker {
- public:
+public:
   virtual ~Invoker() = default;
 
   // InvokeMethod invokes the method matching the service & method ID.
   // Returns {found, error} - found is false if method not found.
   // If service string is empty, ignore it.
-  virtual std::pair<bool, Error> InvokeMethod(
-      const std::string& service_id,
-      const std::string& method_id,
-      Stream* strm) = 0;
+  virtual std::pair<bool, Error> InvokeMethod(const std::string &service_id,
+                                              const std::string &method_id,
+                                              Stream *strm) = 0;
 };
 
 // QueryableInvoker can be used to check if a service and method is implemented.
 // Matches Go QueryableInvoker interface in invoker.go
 class QueryableInvoker {
- public:
+public:
   virtual ~QueryableInvoker() = default;
 
   // HasService checks if the service ID exists in the handlers.
-  virtual bool HasService(const std::string& service_id) const = 0;
+  virtual bool HasService(const std::string &service_id) const = 0;
 
   // HasServiceMethod checks if <service-id, method-id> exists in the handlers.
-  virtual bool HasServiceMethod(const std::string& service_id, const std::string& method_id) const = 0;
+  virtual bool HasServiceMethod(const std::string &service_id,
+                                const std::string &method_id) const = 0;
 };
 
 // InvokerSlice is a list of invokers.
 // Matches Go InvokerSlice in invoker.go
 class InvokerSlice : public Invoker {
- public:
+public:
   InvokerSlice() = default;
-  explicit InvokerSlice(std::vector<Invoker*> invokers)
+  explicit InvokerSlice(std::vector<Invoker *> invokers)
       : invokers_(std::move(invokers)) {}
 
-  void Add(Invoker* invoker) { invokers_.push_back(invoker); }
+  void Add(Invoker *invoker) { invokers_.push_back(invoker); }
 
-  std::pair<bool, Error> InvokeMethod(
-      const std::string& service_id,
-      const std::string& method_id,
-      Stream* strm) override {
-    for (auto* invoker : invokers_) {
-      if (invoker == nullptr) continue;
+  std::pair<bool, Error> InvokeMethod(const std::string &service_id,
+                                      const std::string &method_id,
+                                      Stream *strm) override {
+    for (auto *invoker : invokers_) {
+      if (invoker == nullptr)
+        continue;
       auto [found, err] = invoker->InvokeMethod(service_id, method_id, strm);
       if (found || err != Error::OK) {
         return {true, err};
@@ -61,34 +61,31 @@ class InvokerSlice : public Invoker {
     return {false, Error::OK};
   }
 
- private:
-  std::vector<Invoker*> invokers_;
+private:
+  std::vector<Invoker *> invokers_;
 };
 
 // InvokerFunc is a function implementing InvokeMethod.
 // Matches Go InvokerFunc in invoker.go
 using InvokerFunc = std::function<std::pair<bool, Error>(
-    const std::string& service_id,
-    const std::string& method_id,
-    Stream* strm)>;
+    const std::string &service_id, const std::string &method_id, Stream *strm)>;
 
 // InvokerFuncWrapper wraps an InvokerFunc as an Invoker.
 class InvokerFuncWrapper : public Invoker {
- public:
+public:
   explicit InvokerFuncWrapper(InvokerFunc fn) : fn_(std::move(fn)) {}
 
-  std::pair<bool, Error> InvokeMethod(
-      const std::string& service_id,
-      const std::string& method_id,
-      Stream* strm) override {
+  std::pair<bool, Error> InvokeMethod(const std::string &service_id,
+                                      const std::string &method_id,
+                                      Stream *strm) override {
     if (!fn_) {
       return {false, Error::OK};
     }
     return fn_(service_id, method_id, strm);
   }
 
- private:
+private:
   InvokerFunc fn_;
 };
 
-}  // namespace starpc
+} // namespace starpc

package/srpc/lib.rs

@@ -66,6 +66,7 @@ pub mod mux;
 pub mod packet;
 pub mod proto;
 pub mod rpc;
+pub mod rpcstream;
 pub mod server;
 pub mod stream;
 pub mod testing;