inline_var_len_entry_queue.h

Go to the documentation of this file.

// Copyright 2023 The Pigweed 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.
#pragma once
 
#ifdef __cplusplus
 
#include <cstddef>
#include <cstdint>
 
#include "pw_toolchain/constexpr_tag.h"
 
#else
 
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <string.h>
 
#endif  // __cplusplus
 
#include "pw_preprocessor/compiler.h"
#include "pw_preprocessor/util.h"
#include "pw_varint/varint.h"
 
// TODO: https://pwbug.dev/426012010 - Find a way to single-source this
// content on the Sphinx site without Breathe.
 
#ifdef __cplusplus
extern "C" {
#endif  // __cplusplus
 
 
 
 
typedef uint32_t* pw_InlineVarLenEntryQueue_Handle;
typedef const uint32_t* pw_InlineVarLenEntryQueue_ConstHandle;
 
#define PW_VARIABLE_LENGTH_ENTRY_QUEUE_DECLARE(variable, max_size_bytes) \
  uint32_t variable[PW_VARIABLE_LENGTH_ENTRY_QUEUE_HEADER_SIZE_UINT32 +  \
                    _PW_VAR_QUEUE_DATA_SIZE_UINT32(max_size_bytes)] = {  \
      _PW_VAR_QUEUE_DATA_SIZE_BYTES(max_size_bytes), /*head=*/0u, /*tail=*/0u}
 
#define PW_VARIABLE_LENGTH_ENTRY_QUEUE_HEADER_SIZE_UINT32 (3)
 
static inline void pw_InlineVarLenEntryQueue_Init(uint32_t array[],
                                                  size_t array_size_uint32);
 
static inline void pw_InlineVarLenEntryQueue_Clear(
    pw_InlineVarLenEntryQueue_Handle queue);
 
void pw_InlineVarLenEntryQueue_Push(pw_InlineVarLenEntryQueue_Handle queue,
                                    const void* data,
                                    uint32_t data_size_bytes);
 
bool pw_InlineVarLenEntryQueue_TryPush(pw_InlineVarLenEntryQueue_Handle queue,
                                       const void* data,
                                       const uint32_t data_size_bytes);
 
void pw_InlineVarLenEntryQueue_PushOverwrite(
    pw_InlineVarLenEntryQueue_Handle queue,
    const void* data,
    uint32_t data_size_bytes);
 
void pw_InlineVarLenEntryQueue_Pop(pw_InlineVarLenEntryQueue_Handle queue);
 
typedef struct {
  // Private: do not access these fields directly!
  pw_InlineVarLenEntryQueue_ConstHandle _pw_queue;
  uint32_t _pw_offset;
} pw_InlineVarLenEntryQueue_ConstIterator;
 
typedef struct {
  // Private: do not access these fields directly!
  pw_InlineVarLenEntryQueue_ConstIterator _iterator;
} pw_InlineVarLenEntryQueue_Iterator;
 
typedef struct {
  uint8_t* data_1;
  uint32_t size_1;
  uint8_t* data_2;
  uint32_t size_2;
} pw_InlineVarLenEntryQueue_Entry;
 
typedef struct {
  const uint8_t* data_1;
  uint32_t size_1;
  const uint8_t* data_2;
  uint32_t size_2;
} pw_InlineVarLenEntryQueue_ConstEntry;
 
static inline pw_InlineVarLenEntryQueue_Iterator
pw_InlineVarLenEntryQueue_Begin(pw_InlineVarLenEntryQueue_Handle queue);
 
static inline pw_InlineVarLenEntryQueue_Iterator pw_InlineVarLenEntryQueue_End(
    pw_InlineVarLenEntryQueue_Handle queue);
 
static inline pw_InlineVarLenEntryQueue_ConstIterator
pw_InlineVarLenEntryQueue_ConstEnd(pw_InlineVarLenEntryQueue_ConstHandle queue);
 
static inline void pw_InlineVarLenEntryQueue_Iterator_Advance(
    pw_InlineVarLenEntryQueue_Iterator* iterator);
 
void pw_InlineVarLenEntryQueue_ConstIterator_Advance(
    pw_InlineVarLenEntryQueue_ConstIterator* iterator);
 
static inline bool pw_InlineVarLenEntryQueue_Iterator_Equal(
    const pw_InlineVarLenEntryQueue_Iterator* lhs,
    const pw_InlineVarLenEntryQueue_Iterator* rhs);
 
static inline bool pw_InlineVarLenEntryQueue_ConstIterator_Equal(
    const pw_InlineVarLenEntryQueue_ConstIterator* lhs,
    const pw_InlineVarLenEntryQueue_ConstIterator* rhs);
 
static inline pw_InlineVarLenEntryQueue_Entry
pw_InlineVarLenEntryQueue_GetEntry(
    const pw_InlineVarLenEntryQueue_Iterator* iterator);
 
pw_InlineVarLenEntryQueue_ConstEntry pw_InlineVarLenEntryQueue_GetConstEntry(
    const pw_InlineVarLenEntryQueue_ConstIterator* iterator);
 
uint32_t pw_InlineVarLenEntryQueue_ConstEntry_Copy(
    const pw_InlineVarLenEntryQueue_ConstEntry* entry,
    void* dest,
    uint32_t count);
 
// clang-tidy gives errors for `static inline` functions in headers, so disable
// these diagnostics.
PW_MODIFY_DIAGNOSTICS_PUSH();
PW_MODIFY_DIAGNOSTIC_CLANG(ignored, "-Wunused-function");
PW_MODIFY_DIAGNOSTIC_CLANG(ignored, "-Wunneeded-internal-declaration");
 
static inline uint32_t pw_InlineVarLenEntryQueue_Entry_Copy(
    const pw_InlineVarLenEntryQueue_Entry* entry, void* dest, uint32_t count) {
  pw_InlineVarLenEntryQueue_ConstEntry const_entry;
  memcpy(&const_entry, entry, sizeof(const_entry));
  return pw_InlineVarLenEntryQueue_ConstEntry_Copy(&const_entry, dest, count);
}
 
static inline uint8_t pw_InlineVarLenEntryQueue_Entry_At(
    const pw_InlineVarLenEntryQueue_Entry* entry, size_t index);
 
static inline uint8_t pw_InlineVarLenEntryQueue_ConstEntry_At(
    const pw_InlineVarLenEntryQueue_ConstEntry* entry, size_t index);
 
uint32_t pw_InlineVarLenEntryQueue_Size(
    pw_InlineVarLenEntryQueue_ConstHandle queue);
 
static inline uint32_t pw_InlineVarLenEntryQueue_MaxSize(
    pw_InlineVarLenEntryQueue_ConstHandle queue);
 
uint32_t pw_InlineVarLenEntryQueue_SizeBytes(
    pw_InlineVarLenEntryQueue_ConstHandle queue);
 
static inline uint32_t pw_InlineVarLenEntryQueue_MaxSizeBytes(
    pw_InlineVarLenEntryQueue_ConstHandle queue);
 
static inline uint32_t pw_InlineVarLenEntryQueue_RawStorageSizeBytes(
    pw_InlineVarLenEntryQueue_ConstHandle queue);
 
static inline bool pw_InlineVarLenEntryQueue_Empty(
    pw_InlineVarLenEntryQueue_ConstHandle queue);
 
 
 
// Implementation details.
 
#define _PW_VAR_QUEUE_DATA_SIZE_UINT32(max_size_bytes) \
  ((_PW_VAR_QUEUE_DATA_SIZE_BYTES(max_size_bytes) + 3 /* round up */) / 4)
 
#define _PW_VAR_QUEUE_DATA_SIZE_BYTES(max_size_bytes)              \
  (PW_VARINT_ENCODED_SIZE_BYTES(max_size_bytes) + max_size_bytes + \
   1 /*end byte*/)
 
#define _PW_VAR_QUEUE_ARRAY_SIZE_BYTES queue[0]
#define _PW_VAR_QUEUE_HEAD queue[1]
#define _PW_VAR_QUEUE_TAIL queue[2]  // points after the last byte
#define _PW_VAR_QUEUE_DATA ((const uint8_t*)&queue[3])
 
static inline void pw_InlineVarLenEntryQueue_Init(uint32_t array[],
                                                  size_t array_size_uint32) {
  array[0] = (uint32_t)(array_size_uint32 -
                        PW_VARIABLE_LENGTH_ENTRY_QUEUE_HEADER_SIZE_UINT32) *
             sizeof(uint32_t);
  array[1] = 0;  // head
  array[2] = 0;  // tail
}
 
static inline void pw_InlineVarLenEntryQueue_Clear(
    pw_InlineVarLenEntryQueue_Handle queue) {
  _PW_VAR_QUEUE_HEAD = 0;  // head
  _PW_VAR_QUEUE_TAIL = 0;  // tail
}
 
static inline pw_InlineVarLenEntryQueue_Iterator
pw_InlineVarLenEntryQueue_Begin(pw_InlineVarLenEntryQueue_Handle queue) {
  pw_InlineVarLenEntryQueue_Iterator begin = {{queue, _PW_VAR_QUEUE_HEAD}};
  return begin;
}
 
static inline pw_InlineVarLenEntryQueue_ConstIterator
pw_InlineVarLenEntryQueue_ConstBegin(
    pw_InlineVarLenEntryQueue_ConstHandle queue) {
  pw_InlineVarLenEntryQueue_ConstIterator begin = {queue, _PW_VAR_QUEUE_HEAD};
  return begin;
}
 
static inline pw_InlineVarLenEntryQueue_Iterator pw_InlineVarLenEntryQueue_End(
    pw_InlineVarLenEntryQueue_Handle queue) {
  pw_InlineVarLenEntryQueue_Iterator end = {{queue, _PW_VAR_QUEUE_TAIL}};
  return end;
}
 
static inline pw_InlineVarLenEntryQueue_ConstIterator
pw_InlineVarLenEntryQueue_ConstEnd(
    pw_InlineVarLenEntryQueue_ConstHandle queue) {
  pw_InlineVarLenEntryQueue_ConstIterator end = {queue, _PW_VAR_QUEUE_TAIL};
  return end;
}
 
static inline void pw_InlineVarLenEntryQueue_Iterator_Advance(
    pw_InlineVarLenEntryQueue_Iterator* iterator) {
  pw_InlineVarLenEntryQueue_ConstIterator_Advance(&iterator->_iterator);
}
 
static inline bool pw_InlineVarLenEntryQueue_Iterator_Equal(
    const pw_InlineVarLenEntryQueue_Iterator* lhs,
    const pw_InlineVarLenEntryQueue_Iterator* rhs) {
  return pw_InlineVarLenEntryQueue_ConstIterator_Equal(&lhs->_iterator,
                                                       &rhs->_iterator);
}
 
static inline bool pw_InlineVarLenEntryQueue_ConstIterator_Equal(
    const pw_InlineVarLenEntryQueue_ConstIterator* lhs,
    const pw_InlineVarLenEntryQueue_ConstIterator* rhs) {
  return lhs->_pw_offset == rhs->_pw_offset && lhs->_pw_queue == rhs->_pw_queue;
}
 
static inline pw_InlineVarLenEntryQueue_Entry
pw_InlineVarLenEntryQueue_GetEntry(
    const pw_InlineVarLenEntryQueue_Iterator* iterator) {
  pw_InlineVarLenEntryQueue_ConstEntry const_entry =
      pw_InlineVarLenEntryQueue_GetConstEntry(&iterator->_iterator);
  pw_InlineVarLenEntryQueue_Entry entry;
  memcpy(&entry, &const_entry, sizeof(entry));
  return entry;
}
 
// Private function that returns a pointer to the specified index in the entry.
static inline const uint8_t* _pw_InlineVarLenEntryQueue_ConstEntry_GetPointer(
    const pw_InlineVarLenEntryQueue_ConstEntry* entry, size_t index) {
  if (index < entry->size_1) {
    return &entry->data_1[index];
  }
  return &entry->data_2[index - entry->size_1];
}
 
const uint8_t* _pw_InlineVarLenEntryQueue_ConstEntry_GetPointerChecked(
    const pw_InlineVarLenEntryQueue_ConstEntry* entry, size_t index);
 
static inline uint8_t pw_InlineVarLenEntryQueue_Entry_At(
    const pw_InlineVarLenEntryQueue_Entry* entry, size_t index) {
  pw_InlineVarLenEntryQueue_ConstEntry const_entry;
  memcpy(&const_entry, entry, sizeof(const_entry));
  return pw_InlineVarLenEntryQueue_ConstEntry_At(&const_entry, index);
}
 
static inline uint8_t pw_InlineVarLenEntryQueue_ConstEntry_At(
    const pw_InlineVarLenEntryQueue_ConstEntry* entry, size_t index) {
  return *_pw_InlineVarLenEntryQueue_ConstEntry_GetPointerChecked(entry, index);
}
 
static inline uint32_t pw_InlineVarLenEntryQueue_RawStorageSizeBytes(
    pw_InlineVarLenEntryQueue_ConstHandle queue) {
  return PW_VARIABLE_LENGTH_ENTRY_QUEUE_HEADER_SIZE_UINT32 * sizeof(uint32_t) +
         _PW_VAR_QUEUE_ARRAY_SIZE_BYTES;
}
 
static inline uint32_t pw_InlineVarLenEntryQueue_MaxSize(
    pw_InlineVarLenEntryQueue_ConstHandle queue) {
  return _PW_VAR_QUEUE_ARRAY_SIZE_BYTES - 1;
}
 
static inline uint32_t pw_InlineVarLenEntryQueue_MaxSizeBytes(
    pw_InlineVarLenEntryQueue_ConstHandle queue) {
  return _PW_VAR_QUEUE_ARRAY_SIZE_BYTES - 1 -
         (uint32_t)pw_varint_EncodedSizeBytes(_PW_VAR_QUEUE_ARRAY_SIZE_BYTES -
                                              1);
}
 
static inline bool pw_InlineVarLenEntryQueue_Empty(
    pw_InlineVarLenEntryQueue_ConstHandle queue) {
  return _PW_VAR_QUEUE_HEAD == _PW_VAR_QUEUE_TAIL;
}
PW_MODIFY_DIAGNOSTICS_POP();
 
// These macros are not part of the public API, so undefine them.
#undef _PW_VAR_QUEUE_ARRAY_SIZE_BYTES
#undef _PW_VAR_QUEUE_HEAD
#undef _PW_VAR_QUEUE_TAIL
#undef _PW_VAR_QUEUE_DATA
 
#ifdef __cplusplus
}  // extern "C"
 
