@nxtedition/rocksdb 15.2.2 → 15.2.4

package/deps/abseil-cpp/absl/container/internal/chunked_queue.h

@@ -1,173 +0,0 @@
-// Copyright 2025 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.
-
-#ifndef ABSL_CONTAINER_INTERNAL_CHUNKED_QUEUE_H_
-#define ABSL_CONTAINER_INTERNAL_CHUNKED_QUEUE_H_
-
-#include <algorithm>
-#include <cstddef>
-#include <cstdint>
-#include <initializer_list>
-#include <iterator>
-#include <memory>
-#include <new>
-#include <tuple>
-#include <type_traits>
-#include <utility>
-
-#include "absl/base/attributes.h"
-#include "absl/base/config.h"
-#include "absl/base/macros.h"
-#include "absl/container/internal/layout.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace container_internal {
-
-// ChunkedQueueBlock defines a node in a forward list of uninitialized storage
-// of size T's. The user is responsible for constructing and destroying T's in
-// said storage.
-//
-// ChunkedQueueBlock::New(size) returns said node, with at least size_hint T's
-// of uninitialized storage.
-template <typename T, typename Allocator>
-class ChunkedQueueBlock {
- private:
-  using ChunkedQueueBlockAllocator = typename std::allocator_traits<
-      Allocator>::template rebind_alloc<ChunkedQueueBlock>;
-  using ByteAllocator =
-      typename std::allocator_traits<Allocator>::template rebind_alloc<char>;
-
- public:
-  // NB, instances of this must not be created or destroyed directly, only via
-  // the New() and Delete() methods.  (This notionally-private constructor is
-  // public only to allow access from allocator types used by New().)
-  explicit ChunkedQueueBlock(size_t size)
-      : next_(nullptr), limit_(start() + size) {}
-
-  // Must be deleted by ChunkedQueueBlock::Delete.
-  static ChunkedQueueBlock* New(size_t size_hint, Allocator* alloc) {  // NOLINT
-    ABSL_ASSERT(size_hint >= size_t{1});
-    size_t allocation_bytes = AllocSize(size_hint);
-    void* mem;
-    std::tie(mem, allocation_bytes) = Allocate(allocation_bytes, alloc);
-    const size_t element_count =
-        (allocation_bytes - start_offset()) / sizeof(T);
-    ChunkedQueueBlock* as_block = static_cast<ChunkedQueueBlock*>(mem);
-    ChunkedQueueBlockAllocator block_alloc(*alloc);
-    std::allocator_traits<ChunkedQueueBlockAllocator>::construct(
-        block_alloc, as_block, element_count);
-    return as_block;
-  }
-
-  static void Delete(ChunkedQueueBlock* ptr, Allocator* alloc) {
-    const size_t allocation_bytes = AllocSize(ptr->size());
-    ChunkedQueueBlockAllocator block_alloc(*alloc);
-    std::allocator_traits<ChunkedQueueBlockAllocator>::destroy(block_alloc,
-                                                               ptr);
-    if constexpr (std::is_same_v<ByteAllocator, std::allocator<char>>) {
-#ifdef __STDCPP_DEFAULT_NEW_ALIGNMENT__
-      if (alignment() > __STDCPP_DEFAULT_NEW_ALIGNMENT__) {
-        ::operator delete(ptr
-#ifdef __cpp_sized_deallocation
-                          ,
-                          allocation_bytes
-#endif
-                          ,
-                          std::align_val_t(alignment()));
-        return;
-      }
-#endif
-      ::operator delete(ptr);
-    } else {
-      void* mem = ptr;
-      ByteAllocator byte_alloc(*alloc);
-      std::allocator_traits<ByteAllocator>::deallocate(
-          byte_alloc, static_cast<char*>(mem), allocation_bytes);
-    }
-  }
-
-  ChunkedQueueBlock* next() const { return next_; }
-  void set_next(ChunkedQueueBlock* next) { next_ = next; }
-  T* start() {
-    return reinterpret_cast<T*>(reinterpret_cast<uintptr_t>(this) +
-                                start_offset());
-  }
-  T* limit() { return limit_; }
-  size_t size() { return limit() - start(); }
-
-  static constexpr size_t block_size_from_bytes(size_t bytes) {
-    return bytes <= static_cast<size_t>(start_offset())
-               ? size_t{1}
-               : elements_in_bytes(bytes - start_offset());
-  }
-
- private:
-  ChunkedQueueBlock(const ChunkedQueueBlock&) = delete;
-  ChunkedQueueBlock& operator=(const ChunkedQueueBlock&) = delete;
-
-  // The byte size to allocate to ensure space for `min_element_count` elements.
-  static constexpr size_t AllocSize(size_t min_element_count) {
-    return absl::container_internal::Layout<ChunkedQueueBlock, T>(
-               1, min_element_count)
-        .AllocSize();
-  }
-
-  static constexpr ptrdiff_t start_offset() {
-    return absl::container_internal::Layout<ChunkedQueueBlock, T>(1, 1)
-        .template Offset<1>();
-  }
-
-  static constexpr size_t alignment() {
-    return absl::container_internal::Layout<ChunkedQueueBlock, T>(1, 1)
-        .Alignment();
-  }
-
-  static constexpr size_t elements_in_bytes(size_t bytes) {
-    return (bytes + sizeof(T) - 1) / sizeof(T);
-  }
-
-  static std::pair<void*, size_t> Allocate(size_t allocation_bytes,
-                                           Allocator* alloc) {
-    // If we're using the default allocator, then we can use new.
-    void* mem;
-    if constexpr (std::is_same_v<ByteAllocator, std::allocator<char>>) {
-      // Older GCC versions have an unused variable warning on `alloc` inside
-      // this constexpr branch.
-      static_cast<void>(alloc);
-#ifdef __STDCPP_DEFAULT_NEW_ALIGNMENT__
-      if (alignment() > __STDCPP_DEFAULT_NEW_ALIGNMENT__) {
-        // Align the allocation to respect alignof(T).
-        mem = ::operator new(allocation_bytes, std::align_val_t(alignment()));
-        return {mem, allocation_bytes};
-      }
-#endif
-      mem = ::operator new(allocation_bytes);
-    } else {
-      ByteAllocator byte_alloc(*alloc);
-      mem = std::allocator_traits<ByteAllocator>::allocate(byte_alloc,
-                                                           allocation_bytes);
-    }
-    return {mem, allocation_bytes};
-  }
-
-  ChunkedQueueBlock* next_;
-  T* limit_;
-};
-
-}  // namespace container_internal
-ABSL_NAMESPACE_END
-}  // namespace absl
-
-#endif  // ABSL_CONTAINER_INTERNAL_CHUNKED_QUEUE_H_

