@nxtedition/rocksdb 15.2.2 → 15.2.4

package/deps/abseil-cpp/absl/base/throw_delegate_test.cc

@@ -1,175 +0,0 @@
-// Copyright 2017 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "absl/base/internal/throw_delegate.h"
-
-#include <functional>
-#include <new>
-#include <stdexcept>
-
-#include "absl/base/config.h"
-#include "gtest/gtest.h"
-
-namespace {
-
-using absl::base_internal::ThrowStdLogicError;
-using absl::base_internal::ThrowStdInvalidArgument;
-using absl::base_internal::ThrowStdDomainError;
-using absl::base_internal::ThrowStdLengthError;
-using absl::base_internal::ThrowStdOutOfRange;
-using absl::base_internal::ThrowStdRuntimeError;
-using absl::base_internal::ThrowStdRangeError;
-using absl::base_internal::ThrowStdOverflowError;
-using absl::base_internal::ThrowStdUnderflowError;
-using absl::base_internal::ThrowStdBadFunctionCall;
-using absl::base_internal::ThrowStdBadAlloc;
-
-constexpr const char* what_arg = "The quick brown fox jumps over the lazy dog";
-
-template <typename E>
-void ExpectThrowChar(void (*f)(const char*)) {
-#ifdef ABSL_HAVE_EXCEPTIONS
-  try {
-    f(what_arg);
-    FAIL() << "Didn't throw";
-  } catch (const E& e) {
-    EXPECT_STREQ(e.what(), what_arg);
-  }
-#else
-  EXPECT_DEATH_IF_SUPPORTED(f(what_arg), what_arg);
-#endif
-}
-
-template <typename E>
-void ExpectThrowString(void (*f)(const std::string&)) {
-#ifdef ABSL_HAVE_EXCEPTIONS
-  try {
-    f(what_arg);
-    FAIL() << "Didn't throw";
-  } catch (const E& e) {
-    EXPECT_STREQ(e.what(), what_arg);
-  }
-#else
-  EXPECT_DEATH_IF_SUPPORTED(f(what_arg), what_arg);
-#endif
-}
-
-template <typename E>
-void ExpectThrowNoWhat(void (*f)()) {
-#ifdef ABSL_HAVE_EXCEPTIONS
-  try {
-    f();
-    FAIL() << "Didn't throw";
-  } catch (const E& e) {
-  }
-#else
-  EXPECT_DEATH_IF_SUPPORTED(f(), "");
-#endif
-}
-
-TEST(ThrowDelegate, ThrowStdLogicErrorChar) {
-  ExpectThrowChar<std::logic_error>(ThrowStdLogicError);
-}
-
-TEST(ThrowDelegate, ThrowStdInvalidArgumentChar) {
-  ExpectThrowChar<std::invalid_argument>(ThrowStdInvalidArgument);
-}
-
-TEST(ThrowDelegate, ThrowStdDomainErrorChar) {
-  ExpectThrowChar<std::domain_error>(ThrowStdDomainError);
-}
-
-TEST(ThrowDelegate, ThrowStdLengthErrorChar) {
-  ExpectThrowChar<std::length_error>(ThrowStdLengthError);
-}
-
-TEST(ThrowDelegate, ThrowStdOutOfRangeChar) {
-  ExpectThrowChar<std::out_of_range>(ThrowStdOutOfRange);
-}
-
-TEST(ThrowDelegate, ThrowStdRuntimeErrorChar) {
-  ExpectThrowChar<std::runtime_error>(ThrowStdRuntimeError);
-}
-
-TEST(ThrowDelegate, ThrowStdRangeErrorChar) {
-  ExpectThrowChar<std::range_error>(ThrowStdRangeError);
-}
-
-TEST(ThrowDelegate, ThrowStdOverflowErrorChar) {
-  ExpectThrowChar<std::overflow_error>(ThrowStdOverflowError);
-}
-
-TEST(ThrowDelegate, ThrowStdUnderflowErrorChar) {
-  ExpectThrowChar<std::underflow_error>(ThrowStdUnderflowError);
-}
-
-TEST(ThrowDelegate, ThrowStdLogicErrorString) {
-  ExpectThrowString<std::logic_error>(ThrowStdLogicError);
-}
-
-TEST(ThrowDelegate, ThrowStdInvalidArgumentString) {
-  ExpectThrowString<std::invalid_argument>(ThrowStdInvalidArgument);
-}
-
-TEST(ThrowDelegate, ThrowStdDomainErrorString) {
-  ExpectThrowString<std::domain_error>(ThrowStdDomainError);
-}
-
-TEST(ThrowDelegate, ThrowStdLengthErrorString) {
-  ExpectThrowString<std::length_error>(ThrowStdLengthError);
-}
-
-TEST(ThrowDelegate, ThrowStdOutOfRangeString) {
-  ExpectThrowString<std::out_of_range>(ThrowStdOutOfRange);
-}
-
-TEST(ThrowDelegate, ThrowStdRuntimeErrorString) {
-  ExpectThrowString<std::runtime_error>(ThrowStdRuntimeError);
-}
-
-TEST(ThrowDelegate, ThrowStdRangeErrorString) {
-  ExpectThrowString<std::range_error>(ThrowStdRangeError);
-}
-
-TEST(ThrowDelegate, ThrowStdOverflowErrorString) {
-  ExpectThrowString<std::overflow_error>(ThrowStdOverflowError);
-}
-
-TEST(ThrowDelegate, ThrowStdUnderflowErrorString) {
-  ExpectThrowString<std::underflow_error>(ThrowStdUnderflowError);
-}
-
-TEST(ThrowDelegate, ThrowStdBadFunctionCallNoWhat) {
-#ifdef ABSL_HAVE_EXCEPTIONS
-  try {
-    ThrowStdBadFunctionCall();
-    FAIL() << "Didn't throw";
-  } catch (const std::bad_function_call&) {
-  }
-#ifdef _LIBCPP_VERSION
-  catch (const std::exception&) {
-    // https://reviews.llvm.org/D92397 causes issues with the vtable for
-    // std::bad_function_call when using libc++ as a shared library.
-  }
-#endif
-#else
-  EXPECT_DEATH_IF_SUPPORTED(ThrowStdBadFunctionCall(), "");
-#endif
-}
-
-TEST(ThrowDelegate, ThrowStdBadAllocNoWhat) {
-  ExpectThrowNoWhat<std::bad_alloc>(ThrowStdBadAlloc);
-}
-
-}  // namespace