#include <cstddef>
#include <limits>
#include <type_traits>
#include <utility>
 
#include "pw_containers/internal/raw_storage.h"
#include "pw_span/span.h"
 
namespace pw {
namespace containers::internal {
 
template <typename T>
class VarLenEntryQueueEntry;
 
}  // namespace containers::internal
 
// A`BasicInlineVarLenEntryQueue` with a known maximum size of a single entry.
// The member functions are immplemented in the generic-capacity base.
// TODO: b/303056683 - Add helper for calculating kMaxSizeBytes for N entries of
//     a particular size.
template <typename T,
          size_t kMaxSizeBytes = containers::internal::kGenericSized>
class BasicInlineVarLenEntryQueue
    : public BasicInlineVarLenEntryQueue<T,
                                         containers::internal::kGenericSized> {
 private:
  using Base =
      BasicInlineVarLenEntryQueue<T, containers::internal::kGenericSized>;
 
 public:
  BasicInlineVarLenEntryQueue() : Base(kMaxSizeBytes) {}
 
  // Explicit zero element constexpr constructor. Using this constructor will
  // place the entire object in .data, which will increase ROM size. Use with
  // caution if working with large capacity sizes.
  constexpr BasicInlineVarLenEntryQueue(ConstexprTag)
      : Base(kMaxSizeBytes), data_{} {}
 
  // `BasicInlineVarLenEntryQueue` is trivially copyable.
  BasicInlineVarLenEntryQueue(const BasicInlineVarLenEntryQueue&) = default;
  BasicInlineVarLenEntryQueue& operator=(const BasicInlineVarLenEntryQueue&) =
      default;
 
 private:
  static_assert(kMaxSizeBytes <=
                std::numeric_limits<typename Base::size_type>::max());
 
  using Base::Init;  // Disallow Init since the size template param is not used.
 
  uint32_t data_[_PW_VAR_QUEUE_DATA_SIZE_UINT32(kMaxSizeBytes)];
};
 
 
 
 
template <typename T>
class BasicInlineVarLenEntryQueue<T, containers::internal::kGenericSized> {
 public:
  using value_type = containers::internal::VarLenEntryQueueEntry<T>;
  using const_value_type = containers::internal::VarLenEntryQueueEntry<const T>;
  using size_type = std::uint32_t;
  using pointer = const value_type*;
  using const_pointer = pointer;
  using reference = const value_type&;
  using const_reference = reference;
 