package/deps/abseil-cpp/absl/container/internal/common.h

@@ -1,301 +0,0 @@
-// Copyright 2018 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.
-
-#ifndef ABSL_CONTAINER_INTERNAL_COMMON_H_
-#define ABSL_CONTAINER_INTERNAL_COMMON_H_
-
-#include <algorithm>
-#include <cassert>
-#include <cstddef>
-#include <tuple>
-#include <type_traits>
-
-#include "absl/meta/type_traits.h"
-#include "absl/types/optional.h"
-
-// TODO(b/402804213): Clean up these macros when no longer needed.
-#define ABSL_INTERNAL_SINGLE_ARG(...) __VA_ARGS__
-
-#define ABSL_INTERNAL_IF_true(if_satisfied, ...) if_satisfied
-#define ABSL_INTERNAL_IF_false(if_satisfied, ...) __VA_ARGS__
-
-#define ABSL_INTERNAL_IF_true_AND_true ABSL_INTERNAL_IF_true
-#define ABSL_INTERNAL_IF_false_AND_false ABSL_INTERNAL_IF_false
-#define ABSL_INTERNAL_IF_true_AND_false ABSL_INTERNAL_IF_false_AND_false
-#define ABSL_INTERNAL_IF_false_AND_true ABSL_INTERNAL_IF_false_AND_false
-
-#define ABSL_INTERNAL_IF_true_OR_true ABSL_INTERNAL_IF_true
-#define ABSL_INTERNAL_IF_false_OR_false ABSL_INTERNAL_IF_false
-#define ABSL_INTERNAL_IF_true_OR_false ABSL_INTERNAL_IF_true_OR_true
-#define ABSL_INTERNAL_IF_false_OR_true ABSL_INTERNAL_IF_true_OR_true
-
-#define ABSL_INTERNAL_IF_true_NOR_true ABSL_INTERNAL_IF_false_AND_false
-#define ABSL_INTERNAL_IF_false_NOR_false ABSL_INTERNAL_IF_true_AND_true
-#define ABSL_INTERNAL_IF_true_NOR_false ABSL_INTERNAL_IF_false_AND_true
-#define ABSL_INTERNAL_IF_false_NOR_true ABSL_INTERNAL_IF_true_AND_false
-
-#define ABSL_INTERNAL_COMMA ,
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace container_internal {
-
-// TODO(b/402804213): Clean up these traits when no longer needed or
-// deduplicate them with absl::functional_internal::EnableIf.
-template <class Cond>
-using EnableIf = std::enable_if_t<Cond::value, int>;
-
-template <bool Value, class T>
-using HasValue = std::conditional_t<Value, T, absl::negation<T>>;
-
-template <class T>
-struct IfRRef {
-  template <class Other>
-  using AddPtr = Other;
-};
-
-template <class T>
-struct IfRRef<T&&> {
-  template <class Other>
-  using AddPtr = Other*;
-};
-
-template <class, class = void>
-struct IsTransparent : std::false_type {};
-template <class T>
-struct IsTransparent<T, absl::void_t<typename T::is_transparent>>
-    : std::true_type {};
-
-template <bool is_transparent>
-struct KeyArg {
-  // Transparent. Forward `K`.
-  template <typename K, typename key_type>
-  using type = K;
-};
-
-template <>
-struct KeyArg<false> {
-  // Not transparent. Always use `key_type`.
-  template <typename K, typename key_type>
-  using type = key_type;
-};
-
-// The node_handle concept from C++17.
-// We specialize node_handle for sets and maps. node_handle_base holds the
-// common API of both.
-template <typename PolicyTraits, typename Alloc>
-class node_handle_base {
- protected:
-  using slot_type = typename PolicyTraits::slot_type;
-
- public:
-  using allocator_type = Alloc;
-
-  constexpr node_handle_base() = default;
-  node_handle_base(node_handle_base&& other) noexcept {
-    *this = std::move(other);
-  }
-  ~node_handle_base() { destroy(); }
-  node_handle_base& operator=(node_handle_base&& other) noexcept {
-    destroy();
-    if (!other.empty()) {
-      alloc_ = other.alloc_;
-      PolicyTraits::transfer(alloc(), slot(), other.slot());
-      other.reset();
-    }
-    return *this;
-  }
-
-  bool empty() const noexcept { return !alloc_; }
-  explicit operator bool() const noexcept { return !empty(); }
-  allocator_type get_allocator() const { return *alloc_; }
-
- protected:
-  friend struct CommonAccess;
-
-  struct transfer_tag_t {};
-  node_handle_base(transfer_tag_t, const allocator_type& a, slot_type* s)
-      : alloc_(a) {
-    PolicyTraits::transfer(alloc(), slot(), s);
-  }
-
-  struct construct_tag_t {};
-  template <typename... Args>
-  node_handle_base(construct_tag_t, const allocator_type& a, Args&&... args)
-      : alloc_(a) {
-    PolicyTraits::construct(alloc(), slot(), std::forward<Args>(args)...);
-  }
-
-  void destroy() {
-    if (!empty()) {
-      PolicyTraits::destroy(alloc(), slot());
-      reset();
-    }
-  }
-
-  void reset() {
-    assert(alloc_.has_value());
-    alloc_ = absl::nullopt;
-  }
-
-  slot_type* slot() const {
-    assert(!empty());
-    return reinterpret_cast<slot_type*>(std::addressof(slot_space_));
-  }
-  allocator_type* alloc() { return std::addressof(*alloc_); }
-
- private:
-  absl::optional<allocator_type> alloc_ = {};
-  alignas(slot_type) mutable unsigned char slot_space_[sizeof(slot_type)] = {};
-};
-
-// For sets.
-template <typename Policy, typename PolicyTraits, typename Alloc,
-          typename = void>
-class node_handle : public node_handle_base<PolicyTraits, Alloc> {
-  using Base = node_handle_base<PolicyTraits, Alloc>;
-
- public:
-  using value_type = typename PolicyTraits::value_type;
-
-  constexpr node_handle() {}
-
-  value_type& value() const { return PolicyTraits::element(this->slot()); }
-
- private:
-  friend struct CommonAccess;
-
-  using Base::Base;
-};
-
-// For maps.
-template <typename Policy, typename PolicyTraits, typename Alloc>
-class node_handle<Policy, PolicyTraits, Alloc,
-                  absl::void_t<typename Policy::mapped_type>>
-    : public node_handle_base<PolicyTraits, Alloc> {
-  using Base = node_handle_base<PolicyTraits, Alloc>;
-  using slot_type = typename PolicyTraits::slot_type;
-
- public:
-  using key_type = typename Policy::key_type;
-  using mapped_type = typename Policy::mapped_type;
-
-  constexpr node_handle() {}
-
-  // When C++17 is available, we can use std::launder to provide mutable
-  // access to the key. Otherwise, we provide const access.
-  auto key() const
-      -> decltype(PolicyTraits::mutable_key(std::declval<slot_type*>())) {
-    return PolicyTraits::mutable_key(this->slot());
-  }
-
-  mapped_type& mapped() const {
-    return PolicyTraits::value(&PolicyTraits::element(this->slot()));
-  }
-
- private:
-  friend struct CommonAccess;
-
-  using Base::Base;
-};
-
-// Provide access to non-public node-handle functions.
-struct CommonAccess {
-  template <typename Node>
-  static auto GetSlot(const Node& node) -> decltype(node.slot()) {
-    return node.slot();
-  }
-
-  template <typename Node>
-  static void Destroy(Node* node) {
-    node->destroy();
-  }
-
-  template <typename Node>
-  static void Reset(Node* node) {
-    node->reset();
-  }
-
-  template <typename T, typename... Args>
-  static T Transfer(Args&&... args) {
-    return T(typename T::transfer_tag_t{}, std::forward<Args>(args)...);
-  }
-
-  template <typename T, typename... Args>
-  static T Construct(Args&&... args) {
-    return T(typename T::construct_tag_t{}, std::forward<Args>(args)...);
-  }
-};
-
-// Implement the insert_return_type<> concept of C++17.
-template <class Iterator, class NodeType>
-struct InsertReturnType {
-  Iterator position;
-  bool inserted;
-  NodeType node;
-};
-
-// Utilities to strip redundant template parameters from the underlying
-// implementation types.
-// We use a variadic pack (ie Params...) to specify required prefix of types for
-// non-default types, and then we use GetFromListOr to select the provided types
-// or the default ones otherwise.
-//
-// These default types do not contribute information for debugging and just
-// bloat the binary.
-// Removing the redundant tail types reduces mangled names and stringified
-// function names like __PRETTY_FUNCTION__.
-//
-// How to use:
-//  1. Define a template with `typename ...Params`
-//  2. Instantiate it via `ApplyWithoutDefaultSuffix<>` to only pass the minimal
-//     set of types.
-//  3. Inside the template use `GetFromListOr` to map back from the existing
-//     `Params` list to the actual types, filling the gaps when types are
-//     missing.
-
-template <typename Or, size_t N, typename... Params>
-using GetFromListOr = std::tuple_element_t<(std::min)(N, sizeof...(Params)),
-                                           std::tuple<Params..., Or>>;
-
-template <typename... T>
-struct TypeList {
-  template <template <typename...> class Template>
-  using Apply = Template<T...>;
-};
-
-// Evaluate to `Template<TPrefix...>` where the last type in the list (if any)
-// is different from the corresponding one in the default list.
-// Eg
-//   ApplyWithoutDefaultSuffix<Template, TypeList<a, b, c>, TypeList<a, X, c>>
-// evaluates to
-//   Template<a, X>
-template <template <typename...> class Template, typename D, typename T,
-          typename L = TypeList<>, typename = void>
-struct ApplyWithoutDefaultSuffix {
-  using type = typename L::template Apply<Template>;
-};
-template <template <typename...> class Template, typename D, typename... Ds,
-          typename T, typename... Ts, typename... L>
-struct ApplyWithoutDefaultSuffix<
-    Template, TypeList<D, Ds...>, TypeList<T, Ts...>, TypeList<L...>,
-    std::enable_if_t<!std::is_same_v<TypeList<D, Ds...>, TypeList<T, Ts...>>>>
-    : ApplyWithoutDefaultSuffix<Template, TypeList<Ds...>, TypeList<Ts...>,
-                       TypeList<L..., T>> {};
-
-}  // namespace container_internal
-ABSL_NAMESPACE_END
-}  // namespace absl
-
-#endif  // ABSL_CONTAINER_INTERNAL_COMMON_H_