package/deps/abseil-cpp/absl/cleanup/BUILD.bazel

@@ -1,74 +0,0 @@
-# Copyright 2021 The Abseil Authors.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      https://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-load("@rules_cc//cc:cc_library.bzl", "cc_library")
-load("@rules_cc//cc:cc_test.bzl", "cc_test")
-load(
-    "//absl:copts/configure_copts.bzl",
-    "ABSL_DEFAULT_COPTS",
-    "ABSL_DEFAULT_LINKOPTS",
-    "ABSL_TEST_COPTS",
-)
-
-package(
-    default_visibility = ["//visibility:public"],
-    features = [
-        "header_modules",
-        "layering_check",
-        "parse_headers",
-    ],
-)
-
-licenses(["notice"])
-
-cc_library(
-    name = "cleanup_internal",
-    hdrs = ["internal/cleanup.h"],
-    copts = ABSL_DEFAULT_COPTS,
-    linkopts = ABSL_DEFAULT_LINKOPTS,
-    deps = [
-        "//absl/base:core_headers",
-        "//absl/utility",
-    ],
-)
-
-cc_library(
-    name = "cleanup",
-    hdrs = [
-        "cleanup.h",
-    ],
-    copts = ABSL_DEFAULT_COPTS,
-    linkopts = ABSL_DEFAULT_LINKOPTS,
-    deps = [
-        ":cleanup_internal",
-        "//absl/base:config",
-        "//absl/base:core_headers",
-    ],
-)
-
-cc_test(
-    name = "cleanup_test",
-    size = "small",
-    srcs = [
-        "cleanup_test.cc",
-    ],
-    copts = ABSL_TEST_COPTS,
-    deps = [
-        ":cleanup",
-        "//absl/base:config",
-        "//absl/utility",
-        "@googletest//:gtest",
-        "@googletest//:gtest_main",
-    ],
-)

package/deps/abseil-cpp/absl/cleanup/CMakeLists.txt

@@ -1,55 +0,0 @@
-# Copyright 2021 The Abseil Authors.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      https://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-# Internal-only target, do not depend on directly.
-absl_cc_library(
-  NAME
-    cleanup_internal
-  HDRS
-    "internal/cleanup.h"
-  COPTS
-    ${ABSL_DEFAULT_COPTS}
-  DEPS
-    absl::core_headers
-    absl::utility
-  PUBLIC
-)
-
-absl_cc_library(
-  NAME
-    cleanup
-  HDRS
-    "cleanup.h"
-  COPTS
-    ${ABSL_DEFAULT_COPTS}
-  DEPS
-    absl::cleanup_internal
-    absl::config
-    absl::core_headers
-  PUBLIC
-)
-
-absl_cc_test(
-  NAME
-    cleanup_test
-  SRCS
-    "cleanup_test.cc"
-  COPTS
-    ${ABSL_TEST_COPTS}
-  DEPS
-    absl::cleanup
-    absl::config
-    absl::utility
-    GTest::gmock_main
-)

