Merge branch 'main' into update_coro_http

include/ylt/coro_rpc/impl/context.hpp

@@ -83,7 +83,7 @@ class context_base {
         error_code, error_msg, self_->req_head_, self_->is_delay_);
   }
   void response_error(coro_rpc::err_code error_code) {
-    response_error(error_code, make_error_message(error_code));
+    response_error(error_code, error_code.message());
   }
   /*!
    * Send response message

include/ylt/coro_rpc/impl/coro_rpc_client.hpp

@@ -744,12 +744,12 @@ class coro_rpc_client {
                                                           uint8_t rpc_errc,
                                                           bool &error_happen) {
     rpc_return_type_t<T> ret;
-    struct_pack::errc ec;
+    struct_pack::err_code ec;
     coro_rpc_protocol::rpc_error err;
     if (rpc_errc == 0)
       AS_LIKELY {
         ec = struct_pack::deserialize_to(ret, buffer);
-        if (ec == struct_pack::errc::ok) {
+        if SP_LIKELY (!ec) {
           if constexpr (std::is_same_v<T, void>) {
             return {};
           }
@@ -759,17 +759,17 @@ class coro_rpc_client {
         }
       }
     else {
-      err.code = rpc_errc;
+      err.val() = rpc_errc;
       if (rpc_errc != UINT8_MAX) {
         ec = struct_pack::deserialize_to(err.msg, buffer);
-        if (ec == struct_pack::errc::ok) {
+        if SP_LIKELY (!ec) {
           error_happen = true;
           return rpc_result<T, coro_rpc_protocol>{unexpect_t{}, std::move(err)};
         }
       }
       else {
         ec = struct_pack::deserialize_to(err, buffer);
-        if (ec == struct_pack::errc::ok) {
+        if SP_LIKELY (!ec) {
           return rpc_result<T, coro_rpc_protocol>{unexpect_t{}, std::move(err)};
         }
       }

include/ylt/coro_rpc/impl/errno.h

@@ -33,30 +33,7 @@ enum class errc : uint16_t {
   message_too_large,
   server_has_ran,
 };
-struct err_code {
- public:
-  errc ec;
-  err_code() : ec(errc::ok) {}
-  explicit err_code(uint16_t ec) : ec{ec} {};
-  err_code(errc ec) : ec(ec){};
-  err_code& operator=(errc ec) {
-    this->ec = ec;
-    return *this;
-  }
-  err_code& operator=(uint16_t ec) {
-    this->ec = errc{ec};
-    return *this;
-  }
-  err_code(const err_code& err_code) = default;
-  err_code& operator=(const err_code& o) = default;
-  bool operator!() const { return ec == errc::ok; }
-  operator errc() const { return ec; }
-  operator bool() const { return static_cast<uint16_t>(ec); }
-  explicit operator uint16_t() const { return static_cast<uint16_t>(ec); }
-  uint16_t val() const { return static_cast<uint16_t>(ec); }
-};
-inline bool operator!(errc ec) { return ec == errc::ok; }
-inline std::string_view make_error_message(errc ec) {
+inline constexpr std::string_view make_error_message(errc ec) noexcept {
   switch (ec) {
     case errc::ok:
       return "ok";
@@ -86,4 +63,30 @@ inline std::string_view make_error_message(errc ec) {
       return "unknown_user-defined_error";
   }
 }
+struct err_code {
+ public:
+  errc ec;
+  constexpr err_code() noexcept : ec(errc::ok) {}
+  explicit constexpr err_code(uint16_t ec) noexcept : ec{ec} {};
+  constexpr err_code(errc ec) noexcept : ec(ec){};
+  constexpr err_code& operator=(errc ec) noexcept {
+    this->ec = ec;
+    return *this;
+  }
+  constexpr err_code(const err_code& err_code) noexcept = default;
+  constexpr err_code& operator=(const err_code& o) noexcept = default;
+  constexpr operator errc() const noexcept { return ec; }
+  constexpr operator bool() const noexcept { return static_cast<uint16_t>(ec); }
+  constexpr explicit operator uint16_t() const noexcept {
+    return static_cast<uint16_t>(ec);
+  }
+  constexpr uint16_t val() const noexcept { return static_cast<uint16_t>(ec); }
+  constexpr std::string_view message() const noexcept {
+    return make_error_message(ec);
+  }
+};
+
+inline bool operator!(err_code ec) noexcept { return ec == errc::ok; }
+inline bool operator!(errc ec) noexcept { return ec == errc::ok; }
+
 };  // namespace coro_rpc

include/ylt/coro_rpc/impl/protocol/struct_pack_protocol.hpp

@@ -20,15 +20,12 @@ namespace coro_rpc::protocol {
 struct struct_pack_protocol {
   template <typename T>
   static bool deserialize_to(T& t, std::string_view buffer) {
-    struct_pack::errc ok{};
     if constexpr (std::tuple_size_v<T> == 1) {
-      ok = struct_pack::deserialize_to(std::get<0>(t), buffer);
+      return !struct_pack::deserialize_to(std::get<0>(t), buffer);
     }
     else {
-      ok = struct_pack::deserialize_to(t, buffer);
+      return !struct_pack::deserialize_to(t, buffer);
     }
-
-    return ok == struct_pack::errc::ok;
   }
   template <typename T>
   static std::string serialize(const T& t) {