@nxtedition/rocksdb 15.2.2 → 15.2.4

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

@@ -1,755 +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.
-//
-// -----------------------------------------------------------------------------
-// File: chunked_queue.h
-// -----------------------------------------------------------------------------
-//
-// `std::deque` provides random access and fast push/pop back/front. It is
-// implemented as an array of fixed blocks. It provides no control of block size
-// and implementations differ; libstdc++ tries to allocate blocks of ~512 bytes
-// and libc++ tries for blocks of ~4k bytes.
-//
-// `absl::chunked_queue` provides the same minus random access. It is
-// implemented as a double-linked list of fixed or variable sized blocks.
-//
-// `absl::chunked_queue` is useful when memory usage is paramount as it provides
-//  finegrained and configurable block sizing.
-//
-// The interface supported by this class is limited to:
-//
-//   empty()
-//   size()
-//   max_size()
-//   shrink_to_fit()
-//   resize()
-//   assign()
-//   push_back()
-//   emplace_back()
-//   pop_front()
-//   front()
-//   back()
-//   swap()
-//   clear()
-//   begin(), end()
-//   cbegin(), cend()
-//
-// === ADVANCED USAGE
-//
-// == clear()
-//
-// As an optimization clear() leaves the first block of the chunked_queue
-// allocated (but empty). So clear will not delete all memory of the container.
-// In order to do so, call shrink_to_fit() or swap the container with an empty
-// one.
-//
-//   absl::chunked_queue<int64> q = {1, 2, 3};
-//   q.clear();
-//   q.shrink_to_fit();
-//
-// == block size customization
-//
-// chunked_queue allows customization of the block size for each block. By
-// default the block size is set to 1 element and the size doubles for the next
-// block until it reaches the default max block size, which is 128 elements.
-//
-// = fixed size
-//
-// When only the first block size parameter is specified, it sets a fixed block
-// size for all blocks:
-//
-//   chunked_queue<T, 32>: 32 elements per block
-//
-// The smaller the block size, the less the memory usage for small queues at the
-// cost of performance. Caveat: For large queues, a smaller block size will
-// increase memory usage, and reduce performance.
-//
-// = variable size
-//
-// When both block size parameters are specified, they set the min and max block
-// sizes for the blocks. Initially the queue starts with the min block size and
-// as it grows, the size of each block grows until it reaches the max block
-// size.
-// New blocks are double the size of the tail block (so they at least
-// double the size of the queue).
-//
-//   chunked_queue<T, 4, 64>: first block 4 elements, second block 8 elements,
-//                            third block 16 elements, fourth block 32 elements,
-//                            all other blocks 64 elements
-//
-// One can specify a min and max such that small queues will not waste memory
-// and large queues will not have too many blocks.
-
-#ifndef ABSL_CONTAINER_CHUNKED_QUEUE_H_
-#define ABSL_CONTAINER_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/internal/iterator_traits.h"
-#include "absl/base/macros.h"
-#include "absl/container/internal/chunked_queue.h"
-#include "absl/container/internal/layout.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-template <typename T, size_t BLo = 0, size_t BHi = BLo,
-          typename Allocator = std::allocator<T>>
-class chunked_queue {
- public:
-  static constexpr size_t kBlockSizeMin = (BLo == 0 && BHi == 0) ? 1 : BLo;
-  static constexpr size_t kBlockSizeMax = (BLo == 0 && BHi == 0) ? 128 : BHi;
-
- private:
-  static_assert(kBlockSizeMin > 0, "Min block size cannot be zero");
-  static_assert(kBlockSizeMin <= kBlockSizeMax, "Invalid block size bounds");
-
-  using Block = container_internal::ChunkedQueueBlock<T, Allocator>;
-  using AllocatorTraits = std::allocator_traits<Allocator>;
-
-  class iterator_common {
-   public:
-    friend bool operator==(const iterator_common& a, const iterator_common& b) {
-      return a.ptr == b.ptr;
-    }
-
-    friend bool operator!=(const iterator_common& a, const iterator_common& b) {
-      return !(a == b);
-    }
-
-   protected:
-    iterator_common() = default;
-    explicit iterator_common(Block* b)
-        : block(b), ptr(b->start()), limit(b->limit()) {}
-
-    void Incr() {
-      // If we do not have a next block, make ptr point one past the end of this
-      // block. If we do have a next block, make ptr point to the first element
-      // of the next block.
-      ++ptr;
-      if (ptr == limit && block->next()) *this = iterator_common(block->next());
-    }
-
-    void IncrBy(size_t n) {
-      while (ptr + n > limit) {
-        n -= limit - ptr;
-        *this = iterator_common(block->next());
-      }
-      ptr += n;
-    }
-
-    Block* block = nullptr;
-    T* ptr = nullptr;
-    T* limit = nullptr;
-  };
-
-  // CT can be either T or const T.
-  template <typename CT>
-  class basic_iterator : public iterator_common {
-   public:
-    using iterator_category = std::forward_iterator_tag;
-    using value_type = typename AllocatorTraits::value_type;
-    using difference_type = typename AllocatorTraits::difference_type;
-    using pointer =
-        typename std::conditional<std::is_const<CT>::value,
-                                  typename AllocatorTraits::const_pointer,
-                                  typename AllocatorTraits::pointer>::type;
-    using reference = CT&;
-
-    basic_iterator() = default;
-
-    // Copy ctor if CT is T.
-    // Otherwise it's a conversion of iterator to const_iterator.
-    basic_iterator(const basic_iterator<T>& it)  // NOLINT(runtime/explicit)
-        : iterator_common(it) {}
-
-    basic_iterator& operator=(const basic_iterator& other) = default;
-
-    reference operator*() const { return *this->ptr; }
-    pointer operator->() const { return this->ptr; }
-    basic_iterator& operator++() {
-      this->Incr();
-      return *this;
-    }
-    basic_iterator operator++(int) {
-      basic_iterator t = *this;
-      ++*this;
-      return t;
-    }
-
-   private:
-    explicit basic_iterator(Block* b) : iterator_common(b) {}
-
-    friend chunked_queue;
-  };
-
- public:
-  using allocator_type = typename AllocatorTraits::allocator_type;
-  using value_type = typename AllocatorTraits::value_type;
-  using size_type = typename AllocatorTraits::size_type;
-  using difference_type = typename AllocatorTraits::difference_type;
-  using reference = value_type&;
-  using const_reference = const value_type&;
-  using iterator = basic_iterator<T>;
-  using const_iterator = basic_iterator<const T>;
-
-  // Constructs an empty queue.
-  chunked_queue() : chunked_queue(allocator_type()) {}
-
-  // Constructs an empty queue with a custom allocator.
-  explicit chunked_queue(const allocator_type& alloc)
-      : alloc_and_size_(alloc) {}
-
-  // Constructs a queue with `count` default-inserted elements.
-  explicit chunked_queue(size_type count,
-                         const allocator_type& alloc = allocator_type())
-      : alloc_and_size_(alloc) {
-    resize(count);
-  }
-
-  // Constructs a queue with `count` copies of `value`.
-  chunked_queue(size_type count, const T& value,
-                const allocator_type& alloc = allocator_type())
-      : alloc_and_size_(alloc) {
-    assign(count, value);
-  }
-
-  // Constructs a queue with the contents of the range [first, last).
-  template <typename Iter,
-            typename = std::enable_if_t<
-                base_internal::IsAtLeastInputIterator<Iter>::value>>
-  chunked_queue(Iter first, Iter last,
-                const allocator_type& alloc = allocator_type())
-      : alloc_and_size_(alloc) {
-    using Tag = typename std::iterator_traits<Iter>::iterator_category;
-    RangeInit(first, last, Tag());
-  }
-
-  // Constructs a queue with the contents of the initializer list `list`.
-  chunked_queue(std::initializer_list<T> list,
-                const allocator_type& alloc = allocator_type())
-      : chunked_queue(list.begin(), list.end(), alloc) {}
-
-  ~chunked_queue();
-
-  // Copy constructor.
-  chunked_queue(const chunked_queue& other)
-      : chunked_queue(other,
-                      AllocatorTraits::select_on_container_copy_construction(
-                          other.alloc_and_size_.allocator())) {}
-
-  // Copy constructor with specific allocator.
-  chunked_queue(const chunked_queue& other, const allocator_type& alloc)
-      : alloc_and_size_(alloc) {
-    for (const_reference item : other) {
-      push_back(item);
-    }
-  }
-
-  // Move constructor.
-  chunked_queue(chunked_queue&& other) noexcept
-      : head_(other.head_),
-        tail_(other.tail_),
-        alloc_and_size_(std::move(other.alloc_and_size_)) {
-    other.head_ = {};
-    other.tail_ = {};
-    other.alloc_and_size_.size = 0;
-  }
-
-  // Replaces contents with those from initializer list `il`.
-  chunked_queue& operator=(std::initializer_list<T> il) {
-    assign(il.begin(), il.end());
-    return *this;
-  }
-
-  // Copy assignment operator.
-  chunked_queue& operator=(const chunked_queue& other) {
-    if (this == &other) {
-      return *this;
-    }
-    if (AllocatorTraits::propagate_on_container_copy_assignment::value &&
-        (alloc_and_size_.allocator() != other.alloc_and_size_.allocator())) {
-      // Destroy all current elements and blocks with the current allocator,
-      // before switching this to use the allocator propagated from "other".
-      DestroyAndDeallocateAll();
-      alloc_and_size_ = AllocatorAndSize(other.alloc_and_size_.allocator());
-    }
-    assign(other.begin(), other.end());
-    return *this;
-  }
-
-  // Move assignment operator.
-  chunked_queue& operator=(chunked_queue&& other) noexcept;
-
-  // Returns true if the queue contains no elements.
-  bool empty() const { return alloc_and_size_.size == 0; }
-
-  // Returns the number of elements in the queue.
-  size_t size() const { return alloc_and_size_.size; }
-
-  // Returns the maximum number of elements the queue is able to hold.
-  size_type max_size() const noexcept {
-    return AllocatorTraits::max_size(alloc_and_size_.allocator());
-  }
-
-  // Resizes the container to contain `new_size` elements.
-  // If `new_size > size()`, additional default-inserted elements are appended.
-  // If `new_size < size()`, elements are removed from the end.
-  void resize(size_t new_size);
-
-  // Resizes the container to contain `new_size` elements.
-  // If `new_size > size()`, additional copies of `value` are appended.
-  // If `new_size < size()`, elements are removed from the end.
-  void resize(size_type new_size, const T& value) {
-    if (new_size > size()) {
-      size_t to_add = new_size - size();
-      for (size_t i = 0; i < to_add; ++i) {
-        push_back(value);
-      }
-    } else {
-      resize(new_size);
-    }
-  }
-
-  // Requests the removal of unused capacity.
-  void shrink_to_fit() {
-    // As an optimization clear() leaves the first block of the chunked_queue
-    // allocated (but empty). When empty, shrink_to_fit() deallocates the first
-    // block by swapping it a newly constructed container that has no first
-    // block.
-    if (empty()) {
-      chunked_queue(alloc_and_size_.allocator()).swap(*this);
-    }
-  }
-
-  // Replaces the contents with copies of those in the range [first, last).
-  template <typename Iter,
-            typename = std::enable_if_t<
-                base_internal::IsAtLeastInputIterator<Iter>::value>>
-  void assign(Iter first, Iter last) {
-    auto out = begin();
-    Block* prev_block = nullptr;
-
-    // Overwrite existing elements.
-    for (; out != end() && first != last; ++first) {
-      // Track the previous block so we can correctly update tail_ if we stop
-      // exactly at a block boundary.
-      if (out.ptr + 1 == out.block->limit()) {
-        prev_block = out.block;
-      }
-      *out = *first;
-      ++out;
-    }
-
-    // If we stopped exactly at the start of a block (meaning the previous block
-    // was full), we must ensure tail_ points to the end of the previous block,
-    // not the start of the current (now empty and to be deleted) block.
-    // This maintains the invariant required by back() which assumes tail_
-    // never points to the start of a block (unless it's the only block).
-    if (!empty() && out.block != nullptr && out.ptr == out.block->start() &&
-        prev_block != nullptr) {
-      // Delete the current block and all subsequent blocks.
-      //
-      // NOTE: Calling EraseAllFrom on an iterator that points to the limit of
-      // the previous block will not delete any element from the previous block.
-      iterator prev_block_end(prev_block);
-      prev_block_end.ptr = prev_block->limit();
-      EraseAllFrom(prev_block_end);
-
-      // Update tail_ to point to the end of the previous block.
-      tail_ = prev_block_end;
-      prev_block->set_next(nullptr);
-    } else {
-      // Standard erase from the current position to the end.
-      EraseAllFrom(out);
-    }
-
-    // Append any remaining new elements.
-    for (; first != last; ++first) {
-      push_back(*first);
-    }
-  }
-
-  // Replaces the contents with `count` copies of `value`.
-  void assign(size_type count, const T& value) {
-    clear();
-    for (size_type i = 0; i < count; ++i) {
-      push_back(value);
-    }
-  }
-
-  // Replaces the contents with the elements from the initializer list `il`.
-  void assign(std::initializer_list<T> il) { assign(il.begin(), il.end()); }
-
-  // Appends the given element value to the end of the container.
-  // Invalidates `end()` iterator. References to other elements remain valid.
-  void push_back(const T& val) { emplace_back(val); }
-  void push_back(T&& val) { emplace_back(std::move(val)); }
-
-  // Appends a new element to the end of the container.
-  // The element is constructed in-place with `args`.
-  // Returns a reference to the new element.
-  // Invalidates `end()` iterator. References to other elements remain valid.
-  template <typename... A>
-  T& emplace_back(A&&... args) {
-    T* storage = AllocateBack();
-    AllocatorTraits::construct(alloc_and_size_.allocator(), storage,
-                               std::forward<A>(args)...);
-    return *storage;
-  }
-
-  // Removes the first element of the container.
-  // Invalidates iterators to the removed element.
-  // REQUIRES: !empty()
-  void pop_front();
-
-  // Returns a reference to the first element in the container.
-  // REQUIRES: !empty()
-  T& front() {
-    ABSL_HARDENING_ASSERT(!empty());
-    return *head_;
-  }
-  const T& front() const {
-    ABSL_HARDENING_ASSERT(!empty());
-    return *head_;
-  }
-
-  // Returns a reference to the last element in the container.
-  // REQUIRES: !empty()
-  T& back() {
-    ABSL_HARDENING_ASSERT(!empty());
-    return *(&*tail_ - 1);
-  }
-  const T& back() const {
-    ABSL_HARDENING_ASSERT(!empty());
-    return *(&*tail_ - 1);
-  }
-
-  // Swaps the contents of this queue with `other`.
-  void swap(chunked_queue& other) noexcept {
-    using std::swap;
-    swap(head_, other.head_);
-    swap(tail_, other.tail_);
-    if (AllocatorTraits::propagate_on_container_swap::value) {
-      swap(alloc_and_size_, other.alloc_and_size_);
-    } else {
-      // Swap only the sizes; each object keeps its allocator.
-      //
-      // (It is undefined behavior to swap between two containers with unequal
-      // allocators if propagate_on_container_swap is false, so we don't have to
-      // handle that here like we do in the move-assignment operator.)
-      ABSL_HARDENING_ASSERT(get_allocator() == other.get_allocator());
-      swap(alloc_and_size_.size, other.alloc_and_size_.size);
-    }
-  }
-
-  // Erases all elements from the container.
-  // Note: Leaves one empty block allocated as an optimization.
-  // To free all memory, call shrink_to_fit() after calling clear().
-  void clear();
-
-  iterator begin() { return head_; }
-  iterator end() { return tail_; }
-
-  const_iterator begin() const { return head_; }
-  const_iterator end() const { return tail_; }
-
-  const_iterator cbegin() const { return head_; }
-  const_iterator cend() const { return tail_; }
-
-  // Returns the allocator associated with the container.
-  allocator_type get_allocator() const { return alloc_and_size_.allocator(); }
-
- private:
-  // Empty base-class optimization: bundle storage for our allocator together
-  // with a field we had to store anyway (size), via inheriting from the
-  // allocator, so this allocator instance doesn't consume any storage
-  // when its type has no data members.
-  struct AllocatorAndSize : private allocator_type {
-    explicit AllocatorAndSize(const allocator_type& alloc)
-        : allocator_type(alloc) {}
-    const allocator_type& allocator() const { return *this; }
-    allocator_type& allocator() { return *this; }
-    size_t size = 0;
-  };
-
-  template <typename Iter>
-  void RangeInit(Iter first, Iter last, std::input_iterator_tag) {
-    while (first != last) {
-      AddTailBlock();
-      for (; first != last && tail_.ptr != tail_.limit;
-           ++alloc_and_size_.size, ++tail_.ptr, ++first) {
-        AllocatorTraits::construct(alloc_and_size_.allocator(), tail_.ptr,
-                                   *first);
-      }
-    }
-  }
-
-  void Construct(T* start, T* limit) {
-    ABSL_ASSERT(start <= limit);
-    for (; start != limit; ++start) {
-      AllocatorTraits::construct(alloc_and_size_.allocator(), start);
-    }
-  }
-
-  size_t Destroy(T* start, T* limit) {
-    ABSL_ASSERT(start <= limit);
-    const size_t n = limit - start;
-    for (; start != limit; ++start) {
-      AllocatorTraits::destroy(alloc_and_size_.allocator(), start);
-    }
-    return n;
-  }
-
-  T* block_begin(Block* b) const {
-    return b == head_.block ? head_.ptr : b->start();
-  }
-  T* block_end(Block* b) const {
-    // We have the choice of !b->next or b == tail_.block to determine if b is
-    // the tail or not. !b->next is usually faster because the caller of
-    // block_end() is most likely traversing the list of blocks so b->next is
-    // already fetched into some register.
-    return !b->next() ? tail_.ptr : b->limit();
-  }
-
-  void AddTailBlock();
-  size_t NewBlockSize() {
-    // Double the last block size and bound to [kBlockSizeMin, kBlockSizeMax].
-    if (!tail_.block) return kBlockSizeMin;
-    return (std::min)(kBlockSizeMax, 2 * tail_.block->size());
-  }
-
-  T* AllocateBack();
-  void EraseAllFrom(iterator i);
-
-  // Destroys any contained elements and destroys all allocated storage.
-  // (Like clear(), except this doesn't leave any empty blocks behind.)
-  void DestroyAndDeallocateAll();
-
-  // The set of elements in the queue is the following:
-  //
-  // (1) When we have just one block:
-  //      [head_.ptr .. tail_.ptr-1]
-  // (2) When we have multiple blocks:
-  //      [head_.ptr .. head_.limit-1]
-  //      ... concatenation of all elements from interior blocks ...
-  //      [tail_.ptr .. tail_.limit-1]
-  //
-  // Rep invariants:
-  // When have just one block:
-  //   head_.limit == tail_.limit == &head_.block->element[kBlockSize]
-  // Always:
-  //   head_.ptr <= head_.limit
-  //   tail_.ptr <= tail_.limit
-
-  iterator head_;
-  iterator tail_;
-  AllocatorAndSize alloc_and_size_;
-};
-
-template <typename T, size_t BLo, size_t BHi, typename Allocator>
-constexpr size_t chunked_queue<T, BLo, BHi, Allocator>::kBlockSizeMin;
-
-template <typename T, size_t BLo, size_t BHi, typename Allocator>
-constexpr size_t chunked_queue<T, BLo, BHi, Allocator>::kBlockSizeMax;
-
-template <typename T, size_t BLo, size_t BHi, typename Allocator>
-inline void swap(chunked_queue<T, BLo, BHi, Allocator>& a,
-                 chunked_queue<T, BLo, BHi, Allocator>& b) noexcept {
-  a.swap(b);
-}
-
-template <typename T, size_t BLo, size_t BHi, typename Allocator>
-chunked_queue<T, BLo, BHi, Allocator>&
-chunked_queue<T, BLo, BHi, Allocator>::operator=(
-    chunked_queue&& other) noexcept {
-  if (this == &other) {
-    return *this;
-  }
-  DestroyAndDeallocateAll();
-
-  if constexpr (AllocatorTraits::propagate_on_container_move_assignment::
-                    value) {
-    // Take over the storage of "other", along with its allocator.
-    head_ = other.head_;
-    tail_ = other.tail_;
-    alloc_and_size_ = std::move(other.alloc_and_size_);
-    other.head_ = {};
-    other.tail_ = {};
-    other.alloc_and_size_.size = 0;
-  } else if (get_allocator() == other.get_allocator()) {
-    // Take over the storage of "other", with which we share an allocator.
-    head_ = other.head_;
-    tail_ = other.tail_;
-    alloc_and_size_.size = other.alloc_and_size_.size;
-    other.head_ = {};
-    other.tail_ = {};
-    other.alloc_and_size_.size = 0;
-  } else {
-    // We cannot take over of the storage from "other", since it has a different
-    // allocator; we're stuck move-assigning elements individually.
-    for (auto& elem : other) {
-      push_back(std::move(elem));
-    }
-  }
-  return *this;
-}
-
-template <typename T, size_t BLo, size_t BHi, typename Allocator>
-inline chunked_queue<T, BLo, BHi, Allocator>::~chunked_queue() {
-  Block* b = head_.block;
-  while (b) {
-    Block* next = b->next();
-    Destroy(block_begin(b), block_end(b));
-    Block::Delete(b, &alloc_and_size_.allocator());
-    b = next;
-  }
-}
-
-template <typename T, size_t BLo, size_t BHi, typename Allocator>
-void chunked_queue<T, BLo, BHi, Allocator>::resize(size_t new_size) {
-  while (new_size > size()) {
-    ptrdiff_t to_add = new_size - size();
-    if (tail_.ptr == tail_.limit) {
-      AddTailBlock();
-    }
-    T* start = tail_.ptr;
-    T* limit = (std::min)(tail_.limit, start + to_add);
-    Construct(start, limit);
-    tail_.ptr = limit;
-    alloc_and_size_.size += limit - start;
-  }
-  if (size() == new_size) {
-    return;
-  }
-  ABSL_ASSERT(new_size < size());
-  auto new_end = begin();
-  new_end.IncrBy(new_size);
-  ABSL_ASSERT(new_end != end());
-  EraseAllFrom(new_end);
-}
-
-template <typename T, size_t BLo, size_t BHi, typename Allocator>
-inline void chunked_queue<T, BLo, BHi, Allocator>::AddTailBlock() {
-  ABSL_ASSERT(tail_.ptr == tail_.limit);
-  auto* b = Block::New(NewBlockSize(), &alloc_and_size_.allocator());
-  if (!head_.block) {
-    ABSL_ASSERT(!tail_.block);
-    head_ = iterator(b);
-  } else {
-    ABSL_ASSERT(tail_.block);
-    tail_.block->set_next(b);
-  }
-  tail_ = iterator(b);
-}
-
-template <typename T, size_t BLo, size_t BHi, typename Allocator>
-inline T* chunked_queue<T, BLo, BHi, Allocator>::AllocateBack() {
-  if (tail_.ptr == tail_.limit) {
-    AddTailBlock();
-  }
-  ++alloc_and_size_.size;
-  return tail_.ptr++;
-}
-
-template <typename T, size_t BLo, size_t BHi, typename Allocator>
-inline void chunked_queue<T, BLo, BHi, Allocator>::EraseAllFrom(iterator i) {
-  if (!i.block) {
-    return;
-  }
-  ABSL_ASSERT(i.ptr);
-  ABSL_ASSERT(i.limit);
-  alloc_and_size_.size -= Destroy(i.ptr, block_end(i.block));
-  Block* b = i.block->next();
-  while (b) {
-    Block* next = b->next();
-    alloc_and_size_.size -= Destroy(b->start(), block_end(b));
-    Block::Delete(b, &alloc_and_size_.allocator());
-    b = next;
-  }
-  tail_ = i;
-  tail_.block->set_next(nullptr);
-}
-
-template <typename T, size_t BLo, size_t BHi, typename Allocator>
-inline void chunked_queue<T, BLo, BHi, Allocator>::DestroyAndDeallocateAll() {
-  Block* b = head_.block;
-  while (b) {
-    Block* next = b->next();
-    Destroy(block_begin(b), block_end(b));
-    Block::Delete(b, &alloc_and_size_.allocator());
-    b = next;
-  }
-  head_ = iterator();
-  tail_ = iterator();
-  alloc_and_size_.size = 0;
-}
-
-template <typename T, size_t BLo, size_t BHi, typename Allocator>
-inline void chunked_queue<T, BLo, BHi, Allocator>::pop_front() {
-  ABSL_HARDENING_ASSERT(!empty());
-  ABSL_ASSERT(head_.block);
-  AllocatorTraits::destroy(alloc_and_size_.allocator(), head_.ptr);
-  ++head_.ptr;
-  --alloc_and_size_.size;
-  if (empty()) {
-    // Reset head and tail to the start of the (only) block.
-    ABSL_ASSERT(head_.block == tail_.block);
-    head_.ptr = tail_.ptr = head_.block->start();
-    return;
-  }
-  if (head_.ptr == head_.limit) {
-    Block* n = head_.block->next();
-    Block::Delete(head_.block, &alloc_and_size_.allocator());
-    head_ = iterator(n);
-  }
-}
-
-template <typename T, size_t BLo, size_t BHi, typename Allocator>
-void chunked_queue<T, BLo, BHi, Allocator>::clear() {
-  // NOTE: As an optimization we leave one block allocated.
-  Block* b = head_.block;
-  if (!b) {
-    ABSL_ASSERT(empty());
-    return;
-  }
-  while (b) {
-    Block* next = b->next();
-    Destroy(block_begin(b), block_end(b));
-    if (head_.block != b) {
-      Block::Delete(b, &alloc_and_size_.allocator());
-    }
-    b = next;
-  }
-  b = head_.block;
-  b->set_next(nullptr);
-  head_ = tail_ = iterator(b);
-  alloc_and_size_.size = 0;
-}
-
-ABSL_NAMESPACE_END
-}  // namespace absl
-
-#endif  // ABSL_CONTAINER_CHUNKED_QUEUE_H_