package/deps/abseil-cpp/absl/container/internal/common_policy_traits.h

@@ -1,151 +0,0 @@
-// Copyright 2022 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.
-
-#ifndef ABSL_CONTAINER_INTERNAL_COMMON_POLICY_TRAITS_H_
-#define ABSL_CONTAINER_INTERNAL_COMMON_POLICY_TRAITS_H_
-
-#include <cstddef>
-#include <cstring>
-#include <memory>
-#include <new>
-#include <type_traits>
-#include <utility>
-
-#include "absl/meta/type_traits.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace container_internal {
-
-template <class Policy, class = void>
-struct policy_trait_element_is_owner : std::false_type {};
-
-template <class Policy>
-struct policy_trait_element_is_owner<
-    Policy,
-    std::enable_if_t<!std::is_void<typename Policy::element_is_owner>::value>>
-    : Policy::element_is_owner {};
-
-// Defines how slots are initialized/destroyed/moved.
-template <class Policy, class = void>
-struct common_policy_traits {
-  // The actual object stored in the container.
-  using slot_type = typename Policy::slot_type;
-  using reference = decltype(Policy::element(std::declval<slot_type*>()));
-  using value_type = typename std::remove_reference<reference>::type;
-
-  // PRECONDITION: `slot` is UNINITIALIZED
-  // POSTCONDITION: `slot` is INITIALIZED
-  template <class Alloc, class... Args>
-  static void construct(Alloc* alloc, slot_type* slot, Args&&... args) {
-    Policy::construct(alloc, slot, std::forward<Args>(args)...);
-  }
-
-  // PRECONDITION: `slot` is INITIALIZED
-  // POSTCONDITION: `slot` is UNINITIALIZED
-  // Returns std::true_type in case destroy is trivial.
-  template <class Alloc>
-  static auto destroy(Alloc* alloc, slot_type* slot) {
-    return Policy::destroy(alloc, slot);
-  }
-
-  // Transfers the `old_slot` to `new_slot`. Any memory allocated by the
-  // allocator inside `old_slot` to `new_slot` can be transferred.
-  //
-  // OPTIONAL: defaults to:
-  //
-  //     clone(new_slot, std::move(*old_slot));
-  //     destroy(old_slot);
-  //
-  // PRECONDITION: `new_slot` is UNINITIALIZED and `old_slot` is INITIALIZED
-  // POSTCONDITION: `new_slot` is INITIALIZED and `old_slot` is
-  //                UNINITIALIZED
-  template <class Alloc>
-  static void transfer(Alloc* alloc, slot_type* new_slot, slot_type* old_slot) {
-    transfer_impl(alloc, new_slot, old_slot, Rank2{});
-  }
-
-  // PRECONDITION: `slot` is INITIALIZED
-  // POSTCONDITION: `slot` is INITIALIZED
-  // Note: we use remove_const_t so that the two overloads have different args
-  // in the case of sets with explicitly const value_types.
-  template <class P = Policy>
-  static auto element(absl::remove_const_t<slot_type>* slot)
-      -> decltype(P::element(slot)) {
-    return P::element(slot);
-  }
-  template <class P = Policy>
-  static auto element(const slot_type* slot) -> decltype(P::element(slot)) {
-    return P::element(slot);
-  }
-
-  static constexpr bool transfer_uses_memcpy() {
-    return std::is_same<decltype(transfer_impl<std::allocator<char>>(
-                            nullptr, nullptr, nullptr, Rank2{})),
-                        std::true_type>::value;
-  }
-
-  // Returns true if destroy is trivial and can be omitted.
-  template <class Alloc>
-  static constexpr bool destroy_is_trivial() {
-    return std::is_same<decltype(destroy<Alloc>(nullptr, nullptr)),
-                        std::true_type>::value;
-  }
-
- private:
-  // Use go/ranked-overloads for dispatching.
-  struct Rank0 {};
-  struct Rank1 : Rank0 {};
-  struct Rank2 : Rank1 {};
-
-  // Use auto -> decltype as an enabler.
-  // P::transfer returns std::true_type if transfer uses memcpy (e.g. in
-  // node_slot_policy).
-  template <class Alloc, class P = Policy>
-  static auto transfer_impl(Alloc* alloc, slot_type* new_slot,
-                            slot_type* old_slot,
-                            Rank2) -> decltype(P::transfer(alloc, new_slot,
-                                                           old_slot)) {
-    return P::transfer(alloc, new_slot, old_slot);
-  }
-
-  // This overload returns true_type for the trait below.
-  // The conditional_t is to make the enabler type dependent.
-  template <class Alloc,
-            typename = std::enable_if_t<absl::is_trivially_relocatable<
-                std::conditional_t<false, Alloc, value_type>>::value>>
-  static std::true_type transfer_impl(Alloc*, slot_type* new_slot,
-                                      slot_type* old_slot, Rank1) {
-    // TODO(b/247130232): remove casts after fixing warnings.
-    // TODO(b/251814870): remove casts after fixing warnings.
-    std::memcpy(
-        static_cast<void*>(std::launder(
-            const_cast<std::remove_const_t<value_type>*>(&element(new_slot)))),
-        static_cast<const void*>(&element(old_slot)), sizeof(value_type));
-    return {};
-  }
-
-  template <class Alloc>
-  static void transfer_impl(Alloc* alloc, slot_type* new_slot,
-                            slot_type* old_slot, Rank0) {
-    construct(alloc, new_slot, std::move(element(old_slot)));
-    destroy(alloc, old_slot);
-  }
-};
-
-}  // namespace container_internal
-ABSL_NAMESPACE_END
-}  // namespace absl
-
-#endif  // ABSL_CONTAINER_INTERNAL_COMMON_POLICY_TRAITS_H_