starpc 0.44.0 → 0.45.0

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/message.hpp

@@ -13,18 +13,16 @@ using Message = google::protobuf::MessageLite;
 
 // MarshalVT serializes the message to bytes.
 // (VT suffix matches vtprotobuf convention used in Go)
-inline bool MarshalVT(const Message& msg, std::string* out) {
+inline bool MarshalVT(const Message &msg, std::string *out) {
   return msg.SerializeToString(out);
 }
 
 // UnmarshalVT deserializes the message from bytes.
-inline bool UnmarshalVT(Message* msg, const std::string& data) {
+inline bool UnmarshalVT(Message *msg, const std::string &data) {
   return msg->ParseFromString(data);
 }
 
 // SizeVT returns the serialized size of the message.
-inline size_t SizeVT(const Message& msg) {
-  return msg.ByteSizeLong();
-}
+inline size_t SizeVT(const Message &msg) { return msg.ByteSizeLong(); }
 
-}  // namespace starpc
+} // namespace starpc

package/srpc/msg-stream.hpp

@@ -12,15 +12,16 @@ namespace starpc {
 // MsgStreamRw is the read-write interface for MsgStream.
 // Matches Go MsgStreamRw interface in msg-stream.go
 class MsgStreamRw {
- public:
+public:
   virtual ~MsgStreamRw() = default;
 
   // ReadOne reads a single message and returns.
   // Returns EOF_ if the stream ended.
-  virtual Error ReadOne(std::string* out) = 0;
+  virtual Error ReadOne(std::string *out) = 0;
 
   // WriteCallData writes a call data packet.
-  virtual Error WriteCallData(const std::string& data, bool data_is_zero, bool complete, Error err) = 0;
+  virtual Error WriteCallData(const std::string &data, bool data_is_zero,
+                              bool complete, Error err) = 0;
 
   // WriteCallCancel writes a call cancel (close) packet.
   virtual Error WriteCallCancel() = 0;
@@ -29,13 +30,13 @@ class MsgStreamRw {
 // MsgStream implements the stream interface passed to implementations.
 // Matches Go MsgStream struct in msg-stream.go
 class MsgStream : public Stream {
- public:
+public:
   // Constructor matching NewMsgStream in Go
-  MsgStream(MsgStreamRw* rw, std::function<void()> close_cb)
+  MsgStream(MsgStreamRw *rw, std::function<void()> close_cb)
       : rw_(rw), close_cb_(std::move(close_cb)) {}
 
   // MsgSend sends the message to the remote.
-  Error MsgSend(const Message& msg) override {
+  Error MsgSend(const Message &msg) override {
     std::string msg_data;
     if (!msg.SerializeToString(&msg_data)) {
       return Error::InvalidMessage;
@@ -44,7 +45,7 @@ class MsgStream : public Stream {
   }
 
   // MsgRecv receives an incoming message from the remote.
-  Error MsgRecv(Message* msg) override {
+  Error MsgRecv(Message *msg) override {
     std::string data;
     Error err = rw_->ReadOne(&data);
     if (err != Error::OK) {
@@ -70,15 +71,16 @@ class MsgStream : public Stream {
     return err;
   }
 
- private:
-  MsgStreamRw* rw_;
+private:
+  MsgStreamRw *rw_;
   std::function<void()> close_cb_;
 };
 
 // NewMsgStream constructs a new Stream with a MsgStreamRw.
 // Matches Go NewMsgStream function in msg-stream.go
-inline std::unique_ptr<MsgStream> NewMsgStream(MsgStreamRw* rw, std::function<void()> close_cb) {
+inline std::unique_ptr<MsgStream> NewMsgStream(MsgStreamRw *rw,
+                                               std::function<void()> close_cb) {
   return std::make_unique<MsgStream>(rw, std::move(close_cb));
 }
 
-}  // namespace starpc
+} // namespace starpc

package/srpc/mux.cpp

@@ -1,14 +1,15 @@
-//go:build deps_only
+// go:build deps_only
 
 #include "mux.hpp"
+#include <mutex>
 
 namespace starpc {
 
-Mux::Mux(std::vector<Invoker*> fallback_invokers)
+Mux::Mux(std::vector<Invoker *> fallback_invokers)
     : fallback_(std::move(fallback_invokers)) {}
 
-Error Mux::Register(Handler* handler) {
-  const std::string& service_id = handler->GetServiceID();
+Error Mux::Register(Handler *handler) {
+  const std::string &service_id = handler->GetServiceID();
   auto method_ids = handler->GetMethodIDs();
 
   if (service_id.empty()) {
@@ -17,8 +18,8 @@ Error Mux::Register(Handler* handler) {
 
   std::unique_lock<std::shared_mutex> lock(mtx_);
 
-  auto& service_methods = services_[service_id];
-  for (const auto& method_id : method_ids) {
+  auto &service_methods = services_[service_id];
+  for (const auto &method_id : method_ids) {
     if (!method_id.empty()) {
       service_methods[method_id] = handler;
     }
@@ -27,7 +28,7 @@ Error Mux::Register(Handler* handler) {
   return Error::OK;
 }
 
-bool Mux::HasService(const std::string& service_id) const {
+bool Mux::HasService(const std::string &service_id) const {
   if (service_id.empty()) {
     return false;
   }
@@ -37,7 +38,8 @@ bool Mux::HasService(const std::string& service_id) const {
   return it != services_.end() && !it->second.empty();
 }
 
-bool Mux::HasServiceMethod(const std::string& service_id, const std::string& method_id) const {
+bool Mux::HasServiceMethod(const std::string &service_id,
+                           const std::string &method_id) const {
   if (service_id.empty() || method_id.empty()) {
     return false;
   }
@@ -48,8 +50,8 @@ bool Mux::HasServiceMethod(const std::string& service_id, const std::string& met
     return false;
   }
 
-  for (const auto& [mid, handler] : svc_it->second) {
-    for (const auto& handler_method : handler->GetMethodIDs()) {
+  for (const auto &[mid, handler] : svc_it->second) {
+    for (const auto &handler_method : handler->GetMethodIDs()) {
       if (handler_method == method_id) {
         return true;
       }
@@ -59,18 +61,17 @@ bool Mux::HasServiceMethod(const std::string& service_id, const std::string& met
   return false;
 }
 
-std::pair<bool, Error> Mux::InvokeMethod(
-    const std::string& service_id,
-    const std::string& method_id,
-    Stream* strm) {
-  Handler* handler = nullptr;
+std::pair<bool, Error> Mux::InvokeMethod(const std::string &service_id,
+                                         const std::string &method_id,
+                                         Stream *strm) {
+  Handler *handler = nullptr;
 
   {
     std::shared_lock<std::shared_mutex> lock(mtx_);
 
     if (service_id.empty()) {
       // If service string is empty, search all services
-      for (const auto& [svc_id, svc_methods] : services_) {
+      for (const auto &[svc_id, svc_methods] : services_) {
         auto it = svc_methods.find(method_id);
         if (it != svc_methods.end()) {
           handler = it->second;
@@ -93,7 +94,7 @@ std::pair<bool, Error> Mux::InvokeMethod(
   }
 
   // Try fallback invokers
-  for (auto* invoker : fallback_) {
+  for (auto *invoker : fallback_) {
     if (invoker != nullptr) {
       auto [handled, err] = invoker->InvokeMethod(service_id, method_id, strm);
       if (err != Error::OK || handled) {
@@ -105,4 +106,4 @@ std::pair<bool, Error> Mux::InvokeMethod(
   return {false, Error::OK};
 }
 
-}  // namespace starpc
+} // namespace starpc

package/srpc/mux.hpp

@@ -14,38 +14,38 @@ namespace starpc {
 // Mux contains a set of <service, method> handlers.
 // Matches Go Mux interface in mux.go
 class Mux : public Invoker, public QueryableInvoker {
- public:
+public:
   // Constructor matching NewMux in Go
-  explicit Mux(std::vector<Invoker*> fallback_invokers = {});
+  explicit Mux(std::vector<Invoker *> fallback_invokers = {});
   ~Mux() override = default;
 
   // Register registers a new RPC method handler (service).
   // Matches Go Register in mux.go
-  Error Register(Handler* handler);
+  Error Register(Handler *handler);
 
   // 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.
   // Matches Go InvokeMethod in mux.go
-  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;
 
   // HasService checks if the service ID exists in the handlers.
   // Matches Go HasService in mux.go
-  bool HasService(const std::string& service_id) const override;
+  bool HasService(const std::string &service_id) const override;
 
   // HasServiceMethod checks if <service-id, method-id> exists in the handlers.
   // Matches Go HasServiceMethod in mux.go
-  bool HasServiceMethod(const std::string& service_id, const std::string& method_id) const override;
+  bool HasServiceMethod(const std::string &service_id,
+                        const std::string &method_id) const override;
 
- private:
+private:
   // Mapping from method id to handler
-  using MuxMethods = std::unordered_map<std::string, Handler*>;
+  using MuxMethods = std::unordered_map<std::string, Handler *>;
 
   // Fallback invokers
-  std::vector<Invoker*> fallback_;
+  std::vector<Invoker *> fallback_;
 
   // Read-write mutex guards services_
   mutable std::shared_mutex mtx_;
@@ -56,8 +56,9 @@ class Mux : public Invoker, public QueryableInvoker {
 
 // NewMux constructs a new Mux.
 // Matches Go NewMux function in mux.go
-inline std::unique_ptr<Mux> NewMux(std::vector<Invoker*> fallback_invokers = {}) {
+inline std::unique_ptr<Mux>
+NewMux(std::vector<Invoker *> fallback_invokers = {}) {
   return std::make_unique<Mux>(std::move(fallback_invokers));
 }
 
-}  // namespace starpc
+} // namespace starpc

package/srpc/packet.cpp

@@ -1,4 +1,4 @@
-//go:build deps_only
+// go:build deps_only
 
 #include "packet.hpp"
 
@@ -7,7 +7,7 @@
 namespace starpc {
 
 PacketDataHandler NewPacketDataHandler(PacketHandler handler) {
-  return [handler](const std::string& data) -> Error {
+  return [handler](const std::string &data) -> Error {
     srpc::Packet pkt;
     if (!pkt.ParseFromString(data)) {
       return Error::InvalidMessage;
@@ -16,20 +16,20 @@ PacketDataHandler NewPacketDataHandler(PacketHandler handler) {
   };
 }
 
-Error ValidatePacket(const srpc::Packet& pkt) {
+Error ValidatePacket(const srpc::Packet &pkt) {
   switch (pkt.body_case()) {
-    case srpc::Packet::kCallStart:
-      return ValidateCallStart(pkt.call_start());
-    case srpc::Packet::kCallData:
-      return ValidateCallData(pkt.call_data());
-    case srpc::Packet::kCallCancel:
-      return Error::OK;
-    default:
-      return Error::UnrecognizedPacket;
+  case srpc::Packet::kCallStart:
+    return ValidateCallStart(pkt.call_start());
+  case srpc::Packet::kCallData:
+    return ValidateCallData(pkt.call_data());
+  case srpc::Packet::kCallCancel:
+    return Error::OK;
+  default:
+    return Error::UnrecognizedPacket;
   }
 }
 
-Error ValidateCallStart(const srpc::CallStart& pkt) {
+Error ValidateCallStart(const srpc::CallStart &pkt) {
   if (pkt.rpc_method().empty()) {
     return Error::EmptyMethodID;
   }
@@ -39,20 +39,20 @@ Error ValidateCallStart(const srpc::CallStart& pkt) {
   return Error::OK;
 }
 
-Error ValidateCallData(const srpc::CallData& pkt) {
-  if (pkt.data().empty() && !pkt.complete() && pkt.error().empty() && !pkt.data_is_zero()) {
+Error ValidateCallData(const srpc::CallData &pkt) {
+  if (pkt.data().empty() && !pkt.complete() && pkt.error().empty() &&
+      !pkt.data_is_zero()) {
     return Error::EmptyPacket;
   }
   return Error::OK;
 }
 
-std::unique_ptr<srpc::Packet> NewCallStartPacket(
-    const std::string& service,
-    const std::string& method,
-    const std::string& data,
-    bool data_is_zero) {
+std::unique_ptr<srpc::Packet> NewCallStartPacket(const std::string &service,
+                                                 const std::string &method,
+                                                 const std::string &data,
+                                                 bool data_is_zero) {
   auto pkt = std::make_unique<srpc::Packet>();
-  auto* call_start = pkt->mutable_call_start();
+  auto *call_start = pkt->mutable_call_start();
   call_start->set_rpc_service(service);
   call_start->set_rpc_method(method);
   call_start->set_data(data);
@@ -60,13 +60,11 @@ std::unique_ptr<srpc::Packet> NewCallStartPacket(
   return pkt;
 }
 
-std::unique_ptr<srpc::Packet> NewCallDataPacket(
-    const std::string& data,
-    bool data_is_zero,
-    bool complete,
-    Error err) {
+std::unique_ptr<srpc::Packet> NewCallDataPacket(const std::string &data,
+                                                bool data_is_zero,
+                                                bool complete, Error err) {
   auto pkt = std::make_unique<srpc::Packet>();
-  auto* call_data = pkt->mutable_call_data();
+  auto *call_data = pkt->mutable_call_data();
   call_data->set_data(data);
   call_data->set_data_is_zero(data_is_zero);
   call_data->set_complete(err != Error::OK || complete);
@@ -82,4 +80,4 @@ std::unique_ptr<srpc::Packet> NewCallCancelPacket() {
   return pkt;
 }
 
-}  // namespace starpc
+} // namespace starpc

package/srpc/packet.hpp

@@ -11,7 +11,7 @@ namespace srpc {
 class Packet;
 class CallStart;
 class CallData;
-}  // namespace srpc
+} // namespace srpc
 
 namespace starpc {
 
@@ -21,39 +21,36 @@ using CloseHandler = std::function<void(Error close_err)>;
 
 // PacketHandler handles a packet.
 // Matches Go PacketHandler in packet.go
-using PacketHandler = std::function<Error(const srpc::Packet& pkt)>;
+using PacketHandler = std::function<Error(const srpc::Packet &pkt)>;
 
 // PacketDataHandler handles a packet before it is parsed.
 // Matches Go PacketDataHandler in packet.go
-using PacketDataHandler = std::function<Error(const std::string& data)>;
+using PacketDataHandler = std::function<Error(const std::string &data)>;
 
 // NewPacketDataHandler wraps a PacketHandler with a decoding step.
 PacketDataHandler NewPacketDataHandler(PacketHandler handler);
 
 // Validate performs cursory validation of a Packet.
-Error ValidatePacket(const srpc::Packet& pkt);
+Error ValidatePacket(const srpc::Packet &pkt);
 
 // Validate performs cursory validation of a CallStart.
-Error ValidateCallStart(const srpc::CallStart& pkt);
+Error ValidateCallStart(const srpc::CallStart &pkt);
 
 // Validate performs cursory validation of a CallData.
-Error ValidateCallData(const srpc::CallData& pkt);
+Error ValidateCallData(const srpc::CallData &pkt);
 
 // NewCallStartPacket constructs a new CallStart packet.
-std::unique_ptr<srpc::Packet> NewCallStartPacket(
-    const std::string& service,
-    const std::string& method,
-    const std::string& data,
-    bool data_is_zero);
+std::unique_ptr<srpc::Packet> NewCallStartPacket(const std::string &service,
+                                                 const std::string &method,
+                                                 const std::string &data,
+                                                 bool data_is_zero);
 
 // NewCallDataPacket constructs a new CallData packet.
-std::unique_ptr<srpc::Packet> NewCallDataPacket(
-    const std::string& data,
-    bool data_is_zero,
-    bool complete,
-    Error err);
+std::unique_ptr<srpc::Packet> NewCallDataPacket(const std::string &data,
+                                                bool data_is_zero,
+                                                bool complete, Error err);
 
 // NewCallCancelPacket constructs a new CallCancel packet with cancel.
 std::unique_ptr<srpc::Packet> NewCallCancelPacket();
 
-}  // namespace starpc
+} // namespace starpc