  class iterator;
 
  class const_iterator;
 
  template <size_t kArraySize>
  static BasicInlineVarLenEntryQueue& Init(uint32_t (&array)[kArraySize]) {
    static_assert(
        kArraySize > PW_VARIABLE_LENGTH_ENTRY_QUEUE_HEADER_SIZE_UINT32,
        "InlineVarLenEntryQueue must be backed by an array with more than "
        "PW_VARIABLE_LENGTH_ENTRY_QUEUE_HEADER_SIZE_UINT32 (3) elements");
    return Init(array, kArraySize);
  }
 
  static BasicInlineVarLenEntryQueue& Init(uint32_t array[],
                                           size_t array_size_uint32) {
    pw_InlineVarLenEntryQueue_Init(array, array_size_uint32);
    return *std::launder(reinterpret_cast<BasicInlineVarLenEntryQueue*>(array));
  }
 
  value_type front() { return *begin(); }
 
  const_value_type front() const { return *cbegin(); }
 
  iterator begin() {
    return iterator(pw_InlineVarLenEntryQueue_ConstBegin(array_));
  }
  const_iterator begin() const {
    return const_iterator(pw_InlineVarLenEntryQueue_ConstBegin(array_));
  }
  const_iterator cbegin() const { return begin(); }
 
  iterator end() {
    return iterator(pw_InlineVarLenEntryQueue_ConstEnd(array_));
  }
  const_iterator end() const {
    return const_iterator(pw_InlineVarLenEntryQueue_ConstEnd(array_));
  }
  const_iterator cend() const { return end(); }
 
