couchbase 3.5.1 → 3.5.2

data/ext/couchbase/core/platform/string_hex.cc

@@ -26,76 +26,78 @@
 static inline std::uint8_t
 from_hex_digit(char c)
 {
-    if ('0' <= c && c <= '9') {
-        return static_cast<std::uint8_t>(c - '0');
-    }
-    if ('A' <= c && c <= 'F') {
-        return static_cast<std::uint8_t>(c + 10 - 'A');
-    }
-    if ('a' <= c && c <= 'f') {
-        return static_cast<std::uint8_t>(c + 10 - 'a');
-    }
-    throw std::invalid_argument("couchbase::core::from_hex_digit: character was not in hexadecimal range");
+  if ('0' <= c && c <= '9') {
+    return static_cast<std::uint8_t>(c - '0');
+  }
+  if ('A' <= c && c <= 'F') {
+    return static_cast<std::uint8_t>(c + 10 - 'A');
+  }
+  if ('a' <= c && c <= 'f') {
+    return static_cast<std::uint8_t>(c + 10 - 'a');
+  }
+  throw std::invalid_argument(
+    "couchbase::core::from_hex_digit: character was not in hexadecimal range");
 }
 
 std::uint64_t
 couchbase::core::from_hex(std::string_view buffer)
 {
-    std::uint64_t ret = 0;
-    if (buffer.size() > 16) {
-        throw std::overflow_error("couchbase::core::from_hex: input string too long: " + std::to_string(buffer.size()));
-    }
+  std::uint64_t ret = 0;
+  if (buffer.size() > 16) {
+    throw std::overflow_error("couchbase::core::from_hex: input string too long: " +
+                              std::to_string(buffer.size()));
+  }
 
-    for (char digit : buffer) {
-        ret = (ret << 4) | from_hex_digit(digit);
-    }
+  for (char digit : buffer) {
+    ret = (ret << 4) | from_hex_digit(digit);
+  }
 
-    return ret;
+  return ret;
 }
 
 std::string
 couchbase::core::to_hex(std::uint8_t val)
 {
-    char buf[32];
-    snprintf(buf, sizeof(buf), "0x%02" PRIx8, val);
-    return std::string{ buf };
+  char buf[32];
+  snprintf(buf, sizeof(buf), "0x%02" PRIx8, val);
+  return std::string{ buf };
 }
 
 std::string
 couchbase::core::to_hex(std::uint16_t val)
 {
-    char buf[32];
-    snprintf(buf, sizeof(buf), "0x%04" PRIx16, val);
-    return std::string{ buf };
+  char buf[32];
+  snprintf(buf, sizeof(buf), "0x%04" PRIx16, val);
+  return std::string{ buf };
 }
 
 std::string
 couchbase::core::to_hex(std::uint32_t val)
 {
-    char buf[32];
-    snprintf(buf, sizeof(buf), "0x%08" PRIx32, val);
-    return std::string{ buf };
+  char buf[32];
+  snprintf(buf, sizeof(buf), "0x%08" PRIx32, val);
+  return std::string{ buf };
 }
 
 std::string
 couchbase::core::to_hex(std::uint64_t val)
 {
-    char buf[32];
-    snprintf(buf, sizeof(buf), "0x%016" PRIx64, val);
-    return std::string{ buf };
+  char buf[32];
+  snprintf(buf, sizeof(buf), "0x%016" PRIx64, val);
+  return std::string{ buf };
 }
 
 std::string
 couchbase::core::to_hex(std::string_view buffer)
 {
-    if (buffer.empty()) {
-        return "";
-    }
-    std::stringstream ss;
-    for (const auto& c : buffer) {
-        ss << "0x" << std::hex << std::setfill('0') << std::setw(2) << std::uint32_t(c) << " ";
-    }
-    auto ret = ss.str();
-    ret.resize(ret.size() - 1);
-    return ret;
+  if (buffer.empty()) {
+    return "";
+  }
+  std::stringstream ss;
+  for (const auto& c : buffer) {
+    ss << "0x" << std::hex << std::setfill('0') << std::setw(2) << std::uint32_t(c) << " ";
+  }
+  auto ret = ss.str();
+  ret.resize(ret.size() - 1);
+  return ret;
 }

data/ext/couchbase/core/platform/terminate_handler.cc

