couchbase 4.3.1 → 4.4.1-dev.1

package/deps/couchbase-cxx-client/core/transactions/durability_level.hxx

@@ -21,71 +21,71 @@
 
 namespace couchbase::core::transactions
 {
-constexpr std::string_view
-durability_level_to_string(durability_level level)
+constexpr auto
+durability_level_to_string(durability_level level) -> std::string_view
 {
-    switch (level) {
-        case durability_level::none:
-            return "NONE";
-        case durability_level::majority:
-            return "MAJORITY";
-        case durability_level::majority_and_persist_to_active:
-            return "MAJORITY_AND_PERSIST_TO_ACTIVE";
-        case durability_level::persist_to_majority:
-            return "PERSIST_TO_MAJORITY";
-    }
-    return "MAJORITY";
+  switch (level) {
+    case durability_level::none:
+      return "NONE";
+    case durability_level::majority:
+      return "MAJORITY";
+    case durability_level::majority_and_persist_to_active:
+      return "MAJORITY_AND_PERSIST_TO_ACTIVE";
+    case durability_level::persist_to_majority:
+      return "PERSIST_TO_MAJORITY";
+  }
+  return "MAJORITY";
 }
 
-constexpr std::string_view
-durability_level_to_string_for_query(durability_level level)
+constexpr auto
+durability_level_to_string_for_query(durability_level level) -> std::string_view
 {
-    switch (level) {
-        case durability_level::none:
-            return "none";
-        case durability_level::majority:
-            return "majority";
-        case durability_level::majority_and_persist_to_active:
-            return "majorityAndPersistActive";
-        case durability_level::persist_to_majority:
-            return "persistToMajority";
-    }
-    return "majority";
+  switch (level) {
+    case durability_level::none:
+      return "none";
+    case durability_level::majority:
+      return "majority";
+    case durability_level::majority_and_persist_to_active:
+      return "majorityAndPersistActive";
+    case durability_level::persist_to_majority:
+      return "persistToMajority";
+  }
+  return "majority";
 }
 
-constexpr std::string_view
-store_durability_level_to_string(durability_level level)
+constexpr auto
+store_durability_level_to_string(durability_level level) -> std::string_view
 {
-    switch (level) {
-        case durability_level::none:
-            return "n";
-        case durability_level::majority:
-            return "m";
-        case durability_level::majority_and_persist_to_active:
-            return "pa";
-        case durability_level::persist_to_majority:
-            return "pm";
-        default:
-            return "m";
-    }
+  switch (level) {
+    case durability_level::none:
+      return "n";
+    case durability_level::majority:
+      return "m";
+    case durability_level::majority_and_persist_to_active:
+      return "pa";
+    case durability_level::persist_to_majority:
+      return "pm";
+    default:
+      return "m";
+  }
 }
 
 constexpr durability_level
 store_string_to_durability_level(std::string_view input)
 {
-    if (input == "m") {
-        return durability_level::majority;
-    }
-    if (input == "pa") {
-        return durability_level::majority_and_persist_to_active;
-    }
-    if (input == "pm") {
-        return durability_level::persist_to_majority;
-    }
-    if (input == "n") {
-        return durability_level::none;
-    }
-    // Default to a something sensible if we don't understand the code
+  if (input == "m") {
     return durability_level::majority;
+  }
+  if (input == "pa") {
+    return durability_level::majority_and_persist_to_active;
+  }
+  if (input == "pm") {
+    return durability_level::persist_to_majority;
+  }
+  if (input == "n") {
+    return durability_level::none;
+  }
+  // Default to a something sensible if we don't understand the code
+  return durability_level::majority;
 }
 } // namespace couchbase::core::transactions

package/deps/couchbase-cxx-client/core/transactions/error_class.hxx

@@ -19,17 +19,17 @@
 namespace couchbase::core::transactions
 {
 enum error_class {
-    FAIL_HARD = 0,
-    FAIL_OTHER,
-    FAIL_TRANSIENT,
-    FAIL_AMBIGUOUS,
-    FAIL_DOC_ALREADY_EXISTS,
-    FAIL_DOC_NOT_FOUND,
-    FAIL_PATH_NOT_FOUND,
-    FAIL_CAS_MISMATCH,
-    FAIL_WRITE_WRITE_CONFLICT,
-    FAIL_ATR_FULL,
-    FAIL_PATH_ALREADY_EXISTS,
-    FAIL_EXPIRY
+  FAIL_HARD = 0,
+  FAIL_OTHER,
+  FAIL_TRANSIENT,
+  FAIL_AMBIGUOUS,
+  FAIL_DOC_ALREADY_EXISTS,
+  FAIL_DOC_NOT_FOUND,
+  FAIL_PATH_NOT_FOUND,
+  FAIL_CAS_MISMATCH,
+  FAIL_WRITE_WRITE_CONFLICT,
+  FAIL_ATR_FULL,
+  FAIL_PATH_ALREADY_EXISTS,
+  FAIL_EXPIRY
 };
 } // namespace couchbase::core::transactions