  [[nodiscard]] bool empty() const {
    return pw_InlineVarLenEntryQueue_Empty(array_);
  }
 
  size_type size() const { return pw_InlineVarLenEntryQueue_Size(array_); }
 
  size_type max_size() const {
    return pw_InlineVarLenEntryQueue_MaxSize(array_);
  }
 
  size_type size_bytes() const {
    return pw_InlineVarLenEntryQueue_SizeBytes(array_);
  }
 
  size_type max_size_bytes() const {
    return pw_InlineVarLenEntryQueue_MaxSizeBytes(array_);
  }
 
  span<const T> raw_storage() const {
    return span<const T>(reinterpret_cast<const T*>(array_),
                         pw_InlineVarLenEntryQueue_RawStorageSizeBytes(array_));
  }
 
  void clear() { pw_InlineVarLenEntryQueue_Clear(array_); }
 
  void push(span<const T> value) {
    pw_InlineVarLenEntryQueue_Push(
        array_, value.data(), static_cast<size_type>(value.size()));
  }
 
  [[nodiscard]] bool try_push(span<const T> value) {
    return pw_InlineVarLenEntryQueue_TryPush(
        array_, value.data(), static_cast<size_type>(value.size()));
  }
 
  void push_overwrite(span<const T> value) {
    pw_InlineVarLenEntryQueue_PushOverwrite(
        array_, value.data(), static_cast<size_type>(value.size()));
  }
 