package/deps/abseil-cpp/absl/cleanup/cleanup.h

@@ -1,142 +0,0 @@
-// Copyright 2021 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-// -----------------------------------------------------------------------------
-// File: cleanup.h
-// -----------------------------------------------------------------------------
-//
-// `absl::Cleanup` implements the scope guard idiom, invoking the contained
-// callback's `operator()() &&` on scope exit.
-//
-// This class doesn't allocate or take any locks, and is safe to use in a signal
-// handler. Of course the callback with which it is constructed also must be
-// signal safe in order for this to be useful.
-//
-// Example:
-//
-// ```
-//   absl::Status CopyGoodData(const char* source_path, const char* sink_path) {
-//     FILE* source_file = fopen(source_path, "r");
-//     if (source_file == nullptr) {
-//       return absl::NotFoundError("No source file");  // No cleanups execute
-//     }
-//
-//     // C++17 style cleanup using class template argument deduction
-//     absl::Cleanup source_closer = [source_file] { fclose(source_file); };
-//
-//     FILE* sink_file = fopen(sink_path, "w");
-//     if (sink_file == nullptr) {
-//       return absl::NotFoundError("No sink file");  // First cleanup executes
-//     }
-//
-//     // C++11 style cleanup using the factory function
-//     auto sink_closer = absl::MakeCleanup([sink_file] { fclose(sink_file); });
-//
-//     Data data;
-//     while (ReadData(source_file, &data)) {
-//       if (!data.IsGood()) {
-//         absl::Status result = absl::FailedPreconditionError("Read bad data");
-//         return result;  // Both cleanups execute
-//       }
-//       SaveData(sink_file, &data);
-//     }
-//
-//     return absl::OkStatus();  // Both cleanups execute
-//   }
-// ```
-//
-// Methods:
-//
-// `std::move(cleanup).Cancel()` will prevent the callback from executing.
-//
-// `std::move(cleanup).Invoke()` will execute the callback early, before
-// destruction, and prevent the callback from executing in the destructor.
-//
-// Usage:
-//
-// `absl::Cleanup` is not an interface type. It is only intended to be used
-// within the body of a function. It is not a value type and instead models a
-// control flow construct. Check out `defer` in Golang for something similar.
-
-#ifndef ABSL_CLEANUP_CLEANUP_H_
-#define ABSL_CLEANUP_CLEANUP_H_
-
-#include <utility>
-
-#include "absl/base/config.h"
-#include "absl/base/macros.h"
-#include "absl/cleanup/internal/cleanup.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-template <typename Arg, typename Callback = void()>
-class [[nodiscard]] Cleanup final {
-  static_assert(cleanup_internal::WasDeduced<Arg>(),
-                "Explicit template parameters are not supported.");
-
-  static_assert(cleanup_internal::ReturnsVoid<Callback>(),
-                "Callbacks that return values are not supported.");
-
- public:
-  Cleanup(Callback callback) : storage_(std::move(callback)) {}  // NOLINT
-
-  Cleanup(Cleanup&& other) = default;
-
-  void Cancel() && {
-    ABSL_HARDENING_ASSERT(storage_.IsCallbackEngaged());
-    storage_.DestroyCallback();
-  }
-
-  void Invoke() && {
-    ABSL_HARDENING_ASSERT(storage_.IsCallbackEngaged());
-    storage_.InvokeCallback();
-    storage_.DestroyCallback();
-  }
-
-  ~Cleanup() {
-    if (storage_.IsCallbackEngaged()) {
-      storage_.InvokeCallback();
-      storage_.DestroyCallback();
-    }
-  }
-
- private:
-  cleanup_internal::Storage<Callback> storage_;
-};
-
-// `absl::Cleanup c = /* callback */;`
-//
-// C++17 type deduction API for creating an instance of `absl::Cleanup`
-template <typename Callback>
-Cleanup(Callback callback) -> Cleanup<cleanup_internal::Tag, Callback>;
-
-// `auto c = absl::MakeCleanup(/* callback */);`
-//
-// C++11 type deduction API for creating an instance of `absl::Cleanup`
-template <typename... Args, typename Callback>
-absl::Cleanup<cleanup_internal::Tag, Callback> MakeCleanup(Callback callback) {
-  static_assert(cleanup_internal::WasDeduced<cleanup_internal::Tag, Args...>(),
-                "Explicit template parameters are not supported.");
-
-  static_assert(cleanup_internal::ReturnsVoid<Callback>(),
-                "Callbacks that return values are not supported.");
-
-  return {std::move(callback)};
-}
-
-ABSL_NAMESPACE_END
-}  // namespace absl
-
-#endif  // ABSL_CLEANUP_CLEANUP_H_