@@ -35,24 +35,24 @@ static void
 log_handled_exception()
 {
 #ifdef WIN32
-    // Windows doesn't like us re-throwing the exception in the handler (and
-    // seems to result in immediate process termination). As such skip logging
-    // the exception here.
-    return;
+  // Windows doesn't like us re-throwing the exception in the handler (and
+  // seems to result in immediate process termination). As such skip logging
+  // the exception here.
+  return;
 #else
-    // Attempt to get the exception's what() message.
-    try {
-        static int tried_throw = 0;
-        // try once to re-throw currently active exception (so we can print
-        // its what() message).
-        if (tried_throw++ == 0) {
-            throw;
-        }
-    } catch (const std::exception& e) {
-        CB_LOG_CRITICAL("Caught unhandled std::exception-derived exception. what(): {}", e.what());
-    } catch (...) {
-        CB_LOG_CRITICAL_RAW("Caught unknown/unhandled exception.");
+  // Attempt to get the exception's what() message.
+  try {
+    static int tried_throw = 0;
+    // try once to re-throw currently active exception (so we can print
+    // its what() message).
+    if (tried_throw++ == 0) {
+      throw;
     }
+  } catch (const std::exception& e) {
+    CB_LOG_CRITICAL("Caught unhandled std::exception-derived exception. what(): {}", e.what());
+  } catch (...) {
+    CB_LOG_CRITICAL_RAW("Caught unknown/unhandled exception.");
+  }
 #endif
 }
 
@@ -60,19 +60,19 @@ log_handled_exception()
 static void
 log_backtrace()
 {
-    static const char format_str[] = "Call stack:\n%s";
+  static const char format_str[] = "Call stack:\n%s";
 
-    char buffer[8192];
-    if (print_backtrace_to_buffer("    ", buffer, sizeof(buffer))) {
-        CB_LOG_CRITICAL("Call stack:\n{}", buffer);
-    } else {
-        // Exceeded buffer space - print directly to stderr FD (requires no
-        // buffering, but has the disadvantage that we don't get it in the log).
-        fprintf(stderr, format_str, "");
-        print_backtrace_to_file(stderr);
-        fflush(stderr);
-        CB_LOG_CRITICAL_RAW("Call stack exceeds 8k, rendered to STDERR");
-    }
+  char buffer[8192];
+  if (print_backtrace_to_buffer("    ", buffer, sizeof(buffer))) {
+    CB_LOG_CRITICAL("Call stack:\n{}", buffer);
+  } else {
+    // Exceeded buffer space - print directly to stderr FD (requires no
+    // buffering, but has the disadvantage that we don't get it in the log).
+    fprintf(stderr, format_str, "");
+    print_backtrace_to_file(stderr);
+    fflush(stderr);
+    CB_LOG_CRITICAL_RAW("Call stack exceeds 8k, rendered to STDERR");
+  }
 }
 
 // Replacement terminate_handler which prints the exception's what() and a
@@ -80,46 +80,48 @@ log_backtrace()
 static void
 backtrace_terminate_handler()
 {
-    static bool meta_reported = false;
-    if (!meta_reported) {
-        CB_LOG_CRITICAL(R"(*** Fatal error encountered during exception handling ({}) ***)", meta::sdk_build_info_short());
-        meta_reported = true;
-    }
-    log_handled_exception();
+  static bool meta_reported = false;
+  if (!meta_reported) {
+    CB_LOG_CRITICAL(R"(*** Fatal error encountered during exception handling ({}) ***)",
+                    meta::sdk_build_info_short());
+    meta_reported = true;
+  }
+  log_handled_exception();
 
-    if (should_include_backtrace) {
-        log_backtrace();
-    }
+  if (should_include_backtrace) {
+    log_backtrace();
+  }
 
-    // Chain to the default handler if available (as it may be able to print
-    // other useful information on why we were told to terminate).
-    if (default_terminate_handler != nullptr && default_terminate_handler != backtrace_terminate_handler) {
-        default_terminate_handler();
-    }
+  // Chain to the default handler if available (as it may be able to print
+  // other useful information on why we were told to terminate).
+  if (default_terminate_handler != nullptr &&
+      default_terminate_handler != backtrace_terminate_handler) {
+    default_terminate_handler();
+  }
 
 #if !defined(HAVE_BREAKPAD)
-    // Shut down the logger (and flush everything). If breakpad is installed
-    // then we'll let it do it.
-    logger::shutdown();
+  // Shut down the logger (and flush everything). If breakpad is installed
+  // then we'll let it do it.
+  logger::shutdown();
 #endif
 
-    std::abort();
+  std::abort();
 }
 
 void
 install_backtrace_terminate_handler()
 {
-    if (default_terminate_handler != nullptr) {
-        // restore the previously saved one before (re)installing ours.
-        std::set_terminate(default_terminate_handler);
-    }
-    default_terminate_handler = std::set_terminate(backtrace_terminate_handler);
+  if (default_terminate_handler != nullptr) {
+    // restore the previously saved one before (re)installing ours.
+    std::set_terminate(default_terminate_handler);
+  }
+  default_terminate_handler = std::set_terminate(backtrace_terminate_handler);
 }
 
 void
 set_terminate_handler_print_backtrace(bool print)
 {
-    should_include_backtrace = print;
+  should_include_backtrace = print;
 }
 
 } // namespace couchbase::core::platform