  void pop() { pw_InlineVarLenEntryQueue_Pop(array_); }
 
 protected:
  constexpr BasicInlineVarLenEntryQueue(uint32_t max_size_bytes)
      : array_{_PW_VAR_QUEUE_DATA_SIZE_BYTES(max_size_bytes), 0, 0} {}
 
  // Polymorphic-sized queues cannot be destroyed directly due to the lack of a
  // virtual destructor.
  ~BasicInlineVarLenEntryQueue() = default;
 
  BasicInlineVarLenEntryQueue(const BasicInlineVarLenEntryQueue&) = default;
  BasicInlineVarLenEntryQueue& operator=(const BasicInlineVarLenEntryQueue&) =
      default;
 
 private:
  static_assert(std::is_integral_v<T> || std::is_same_v<T, std::byte>);
  static_assert(sizeof(T) == sizeof(std::byte));
 
  uint32_t array_[PW_VARIABLE_LENGTH_ENTRY_QUEUE_HEADER_SIZE_UINT32];
};
 
namespace containers::internal {
 
template <typename T>
class VarLenEntryQueueEntryIterator {
 public:
  using difference_type = std::ptrdiff_t;
  using value_type = std::remove_cv_t<T>;
  using pointer = T*;
  using reference = T&;
  using iterator_category = std::forward_iterator_tag;
 