package/deps/couchbase-cxx-client/core/transactions/error_list.hxx

@@ -27,28 +27,28 @@ namespace couchbase::core::transactions
 
 class error_list
 {
-  private:
-    std::list<transaction_operation_failed> list_;
-    std::mutex mutex_;
-    std::atomic<std::size_t> size_{ 0 };
+private:
+  std::list<transaction_operation_failed> list_;
+  std::mutex mutex_;
+  std::atomic<std::size_t> size_{ 0 };
 
-  public:
-    bool empty()
-    {
-        return size_.load() == 0;
-    }
-    void push_back(const transaction_operation_failed& ex)
-    {
-        std::lock_guard<std::mutex> lock(mutex_);
-        list_.push_back(ex);
-        size_ = list_.size();
-    }
-    void do_throw(std::optional<external_exception> cause = {})
-    {
-        assert(size_.load() > 0);
-        // merge the errors, throw a composite
-        std::lock_guard<std::mutex> lock(mutex_);
-        transaction_operation_failed::merge_errors(list_, cause);
-    }
+public:
+  auto empty() -> bool
+  {
+    return size_.load() == 0;
+  }
+  void push_back(const transaction_operation_failed& ex)
+  {
+    std::lock_guard<std::mutex> lock(mutex_);
+    list_.push_back(ex);
+    size_ = list_.size();
+  }
+  void do_throw(std::optional<external_exception> cause = {})
+  {
+    assert(size_.load() > 0);
+    // merge the errors, throw a composite
+    std::lock_guard<std::mutex> lock(mutex_);
+    transaction_operation_failed::merge_errors(list_, cause);
+  }
 };
 } // namespace couchbase::core::transactions

package/deps/couchbase-cxx-client/core/transactions/exceptions.cxx