data/ext/couchbase/core/platform/uuid.cc

@@ -25,78 +25,78 @@
 void
 couchbase::core::uuid::random(couchbase::core::uuid::uuid_t& uuid)
 {
-    static thread_local std::mt19937_64 gen{ std::random_device()() };
-    std::uniform_int_distribution<std::uint64_t> dis;
+  static thread_local std::mt19937_64 gen{ std::random_device()() };
+  std::uniform_int_distribution<std::uint64_t> dis;
 
-    // The uuid is 16 bytes, which is the same as two 64-bit integers
-    auto* ptr = reinterpret_cast<std::uint64_t*>(uuid.data());
-    ptr[0] = dis(gen);
-    ptr[1] = dis(gen);
+  // The uuid is 16 bytes, which is the same as two 64-bit integers
+  auto* ptr = reinterpret_cast<std::uint64_t*>(uuid.data());
+  ptr[0] = dis(gen);
+  ptr[1] = dis(gen);
 
-    // Make sure that it looks like a version 4
-    uuid[6] &= 0x0f;
-    uuid[6] |= 0x40;
+  // Make sure that it looks like a version 4
+  uuid[6] &= 0x0f;
+  uuid[6] |= 0x40;
 }
 
 couchbase::core::uuid::uuid_t
 couchbase::core::uuid::random()
 {
-    uuid_t ret;
-    random(ret);
-    return ret;
+  uuid_t ret;
+  random(ret);
+  return ret;
 }
 
 couchbase::core::uuid::uuid_t
 couchbase::core::uuid::from_string(std::string_view str)
 {
-    uuid_t ret;
-    if (str.size() != 36) {
-        throw std::invalid_argument("couchbase::core::uuid::from_string: string was wrong size got: " + std::to_string(str.size()) +
-                                    " (expected: 36)");
-    }
+  uuid_t ret;
+  if (str.size() != 36) {
+    throw std::invalid_argument("couchbase::core::uuid::from_string: string was wrong size got: " +
+                                std::to_string(str.size()) + " (expected: 36)");
+  }
 
-    std::size_t jj = 0;
-    for (std::size_t ii = 0; ii < 36; ii += 2) {
-        switch (ii) {
-            case 8:
-            case 13:
-            case 18:
-            case 23:
-                if (str[ii] != '-') {
-                    throw std::invalid_argument("couchbase::core::uuid::from_string: hyphen not found where "
-                                                "expected");
-                }
-                ++ii; // fall-through
-            default:
-                ret[jj++] = std::uint8_t(from_hex({ str.data() + ii, 2 }));
+  std::size_t jj = 0;
+  for (std::size_t ii = 0; ii < 36; ii += 2) {
+    switch (ii) {
+      case 8:
+      case 13:
+      case 18:
+      case 23:
+        if (str[ii] != '-') {
+          throw std::invalid_argument("couchbase::core::uuid::from_string: hyphen not found where "
+                                      "expected");
         }
+        ++ii; // fall-through
+      default:
+        ret[jj++] = std::uint8_t(from_hex({ str.data() + ii, 2 }));
     }
-    return ret;
+  }
+  return ret;
 }
 
 inline char
 to_char(std::uint8_t c)
 {
-    if (c <= 9) {
-        return static_cast<char>('0' + c);
-    }
-    return static_cast<char>('a' + (c - 10));
+  if (c <= 9) {
+    return static_cast<char>('0' + c);
+  }
+  return static_cast<char>('a' + (c - 10));
 }
 
 std::string
 couchbase::core::uuid::to_string(const couchbase::core::uuid::uuid_t& uuid)
 {
-    std::string ret(36, '-');
-    std::size_t i = 0;
+  std::string ret(36, '-');
+  std::size_t i = 0;
 
-    for (const auto& byte : uuid) {
-        ret[i] = to_char(static_cast<std::uint8_t>(byte >> 4U) & 0x0fU);
-        ++i;
-        ret[i] = to_char(byte & 0x0fU);
-        ++i;
-        if (i == 6 || i == 11 || i == 16 || i == 21) {
-            ++i;
-        }
+  for (const auto& byte : uuid) {
+    ret[i] = to_char(static_cast<std::uint8_t>(byte >> 4U) & 0x0fU);
+    ++i;
+    ret[i] = to_char(byte & 0x0fU);
+    ++i;
+    if (i == 6 || i == 11 || i == 16 || i == 21) {
+      ++i;
     }
-    return ret;
+  }
+  return ret;
 }