  constexpr VarLenEntryQueueEntryIterator() : entry_(nullptr), index_(0) {}
 
  constexpr VarLenEntryQueueEntryIterator(
      const VarLenEntryQueueEntryIterator&) = default;
  constexpr VarLenEntryQueueEntryIterator& operator=(
      const VarLenEntryQueueEntryIterator&) = default;
 
  constexpr VarLenEntryQueueEntryIterator& operator++() {
    index_ += 1;
    return *this;
  }
  constexpr VarLenEntryQueueEntryIterator operator++(int) {
    VarLenEntryQueueEntryIterator previous_value(*this);
    operator++();
    return previous_value;
  }
 
  constexpr VarLenEntryQueueEntryIterator& operator+=(difference_type n) {
    index_ += static_cast<size_t>(n);
    return *this;
  }
 
  reference operator*() const { return const_cast<reference>(*operator->()); }
 
  pointer operator->() const {
    return const_cast<pointer>(reinterpret_cast<const T*>(
        _pw_InlineVarLenEntryQueue_ConstEntry_GetPointer(entry_, index_)));
  }
 
  friend VarLenEntryQueueEntryIterator operator+(
      const VarLenEntryQueueEntryIterator& it, difference_type n) {
    return VarLenEntryQueueEntryIterator(*it.entry_,
                                         it.index_ + static_cast<size_t>(n));
  }
 
  friend VarLenEntryQueueEntryIterator operator+(
      difference_type n, const VarLenEntryQueueEntryIterator& it) {
    return VarLenEntryQueueEntryIterator(*it.entry_,
                                         it.index_ + static_cast<size_t>(n));
  }
 