@@ -20,141 +20,194 @@
 
 namespace couchbase::core::transactions
 {
-external_exception
-external_exception_from_error_class(error_class ec)
+auto
+external_exception_from_error_class(error_class ec) -> external_exception
 {
-    switch (ec) {
-        case FAIL_DOC_NOT_FOUND:
-            return DOCUMENT_NOT_FOUND_EXCEPTION;
-        case FAIL_DOC_ALREADY_EXISTS:
-            return DOCUMENT_EXISTS_EXCEPTION;
-        default:
-            return UNKNOWN;
-    }
+  switch (ec) {
+    case FAIL_DOC_NOT_FOUND:
+      return DOCUMENT_NOT_FOUND_EXCEPTION;
+    case FAIL_DOC_ALREADY_EXISTS:
+      return DOCUMENT_EXISTS_EXCEPTION;
+    default:
+      return UNKNOWN;
+  }
 }
 
-couchbase::core::transactions::error_class
+auto
 error_class_from_external_exception(external_exception e)
+  -> couchbase::core::transactions::error_class
 {
-    switch (e) {
-        case DOCUMENT_NOT_FOUND_EXCEPTION:
-            return FAIL_DOC_NOT_FOUND;
-        case DOCUMENT_EXISTS_EXCEPTION:
-            return FAIL_DOC_ALREADY_EXISTS;
-        default:
-            return FAIL_OTHER;
-    }
+  switch (e) {
+    case DOCUMENT_NOT_FOUND_EXCEPTION:
+      return FAIL_DOC_NOT_FOUND;
+    case DOCUMENT_EXISTS_EXCEPTION:
+      return FAIL_DOC_ALREADY_EXISTS;
+    default:
+      return FAIL_OTHER;
+  }
 }
 
-error_class
-error_class_from_result(const result& res)
+auto
+error_class_from_result(const result& res) -> error_class
 {
-    subdoc_result::status_type subdoc_status = res.subdoc_status();
-    assert(res.ec || (!res.ignore_subdoc_errors && subdoc_status != subdoc_result::status_type::success));
-    if (res.ec || res.ignore_subdoc_errors) {
-        if (res.ec == couchbase::errc::key_value::document_not_found) {
-            return FAIL_DOC_NOT_FOUND;
-        }
-        if (res.ec == couchbase::errc::key_value::document_exists) {
-            return FAIL_DOC_ALREADY_EXISTS;
-        }
-        if (res.ec == couchbase::errc::common::cas_mismatch) {
-            return FAIL_CAS_MISMATCH;
-        }
-        if (res.ec == couchbase::errc::key_value::value_too_large) {
-            return FAIL_ATR_FULL;
-        }
-        if (res.ec == couchbase::errc::common::unambiguous_timeout || res.ec == couchbase::errc::common::temporary_failure ||
-            res.ec == couchbase::errc::key_value::durable_write_in_progress) {
-            return FAIL_TRANSIENT;
-        }
-        if (res.ec == couchbase::errc::key_value::durability_ambiguous || res.ec == couchbase::errc::common::ambiguous_timeout ||
-            res.ec == couchbase::errc::common::request_canceled) {
-            return FAIL_AMBIGUOUS;
-        }
-        if (res.ec == couchbase::errc::key_value::path_not_found) {
-            return FAIL_PATH_NOT_FOUND;
-        }
-        if (res.ec == couchbase::errc::key_value::path_exists) {
-            return FAIL_PATH_ALREADY_EXISTS;
-        }
-        return FAIL_OTHER;
+  subdoc_result::status_type subdoc_status = res.subdoc_status();
+  assert(res.ec ||
+         (!res.ignore_subdoc_errors && subdoc_status != subdoc_result::status_type::success));
+  if (res.ec || res.ignore_subdoc_errors) {
+    if (res.ec == couchbase::errc::key_value::document_not_found) {
+      return FAIL_DOC_NOT_FOUND;
+    }
+    if (res.ec == couchbase::errc::key_value::document_exists) {
+      return FAIL_DOC_ALREADY_EXISTS;
+    }
+    if (res.ec == couchbase::errc::common::cas_mismatch) {
+      return FAIL_CAS_MISMATCH;
+    }
+    if (res.ec == couchbase::errc::key_value::value_too_large) {
+      return FAIL_ATR_FULL;
+    }
+    if (res.ec == couchbase::errc::common::unambiguous_timeout ||
+        res.ec == couchbase::errc::common::temporary_failure ||
+        res.ec == couchbase::errc::key_value::durable_write_in_progress) {
+      return FAIL_TRANSIENT;
+    }
+    if (res.ec == couchbase::errc::key_value::durability_ambiguous ||
+        res.ec == couchbase::errc::common::ambiguous_timeout ||
+        res.ec == couchbase::errc::common::request_canceled) {
+      return FAIL_AMBIGUOUS;
+    }
+    if (res.ec == couchbase::errc::key_value::path_not_found) {
+      return FAIL_PATH_NOT_FOUND;
+    }
+    if (res.ec == couchbase::errc::key_value::path_exists) {
+      return FAIL_PATH_ALREADY_EXISTS;
+    }
+    return FAIL_OTHER;
+  } else {
+    // TODO this section is likely redundant from TXNCXX-230, but leaving it here to be compatible
+    // with older C++ clients.  It can be removed later.
+    if (subdoc_status == subdoc_result::status_type::subdoc_path_not_found) {
+      return FAIL_PATH_NOT_FOUND;
+    } else if (subdoc_status == subdoc_result::status_type::subdoc_path_exists) {
+      return FAIL_PATH_ALREADY_EXISTS;
     } else {
-        // TODO this section is likely redundant from TXNCXX-230, but leaving it here to be compatible with older
-        // C++ clients.  It can be removed later.
-        if (subdoc_status == subdoc_result::status_type::subdoc_path_not_found) {
-            return FAIL_PATH_NOT_FOUND;
-        } else if (subdoc_status == subdoc_result::status_type::subdoc_path_exists) {
-            return FAIL_PATH_ALREADY_EXISTS;
-        } else {
-            return FAIL_OTHER;
-        }
+      return FAIL_OTHER;
     }
+  }
 }
 
-transaction_exception::transaction_exception(const std::runtime_error& cause, const transaction_context& context, failure_type type)
+transaction_exception::transaction_exception(const std::runtime_error& cause,
+                                             const transaction_context& context,
+                                             failure_type type)
   : std::runtime_error(cause)
   , result_(context.get_transaction_result())
   , cause_(UNKNOWN)
   , type_(type)
   , txn_id_(context.transaction_id())
 {
-    auto txn_op = dynamic_cast<const transaction_operation_failed*>(&cause);
-    if (nullptr != txn_op) {
-        cause_ = txn_op->cause();
-    }
+  auto txn_op = dynamic_cast<const transaction_operation_failed*>(&cause);
+  if (nullptr != txn_op) {
+    cause_ = txn_op->cause();
+  }
 }
 
-errc::transaction_op
-transaction_op_errc_from_external_exception(external_exception e)
+auto
+transaction_op_errc_from_external_exception(external_exception e) -> errc::transaction_op
 {
-    switch (e) {
-        case external_exception::UNKNOWN:
-            return errc::transaction_op::unknown;
-        case external_exception::ACTIVE_TRANSACTION_RECORD_ENTRY_NOT_FOUND:
-            return errc::transaction_op::active_transaction_record_entry_not_found;
-        case external_exception::ACTIVE_TRANSACTION_RECORD_FULL:
-            return errc::transaction_op::active_transaction_record_full;
-        case external_exception::COMMIT_NOT_PERMITTED:
-            return errc::transaction_op::commit_not_permitted;
-        case external_exception::ACTIVE_TRANSACTION_RECORD_NOT_FOUND:
-            return errc::transaction_op::active_transaction_record_not_found;
-        case external_exception::CONCURRENT_OPERATIONS_DETECTED_ON_SAME_DOCUMENT:
-            return errc::transaction_op::concurrent_operations_detected_on_same_document;
-        case external_exception::COUCHBASE_EXCEPTION:
-            return errc::transaction_op::couchbase_exception;
-        case external_exception::DOCUMENT_ALREADY_IN_TRANSACTION:
-            return errc::transaction_op::document_already_in_transaction;
-        case external_exception::DOCUMENT_EXISTS_EXCEPTION:
-            return errc::transaction_op::document_exists_exception;
-        case external_exception::DOCUMENT_NOT_FOUND_EXCEPTION:
-            return errc::transaction_op::document_not_found_exception;
-        case external_exception::FEATURE_NOT_AVAILABLE_EXCEPTION:
-            return errc::transaction_op::feature_not_available_exception;
-        case external_exception::FORWARD_COMPATIBILITY_FAILURE:
-            return errc::transaction_op::forward_compatibility_failure;
-        case external_exception::ILLEGAL_STATE_EXCEPTION:
-            return errc::transaction_op::illegal_state_exception;
-        case external_exception::PARSING_FAILURE:
-            return errc::transaction_op::parsing_failure;
-        case external_exception::NOT_SET:
-            return errc::transaction_op::not_set;
-        case external_exception::PREVIOUS_OPERATION_FAILED:
-            return errc::transaction_op::previous_operation_failed;
-        case external_exception::REQUEST_CANCELED_EXCEPTION:
-            return errc::transaction_op::request_canceled_exception;
-        case external_exception::ROLLBACK_NOT_PERMITTED:
-            return errc::transaction_op::rollback_not_permitted;
-        case external_exception::SERVICE_NOT_AVAILABLE_EXCEPTION:
-            return errc::transaction_op::service_not_available_exception;
-        case external_exception::TRANSACTION_ABORTED_EXTERNALLY:
-            return errc::transaction_op::transaction_aborted_externally;
-        case external_exception::TRANSACTION_ALREADY_ABORTED:
-            return errc::transaction_op::transaction_already_aborted;
-        case external_exception::TRANSACTION_ALREADY_COMMITTED:
-            return errc::transaction_op::transaction_already_committed;
-    }
-    return errc::transaction_op::unknown;
+  switch (e) {
+    case external_exception::UNKNOWN:
+    case external_exception::COUCHBASE_EXCEPTION:
+    case external_exception::NOT_SET:
+      return errc::transaction_op::generic;
+    case external_exception::ACTIVE_TRANSACTION_RECORD_ENTRY_NOT_FOUND:
+      return errc::transaction_op::active_transaction_record_entry_not_found;
+    case external_exception::ACTIVE_TRANSACTION_RECORD_FULL:
+      return errc::transaction_op::active_transaction_record_full;
+    case external_exception::COMMIT_NOT_PERMITTED:
+      return errc::transaction_op::commit_not_permitted;
+    case external_exception::ACTIVE_TRANSACTION_RECORD_NOT_FOUND:
+      return errc::transaction_op::active_transaction_record_not_found;
+    case external_exception::CONCURRENT_OPERATIONS_DETECTED_ON_SAME_DOCUMENT:
+      return errc::transaction_op::concurrent_operations_detected_on_same_document;
+    case external_exception::DOCUMENT_ALREADY_IN_TRANSACTION:
+      return errc::transaction_op::document_already_in_transaction;
+    case external_exception::DOCUMENT_EXISTS_EXCEPTION:
+      return errc::transaction_op::document_exists;
+    case external_exception::DOCUMENT_NOT_FOUND_EXCEPTION:
+      return errc::transaction_op::document_not_found;
+    case external_exception::FEATURE_NOT_AVAILABLE_EXCEPTION:
+      return errc::transaction_op::feature_not_available;
+    case external_exception::FORWARD_COMPATIBILITY_FAILURE:
+      return errc::transaction_op::forward_compatibility_failure;
+    case external_exception::ILLEGAL_STATE_EXCEPTION:
+      return errc::transaction_op::illegal_state;
+    case external_exception::PARSING_FAILURE:
+      return errc::transaction_op::parsing_failure;
+    case external_exception::PREVIOUS_OPERATION_FAILED:
+      return errc::transaction_op::previous_operation_failed;
+    case external_exception::REQUEST_CANCELED_EXCEPTION:
+      return errc::transaction_op::request_canceled;
+    case external_exception::ROLLBACK_NOT_PERMITTED:
+      return errc::transaction_op::rollback_not_permitted;
+    case external_exception::SERVICE_NOT_AVAILABLE_EXCEPTION:
+      return errc::transaction_op::service_not_available;
+    case external_exception::TRANSACTION_ABORTED_EXTERNALLY:
+      return errc::transaction_op::transaction_aborted_externally;
+    case external_exception::TRANSACTION_ALREADY_ABORTED:
+      return errc::transaction_op::transaction_already_aborted;
+    case external_exception::TRANSACTION_ALREADY_COMMITTED:
+      return errc::transaction_op::transaction_already_committed;
+  }
+  return errc::transaction_op::generic;
+}
+
+auto
+external_exception_from_transaction_op_errc(errc::transaction_op ec) -> external_exception
+{
+  switch (ec) {
+    case errc::transaction_op::generic:
+      return external_exception::UNKNOWN;
+    case errc::transaction_op::active_transaction_record_entry_not_found:
+      return external_exception::ACTIVE_TRANSACTION_RECORD_ENTRY_NOT_FOUND;
+    case errc::transaction_op::active_transaction_record_full:
+      return external_exception::ACTIVE_TRANSACTION_RECORD_FULL;
+    case errc::transaction_op::active_transaction_record_not_found:
+      return external_exception::ACTIVE_TRANSACTION_RECORD_NOT_FOUND;
+    case errc::transaction_op::document_already_in_transaction:
+      return external_exception::DOCUMENT_ALREADY_IN_TRANSACTION;
+    case errc::transaction_op::document_exists:
+      return external_exception::DOCUMENT_EXISTS_EXCEPTION;
+    case errc::transaction_op::document_not_found:
+      return external_exception::DOCUMENT_NOT_FOUND_EXCEPTION;
+    case errc::transaction_op::feature_not_available:
+      return external_exception::FEATURE_NOT_AVAILABLE_EXCEPTION;
+    case errc::transaction_op::transaction_aborted_externally:
+      return external_exception::TRANSACTION_ABORTED_EXTERNALLY;
+    case errc::transaction_op::previous_operation_failed:
+      return external_exception::PREVIOUS_OPERATION_FAILED;
+    case errc::transaction_op::forward_compatibility_failure:
+      return external_exception::FORWARD_COMPATIBILITY_FAILURE;
+    case errc::transaction_op::parsing_failure:
+      return external_exception::PARSING_FAILURE;
+    case errc::transaction_op::illegal_state:
+      return external_exception::ILLEGAL_STATE_EXCEPTION;
+    case errc::transaction_op::service_not_available:
+      return external_exception::SERVICE_NOT_AVAILABLE_EXCEPTION;
+    case errc::transaction_op::request_canceled:
+      return external_exception::REQUEST_CANCELED_EXCEPTION;
+    case errc::transaction_op::concurrent_operations_detected_on_same_document:
+      return external_exception::CONCURRENT_OPERATIONS_DETECTED_ON_SAME_DOCUMENT;
+    case errc::transaction_op::commit_not_permitted:
+      return external_exception::COMMIT_NOT_PERMITTED;
+    case errc::transaction_op::rollback_not_permitted:
+      return external_exception::ROLLBACK_NOT_PERMITTED;
+    case errc::transaction_op::transaction_already_aborted:
+      return external_exception::TRANSACTION_ALREADY_ABORTED;
+    case errc::transaction_op::transaction_already_committed:
+      return external_exception::TRANSACTION_ALREADY_COMMITTED;
+    default:
+      return external_exception::UNKNOWN;
+  }
 }
 
 } // namespace couchbase::core::transactions