  friend bool operator==(const VarLenEntryQueueEntryIterator& lhs,
                         const VarLenEntryQueueEntryIterator& rhs) {
    return lhs.entry_->data_1 == rhs.entry_->data_1 && lhs.index_ == rhs.index_;
  }
  friend bool operator!=(const VarLenEntryQueueEntryIterator& lhs,
                         const VarLenEntryQueueEntryIterator& rhs) {
    return !(lhs == rhs);
  }
 
 private:
  template <typename U>
  friend class VarLenEntryQueueEntry;
 
  constexpr VarLenEntryQueueEntryIterator(
      const pw_InlineVarLenEntryQueue_ConstEntry& entry, size_t index)
      : entry_(&entry), index_(index) {}
 
  const pw_InlineVarLenEntryQueue_ConstEntry* entry_;
  size_t index_;
};
 
template <typename T>
class VarLenEntryQueueEntry {
 public:
  using element_type = T;
  using value_type = std::remove_cv_t<T>;
  using size_type = std::uint32_t;
  using pointer = T*;
  using const_pointer = const T*;
  using reference = T&;
  using const_reference = const T&;
 
  using iterator = VarLenEntryQueueEntryIterator<T>;
  using const_iterator = VarLenEntryQueueEntryIterator<const T>;
 
  constexpr VarLenEntryQueueEntry(const VarLenEntryQueueEntry&) = default;
  constexpr VarLenEntryQueueEntry& operator=(const VarLenEntryQueueEntry&) =
      default;
 
  constexpr operator VarLenEntryQueueEntry<const T>() const {
    return VarLenEntryQueueEntry<const T>(entry_);
  }
 
  reference at(size_t index) const {
    return const_cast<reference>(*reinterpret_cast<const_pointer>(
        _pw_InlineVarLenEntryQueue_ConstEntry_GetPointerChecked(&entry_,
                                                                index)));
  }
 
  reference operator[](size_t index) const {
    return const_cast<reference>(*reinterpret_cast<const_pointer>(
        _pw_InlineVarLenEntryQueue_ConstEntry_GetPointer(&entry_, index)));
  }
 
  reference front() const {
    return const_cast<reference>(
        reinterpret_cast<const_reference>(*entry_.data_1));
  }
  reference back() const { return operator[](size() - 1); }
 
  std::pair<span<element_type>, span<element_type>> contiguous_data() const {
    return std::make_pair(
        span(
            const_cast<pointer>(reinterpret_cast<const_pointer>(entry_.data_1)),
            entry_.size_1),
        span(
            const_cast<pointer>(reinterpret_cast<const_pointer>(entry_.data_2)),
            entry_.size_2));
  }
 
  size_type copy(value_type* dest, size_type count) const {
    return pw_InlineVarLenEntryQueue_ConstEntry_Copy(&entry_, dest, count);
  }
 
  iterator begin() const { return iterator(entry_, 0); }
  const_iterator cbegin() const { return const_iterator(entry_, 0); }
 
  iterator end() const { return iterator(entry_, size()); }
  const_iterator cend() const { return const_iterator(entry_, size()); }
 
  [[nodiscard]] bool empty() const { return size() == 0; }
 
  size_type size() const { return entry_.size_1 + entry_.size_2; }
 
 private:
  friend class VarLenEntryQueueEntry<std::remove_const_t<T>>;
  friend class BasicInlineVarLenEntryQueue;
  friend class BasicInlineVarLenEntryQueue<std::remove_const_t<T>>::iterator;
  friend class BasicInlineVarLenEntryQueue<
      std::remove_const_t<T>>::const_iterator;
 
  explicit constexpr VarLenEntryQueueEntry(
      const pw_InlineVarLenEntryQueue_ConstEntry& entry)
      : entry_(entry) {}
 
  constexpr VarLenEntryQueueEntry() : entry_{} {}
 
  pw_InlineVarLenEntryQueue_ConstEntry entry_;
};
 
}  // namespace containers::internal
 
template <typename T>
class BasicInlineVarLenEntryQueue<T>::const_iterator {
 public:
  using difference_type = std::ptrdiff_t;
  using value_type = BasicInlineVarLenEntryQueue<T>::const_value_type;
  using pointer = const value_type*;
  using reference = const value_type&;
  using iterator_category = std::forward_iterator_tag;
 
  constexpr const_iterator() : iterator_{}, entry_{} {}
 
  constexpr const_iterator(const const_iterator&) = default;
  constexpr const_iterator& operator=(const const_iterator&) = default;
 
  const_iterator& operator++() {
    pw_InlineVarLenEntryQueue_ConstIterator_Advance(&iterator_);
    entry_.entry_.data_1 = nullptr;  // mark the entry as unloaded
    return *this;
  }
  const_iterator operator++(int) {
    const_iterator previous_value(*this);
    operator++();
    return previous_value;
  }
 
  reference operator*() const {
    LoadEntry();
    return entry_;
  }
  pointer operator->() const {
    LoadEntry();
    return &entry_;
  }
 
  bool operator==(const const_iterator& rhs) const {
    return pw_InlineVarLenEntryQueue_ConstIterator_Equal(&iterator_,
                                                         &rhs.iterator_);
  }
  bool operator!=(const const_iterator& rhs) const { return !(*this == rhs); }
 
 private:
  friend class BasicInlineVarLenEntryQueue;
 
  explicit constexpr const_iterator(
      const pw_InlineVarLenEntryQueue_ConstIterator& it)
      : iterator_(it) {}
 
  void LoadEntry() const {
    if (entry_.entry_.data_1 == nullptr) {
      entry_.entry_ = pw_InlineVarLenEntryQueue_GetConstEntry(&iterator_);
    }
  }
 
  pw_InlineVarLenEntryQueue_ConstIterator iterator_;
  mutable value_type entry_;
};
 
template <typename T>
class BasicInlineVarLenEntryQueue<T>::iterator {
 public:
  using difference_type = std::ptrdiff_t;
  using value_type = BasicInlineVarLenEntryQueue<T>::value_type;
  using pointer = const value_type*;
  using reference = const value_type&;
  using iterator_category = std::forward_iterator_tag;
 
  constexpr iterator() : iterator_{}, entry_{} {}
 
  constexpr iterator(const iterator&) = default;
  constexpr iterator& operator=(const iterator&) = default;
 
  iterator& operator++() {
    pw_InlineVarLenEntryQueue_ConstIterator_Advance(&iterator_);
    entry_.entry_.data_1 = nullptr;  // mark the entry as unloaded
    return *this;
  }
  iterator operator++(int) {
    iterator previous_value(*this);
    operator++();
    return previous_value;
  }
 
  reference operator*() const {
    LoadEntry();
    return entry_;
  }
  pointer operator->() const {
    LoadEntry();
    return &entry_;
  }
 
  bool operator==(const iterator& rhs) const {
    return pw_InlineVarLenEntryQueue_ConstIterator_Equal(&iterator_,
                                                         &rhs.iterator_);
  }
  bool operator!=(const iterator& rhs) const { return !(*this == rhs); }
 
 private:
  friend class BasicInlineVarLenEntryQueue;
 
  explicit constexpr iterator(const pw_InlineVarLenEntryQueue_ConstIterator& it)
      : iterator_(it) {}
 
  void LoadEntry() const {
    if (entry_.entry_.data_1 == nullptr) {
      entry_.entry_ = pw_InlineVarLenEntryQueue_GetConstEntry(&iterator_);
    }
  }
 
  pw_InlineVarLenEntryQueue_ConstIterator iterator_;
  mutable value_type entry_;
};
 
template <size_t kMaxSizeBytes = containers::internal::kGenericSized>
using InlineVarLenEntryQueue =
    BasicInlineVarLenEntryQueue<std::byte, kMaxSizeBytes>;
 
 
 
}  // namespace pw
 
#endif  // __cplusplus