pw_containers: Rename to VariableLengthEntryQueue
- Rename VariableLengthEntryDeque to VariableLengthEntryQueue.
Double-ended operations (pop_back(), push_front()) are inefficient in
this design, so won't be implemented.
- Rename PushBack() to Push(), PopFront() to Pop() to match
pw::InlineQueue / std::queue style.
Change-Id: Ic7693cb129a1e653d16aaa6b582335bf49112d7d
Reviewed-on: https://pigweed-review.googlesource.com/c/pigweed/pigweed/+/173451
Reviewed-by: Carlos Chinchilla <cachinchilla@google.com>
Pigweed-Auto-Submit: Wyatt Hepler <hepler@google.com>
Commit-Queue: Auto-Submit <auto-submit@pigweed-service-accounts.iam.gserviceaccount.com>
diff --git a/pw_containers/docs.rst b/pw_containers/docs.rst
index 382c188..4881835 100644
--- a/pw_containers/docs.rst
+++ b/pw_containers/docs.rst
@@ -30,7 +30,7 @@
.. doxygentypedef:: pw::InlineQueue
----------------------------
-pw::VariableLengthEntryDeque
+pw::VariableLengthEntryQueue
----------------------------
.. doxygenfile:: pw_containers/variable_length_entry_queue.h
:sections: detaileddescription
diff --git a/pw_containers/public/pw_containers/variable_length_entry_queue.h b/pw_containers/public/pw_containers/variable_length_entry_queue.h
index cfb5697..f07b728 100644
--- a/pw_containers/public/pw_containers/variable_length_entry_queue.h
+++ b/pw_containers/public/pw_containers/variable_length_entry_queue.h
@@ -22,18 +22,18 @@
/// @file pw_containers/variable_length_entry_queue.h
///
-/// A `VariableLengthEntryDeque` is a double-ended queue of variable-length
+/// A `VariableLengthEntryQueue` is a ended queue of inline variable-length
/// binary entries. It is implemented as a ring (circular) buffer and supports
/// operations to append entries and overwrite if necessary. Entries may be zero
-/// bytes up to the maximum size supported by the deque.
+/// bytes up to the maximum size supported by the queue.
///
-/// The `VariableLengthEntryDeque` a few interesting properties.
+/// The `VariableLengthEntryQueue` has a few interesting properties.
///
/// - Data and metadata are stored inline in a contiguous block of
/// `uint32_t`-aligned memory.
-/// - All data structure state changes are accomplished with a single update to
-/// a `uint32_t`. The memory is always in a valid state and may be parsed
-/// offline.
+/// - The data structure is trivially copyable.
+/// - All state changes are accomplished with a single update to a `uint32_t`.
+/// The memory is always in a valid state and may be parsed offline.
///
/// This data structure is a much simpler version of
/// @cpp_class{pw::ring_buffer::PrefixedEntryRingBuffer}. Prefer this
@@ -45,40 +45,40 @@
/// - A consistent, parsable, in-memory representation is required (e.g. to
/// decode the buffer from a block of memory).
///
-/// A `VariableLengthEntryDeque` may be declared and initialized in C with the
-/// @c_macro{PW_VARIABLE_LENGTH_ENTRY_DEQUE_DECLARE} macro.
+/// A `VariableLengthEntryQueue` may be declared and initialized in C with the
+/// @c_macro{PW_VARIABLE_LENGTH_ENTRY_QUEUE_DECLARE} macro.
///
/// @code{c}
///
-/// // Declares a deque with a maximum entry size of 10 bytes.
-/// PW_VARIABLE_LENGTH_ENTRY_DEQUE_DECLARE(deque, 10);
+/// // Declares a queue with a maximum single entry size of 10 bytes.
+/// PW_VARIABLE_LENGTH_ENTRY_QUEUE_DECLARE(queue, 10);
///
/// // Write some data
-/// pw_VariableLengthEntryDeque_PushBackOverwrite(deque, "123", 3);
-/// pw_VariableLengthEntryDeque_PushBackOverwrite(deque, "456", 3);
+/// pw_VariableLengthEntryQueue_PushOverwrite(queue, "123", 3);
+/// pw_VariableLengthEntryQueue_PushOverwrite(queue, "456", 3);
///
-/// assert(pw_VariableLengthEntryDeque_Size(deque) == 2u);
+/// assert(pw_VariableLengthEntryQueue_Size(queue) == 2u);
///
/// // Remove the entries
-/// pw_VariableLengthEntryDeque_PopFront(deque);
-/// pw_VariableLengthEntryDeque_PopFront(deque);
+/// pw_VariableLengthEntryQueue_Pop(queue);
+/// pw_VariableLengthEntryQueue_Pop(queue);
///
/// @endcode
///
-/// Alternately, a `VariableLengthEntryDeque` may also be initialized in an
+/// Alternately, a `VariableLengthEntryQueue` may also be initialized in an
/// existing ``uint32_t`` array.
///
/// @code{c}
///
-/// // Initialize a VariableLengthEntryDeque.
+/// // Initialize a VariableLengthEntryQueue.
/// uint32_t buffer[32];
-/// pw_VariableLengthEntryDeque_Init(buffer, 32);
+/// pw_VariableLengthEntryQueue_Init(buffer, 32);
///
/// // Largest supported entry works out to 114 B (13 B overhead + 1 B prefix)
-/// assert(pw_VariableLengthEntryDeque_MaxEntrySizeBytes(buffer) == 114u);
+/// assert(pw_VariableLengthEntryQueue_MaxEntrySizeBytes(buffer) == 114u);
///
/// // Write some data
-/// pw_VariableLengthEntryDeque_PushBackOverwrite(buffer, "123", 3);
+/// pw_VariableLengthEntryQueue_PushOverwrite(buffer, "123", 3);
///
/// @endcode
@@ -86,105 +86,103 @@
extern "C" {
#endif // __cplusplus
-/// @defgroup variable_length_entry_queue_c_api VariableLengthEntryDeque C API
+/// @defgroup variable_length_entry_queue_c_api VariableLengthEntryQueue C API
/// @{
-/// Handle that refers to a `VariableLengthEntryDeque`. In memory, the deque
+/// Handle that refers to a `VariableLengthEntryQueue`. In memory, the queue
/// is a `uint32_t` array.
-typedef uint32_t* pw_VariableLengthEntryDeque_Handle;
-typedef const uint32_t* pw_VariableLengthEntryDeque_ConstHandle;
+typedef uint32_t* pw_VariableLengthEntryQueue_Handle;
+typedef const uint32_t* pw_VariableLengthEntryQueue_ConstHandle;
-/// Declares and initializes a `VariableLengthEntryDeque` that can hold an entry
+/// Declares and initializes a `VariableLengthEntryQueue` that can hold an entry
/// of up to `max_entry_size_bytes`. Attempting to store larger entries is
/// invalid and will fail an assertion.
-#define PW_VARIABLE_LENGTH_ENTRY_DEQUE_DECLARE(variable, max_entry_size_bytes) \
- uint32_t variable[PW_VARIABLE_LENGTH_ENTRY_DEQUE_HEADER_SIZE_UINT32 + \
- _PW_VAR_DEQUE_DATA_SIZE_UINT32(max_entry_size_bytes)] = { \
- _PW_VAR_DEQUE_DATA_SIZE_BYTES(max_entry_size_bytes), \
+#define PW_VARIABLE_LENGTH_ENTRY_QUEUE_DECLARE(variable, max_entry_size_bytes) \
+ uint32_t variable[PW_VARIABLE_LENGTH_ENTRY_QUEUE_HEADER_SIZE_UINT32 + \
+ _PW_VAR_QUEUE_DATA_SIZE_UINT32(max_entry_size_bytes)] = { \
+ _PW_VAR_QUEUE_DATA_SIZE_BYTES(max_entry_size_bytes), \
/*head=*/0u, \
/*tail=*/0u}
-/// The size of the `VariableLengthEntryDeque` header, in `uint32_t` elements.
+/// The size of the `VariableLengthEntryQueue` header, in `uint32_t` elements.
/// This header stores the buffer length and head and tail offsets.
///
-/// The underlying `uint32_t` array of a `VariableLengthEntryDeque` must be
+/// The underlying `uint32_t` array of a `VariableLengthEntryQueue` must be
/// larger than this size.
-#define PW_VARIABLE_LENGTH_ENTRY_DEQUE_HEADER_SIZE_UINT32 (3)
+#define PW_VARIABLE_LENGTH_ENTRY_QUEUE_HEADER_SIZE_UINT32 (3)
-/// Initializes a `VariableLengthEntryDeque` in place in a `uint32_t` array. The
+/// Initializes a `VariableLengthEntryQueue` in place in a `uint32_t` array. The
/// array MUST be larger than
-/// @c_macro{PW_VARIABLE_LENGTH_ENTRY_DEQUE_HEADER_SIZE_UINT32} (3) elements.
-static inline void pw_VariableLengthEntryDeque_Init(uint32_t array[],
+/// @c_macro{PW_VARIABLE_LENGTH_ENTRY_QUEUE_HEADER_SIZE_UINT32} (3) elements.
+static inline void pw_VariableLengthEntryQueue_Init(uint32_t array[],
size_t array_size_uint32);
-/// Appends an entry to the end of the deque.
+/// Appends an entry to the end of the queue.
///
/// @pre The entry MUST not be larger than
-/// @cpp_func{pw_VariableLengthEntryDeque_MaxEntrySizeBytes}; asserts if it is.
-void pw_VariableLengthEntryDeque_PushBack(
- pw_VariableLengthEntryDeque_Handle deque,
- const void* data,
- uint32_t data_size_bytes);
+/// @cpp_func{pw_VariableLengthEntryQueue_MaxEntrySizeBytes}; asserts if it is.
+void pw_VariableLengthEntryQueue_Push(pw_VariableLengthEntryQueue_Handle queue,
+ const void* data,
+ uint32_t data_size_bytes);
-/// Appends an entry to the end of the deque, removing entries with `PopFront`
+/// Appends an entry to the end of the queue, removing entries with `Pop`
/// as necessary to make room.
///
/// @pre The entry MUST not be larger than
-/// @cpp_func{pw_VariableLengthEntryDeque_MaxEntrySizeBytes}; asserts if it is.
-void pw_VariableLengthEntryDeque_PushBackOverwrite(
- pw_VariableLengthEntryDeque_Handle deque,
+/// @cpp_func{pw_VariableLengthEntryQueue_MaxEntrySizeBytes}; asserts if it is.
+void pw_VariableLengthEntryQueue_PushOverwrite(
+ pw_VariableLengthEntryQueue_Handle queue,
const void* data,
uint32_t data_size_bytes);
/// Removes the first entry from the ring buffer.
///
-/// @pre The deque MUST have at least one entry.
-void pw_VariableLengthEntryDeque_PopFront(
- pw_VariableLengthEntryDeque_Handle deque);
+/// @pre The queue MUST have at least one entry.
+void pw_VariableLengthEntryQueue_Pop(pw_VariableLengthEntryQueue_Handle queue);
-/// Iterator object for a `VariableLengthEntryDeque`. Iterators are checked for
+/// Iterator object for a `VariableLengthEntryQueue`. Iterators are checked for
/// equality with
-/// @cpp_func{pw_VariableLengthEntryDeque_Iterator_Equal}.
+/// @cpp_func{pw_VariableLengthEntryQueue_Iterator_Equal}.
///
/// Iterators are invalidated by any operations that change the container or
/// its underlying data (push/pop/init).
typedef struct {
// Private: do not access these fields directly!
- pw_VariableLengthEntryDeque_ConstHandle _pw_deque;
+ pw_VariableLengthEntryQueue_ConstHandle _pw_queue;
uint32_t _pw_offset;
-} pw_VariableLengthEntryDeque_Iterator;
+} pw_VariableLengthEntryQueue_Iterator;
-// An entry in the deque. Entries may be stored in up to two segments, so this
+// An entry in the queue. Entries may be stored in up to two segments, so this
// struct includes pointers to both portions of the entry.
typedef struct {
const uint8_t* data_1;
uint32_t size_1;
const uint8_t* data_2;
uint32_t size_2;
-} pw_VariableLengthEntryDeque_Entry;
+} pw_VariableLengthEntryQueue_Entry;
-/// Returns an iterator to the start of the `VariableLengthEntryDeque`.
-static inline pw_VariableLengthEntryDeque_Iterator
-pw_VariableLengthEntryDeque_Begin(
- pw_VariableLengthEntryDeque_ConstHandle deque);
+/// Returns an iterator to the start of the `VariableLengthEntryQueue`.
+static inline pw_VariableLengthEntryQueue_Iterator
+pw_VariableLengthEntryQueue_Begin(
+ pw_VariableLengthEntryQueue_ConstHandle queue);
/// Returns an iterator to entry following the last entry, which is not valid.
-static inline pw_VariableLengthEntryDeque_Iterator
-pw_VariableLengthEntryDeque_End(pw_VariableLengthEntryDeque_ConstHandle deque);
+static inline pw_VariableLengthEntryQueue_Iterator
+pw_VariableLengthEntryQueue_End(pw_VariableLengthEntryQueue_ConstHandle queue);
-/// Advances an iterator to point to the next entry in the deque. It is
+/// Advances an iterator to point to the next entry in the queue. It is
/// invalid to call `Advance` on an iterator equal to the `End` iterator.
-void pw_VariableLengthEntryDeque_Iterator_Advance(
- pw_VariableLengthEntryDeque_Iterator* iterator);
+void pw_VariableLengthEntryQueue_Iterator_Advance(
+ pw_VariableLengthEntryQueue_Iterator* iterator);
/// Compares two iterators for equality.
-static inline bool pw_VariableLengthEntryDeque_Iterator_Equal(
- const pw_VariableLengthEntryDeque_Iterator* lhs,
- const pw_VariableLengthEntryDeque_Iterator* rhs);
+static inline bool pw_VariableLengthEntryQueue_Iterator_Equal(
+ const pw_VariableLengthEntryQueue_Iterator* lhs,
+ const pw_VariableLengthEntryQueue_Iterator* rhs);
/// Dereferences an iterator, loading the entry it points to.
-pw_VariableLengthEntryDeque_Entry pw_VariableLengthEntryDeque_GetEntry(
- const pw_VariableLengthEntryDeque_Iterator* iterator);
+pw_VariableLengthEntryQueue_Entry pw_VariableLengthEntryQueue_GetEntry(
+ const pw_VariableLengthEntryQueue_Iterator* iterator);
/// Copies the contents of the entry to the provided buffer. The entry may be
/// split into two regions; this serializes it into one buffer.
@@ -193,126 +191,126 @@
/// @param dest The buffer into which to copy the serialized entry
/// @param count Copy up to this many bytes; must not be larger than the `dest`
/// buffer, but may be larger than the entry
-uint32_t pw_VariableLengthEntryDeque_Entry_Copy(
- const pw_VariableLengthEntryDeque_Entry* entry, void* dest, uint32_t count);
+uint32_t pw_VariableLengthEntryQueue_Entry_Copy(
+ const pw_VariableLengthEntryQueue_Entry* entry, void* dest, uint32_t count);
-/// Returns the number of variable-length entries in the deque. This is O(n) in
-/// the number of entries in the deque.
-uint32_t pw_VariableLengthEntryDeque_Size(
- pw_VariableLengthEntryDeque_ConstHandle deque);
+/// Returns the number of variable-length entries in the queue. This is O(n) in
+/// the number of entries in the queue.
+uint32_t pw_VariableLengthEntryQueue_Size(
+ pw_VariableLengthEntryQueue_ConstHandle queue);
/// Returns the number of bytes stored in the buffer, including entry metadata.
/// This can be used with `RawCapacityBytes` to gauge available space for
/// entries.
-static inline uint32_t pw_VariableLengthEntryDeque_RawSizeBytes(
- pw_VariableLengthEntryDeque_ConstHandle deque);
+static inline uint32_t pw_VariableLengthEntryQueue_RawSizeBytes(
+ pw_VariableLengthEntryQueue_ConstHandle queue);
/// Returns the maximum number of bytes that can be stored in the buffer,
/// including per-entry metadata. This can be used with `RawSizeBytes` to gauge
/// available space for entries.
-static inline uint32_t pw_VariableLengthEntryDeque_RawCapacityBytes(
- pw_VariableLengthEntryDeque_ConstHandle deque);
+static inline uint32_t pw_VariableLengthEntryQueue_RawCapacityBytes(
+ pw_VariableLengthEntryQueue_ConstHandle queue);
-/// Returns the size of the raw underlying `VariableLengthEntryDeque` storage.
-/// This size may be used to copy a `VariableLengthEntryDeque` into another
+/// Returns the size of the raw underlying `VariableLengthEntryQueue` storage.
+/// This size may be used to copy a `VariableLengthEntryQueue` into another
/// 32-bit aligned memory location.
-static inline uint32_t pw_VariableLengthEntryDeque_RawStorageSizeBytes(
- pw_VariableLengthEntryDeque_ConstHandle deque);
+static inline uint32_t pw_VariableLengthEntryQueue_RawStorageSizeBytes(
+ pw_VariableLengthEntryQueue_ConstHandle queue);
-/// Returns the size of the largest entry this `VariableLengthEntryDeque` can
+/// Returns the size of the largest entry this `VariableLengthEntryQueue` can
/// hold. Attempting to store a larger entry is invalid and fails an assert.
-static inline uint32_t pw_VariableLengthEntryDeque_MaxEntrySizeBytes(
- pw_VariableLengthEntryDeque_ConstHandle deque);
+static inline uint32_t pw_VariableLengthEntryQueue_MaxEntrySizeBytes(
+ pw_VariableLengthEntryQueue_ConstHandle queue);
-/// Returns true if the `VariableLengthEntryDeque` is empty, false if it has at
+/// Returns true if the `VariableLengthEntryQueue` is empty, false if it has at
/// least one entry.
-static inline bool pw_VariableLengthEntryDeque_Empty(
- pw_VariableLengthEntryDeque_ConstHandle deque);
+static inline bool pw_VariableLengthEntryQueue_Empty(
+ pw_VariableLengthEntryQueue_ConstHandle queue);
/// @}
// Implementation details.
-#define _PW_VAR_DEQUE_DATA_SIZE_UINT32(max_entry_size_bytes) \
- ((_PW_VAR_DEQUE_DATA_SIZE_BYTES(max_entry_size_bytes) + 3 /* round up */) / 4)
+#define _PW_VAR_QUEUE_DATA_SIZE_UINT32(max_entry_size_bytes) \
+ ((_PW_VAR_QUEUE_DATA_SIZE_BYTES(max_entry_size_bytes) + 3 /* round up */) / 4)
-#define _PW_VAR_DEQUE_DATA_SIZE_BYTES(max_entry_size_bytes) \
+#define _PW_VAR_QUEUE_DATA_SIZE_BYTES(max_entry_size_bytes) \
(PW_VARINT_ENCODED_SIZE_BYTES(max_entry_size_bytes) + max_entry_size_bytes + \
1 /*end byte*/)
-#define _PW_VAR_DEQUE_ARRAY_SIZE_BYTES deque[0]
-#define _PW_VAR_DEQUE_HEAD deque[1]
-#define _PW_VAR_DEQUE_TAIL deque[2] // points after the last byte
-#define _PW_VAR_DEQUE_DATA ((const uint8_t*)&deque[3])
+#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])
-#define _PW_VAR_DEQUE_GET_ARRAY_SIZE_BYTES(array_size_uint32) \
+#define _PW_VAR_QUEUE_GET_ARRAY_SIZE_BYTES(array_size_uint32) \
(uint32_t)(array_size_uint32 - \
- PW_VARIABLE_LENGTH_ENTRY_DEQUE_HEADER_SIZE_UINT32) * \
+ PW_VARIABLE_LENGTH_ENTRY_QUEUE_HEADER_SIZE_UINT32) * \
sizeof(uint32_t)
-static inline void pw_VariableLengthEntryDeque_Init(uint32_t array[],
+static inline void pw_VariableLengthEntryQueue_Init(uint32_t array[],
size_t array_size_uint32) {
- array[0] = _PW_VAR_DEQUE_GET_ARRAY_SIZE_BYTES(array_size_uint32);
+ array[0] = _PW_VAR_QUEUE_GET_ARRAY_SIZE_BYTES(array_size_uint32);
array[1] = 0; // head
array[2] = 0; // tail
}
-static inline pw_VariableLengthEntryDeque_Iterator
-pw_VariableLengthEntryDeque_Begin(
- pw_VariableLengthEntryDeque_ConstHandle deque) {
- pw_VariableLengthEntryDeque_Iterator begin = {deque, _PW_VAR_DEQUE_HEAD};
+static inline pw_VariableLengthEntryQueue_Iterator
+pw_VariableLengthEntryQueue_Begin(
+ pw_VariableLengthEntryQueue_ConstHandle queue) {
+ pw_VariableLengthEntryQueue_Iterator begin = {queue, _PW_VAR_QUEUE_HEAD};
return begin;
}
-static inline pw_VariableLengthEntryDeque_Iterator
-pw_VariableLengthEntryDeque_End(pw_VariableLengthEntryDeque_ConstHandle deque) {
- pw_VariableLengthEntryDeque_Iterator end = {deque, _PW_VAR_DEQUE_TAIL};
+static inline pw_VariableLengthEntryQueue_Iterator
+pw_VariableLengthEntryQueue_End(pw_VariableLengthEntryQueue_ConstHandle queue) {
+ pw_VariableLengthEntryQueue_Iterator end = {queue, _PW_VAR_QUEUE_TAIL};
return end;
}
-static inline bool pw_VariableLengthEntryDeque_Iterator_Equal(
- const pw_VariableLengthEntryDeque_Iterator* lhs,
- const pw_VariableLengthEntryDeque_Iterator* rhs) {
- return lhs->_pw_offset == rhs->_pw_offset && lhs->_pw_deque == rhs->_pw_deque;
+static inline bool pw_VariableLengthEntryQueue_Iterator_Equal(
+ const pw_VariableLengthEntryQueue_Iterator* lhs,
+ const pw_VariableLengthEntryQueue_Iterator* rhs) {
+ return lhs->_pw_offset == rhs->_pw_offset && lhs->_pw_queue == rhs->_pw_queue;
}
-static inline uint32_t pw_VariableLengthEntryDeque_RawSizeBytes(
- pw_VariableLengthEntryDeque_ConstHandle deque) {
- uint32_t tail = _PW_VAR_DEQUE_TAIL;
- if (tail < _PW_VAR_DEQUE_HEAD) {
- tail += _PW_VAR_DEQUE_ARRAY_SIZE_BYTES;
+static inline uint32_t pw_VariableLengthEntryQueue_RawSizeBytes(
+ pw_VariableLengthEntryQueue_ConstHandle queue) {
+ uint32_t tail = _PW_VAR_QUEUE_TAIL;
+ if (tail < _PW_VAR_QUEUE_HEAD) {
+ tail += _PW_VAR_QUEUE_ARRAY_SIZE_BYTES;
}
- return tail - _PW_VAR_DEQUE_HEAD;
+ return tail - _PW_VAR_QUEUE_HEAD;
}
-static inline uint32_t pw_VariableLengthEntryDeque_RawCapacityBytes(
- pw_VariableLengthEntryDeque_ConstHandle deque) {
- return _PW_VAR_DEQUE_ARRAY_SIZE_BYTES - 1;
+static inline uint32_t pw_VariableLengthEntryQueue_RawCapacityBytes(
+ pw_VariableLengthEntryQueue_ConstHandle queue) {
+ return _PW_VAR_QUEUE_ARRAY_SIZE_BYTES - 1;
}
-static inline uint32_t pw_VariableLengthEntryDeque_RawStorageSizeBytes(
- pw_VariableLengthEntryDeque_ConstHandle deque) {
- return PW_VARIABLE_LENGTH_ENTRY_DEQUE_HEADER_SIZE_UINT32 * sizeof(uint32_t) +
- _PW_VAR_DEQUE_ARRAY_SIZE_BYTES;
+static inline uint32_t pw_VariableLengthEntryQueue_RawStorageSizeBytes(
+ pw_VariableLengthEntryQueue_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_VariableLengthEntryDeque_MaxEntrySizeBytes(
- pw_VariableLengthEntryDeque_ConstHandle deque) {
- return _PW_VAR_DEQUE_ARRAY_SIZE_BYTES - 1 -
- (uint32_t)pw_varint_EncodedSizeBytes(_PW_VAR_DEQUE_ARRAY_SIZE_BYTES -
+static inline uint32_t pw_VariableLengthEntryQueue_MaxEntrySizeBytes(
+ pw_VariableLengthEntryQueue_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_VariableLengthEntryDeque_Empty(
- pw_VariableLengthEntryDeque_ConstHandle deque) {
- return _PW_VAR_DEQUE_HEAD == _PW_VAR_DEQUE_TAIL;
+static inline bool pw_VariableLengthEntryQueue_Empty(
+ pw_VariableLengthEntryQueue_ConstHandle queue) {
+ return _PW_VAR_QUEUE_HEAD == _PW_VAR_QUEUE_TAIL;
}
// These macros are not part of the public API, so undefine them.
-#undef _PW_VAR_DEQUE_ARRAY_SIZE_BYTES
-#undef _PW_VAR_DEQUE_HEAD
-#undef _PW_VAR_DEQUE_TAIL
-#undef _PW_VAR_DEQUE_DATA
+#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"
diff --git a/pw_containers/pw_containers_private/variable_length_entry_queue_test_oracle.h b/pw_containers/pw_containers_private/variable_length_entry_queue_test_oracle.h
index f492e68..9389d53 100644
--- a/pw_containers/pw_containers_private/variable_length_entry_queue_test_oracle.h
+++ b/pw_containers/pw_containers_private/variable_length_entry_queue_test_oracle.h
@@ -24,26 +24,26 @@
namespace pw::containers {
-// Behaves like a VariableLengthEntryDeque should, but with a std::deque-based
+// Behaves like a VariableLengthEntryQueue should, but with a std::deque-based
// implementation.
-class VariableLengthEntryDequeTestOracle {
+class VariableLengthEntryQueueTestOracle {
public:
- VariableLengthEntryDequeTestOracle(uint32_t max_entry_size_bytes)
+ VariableLengthEntryQueueTestOracle(uint32_t max_entry_size_bytes)
: max_entry_size_bytes_(max_entry_size_bytes),
raw_size_bytes_(0),
raw_capacity_bytes_(
static_cast<uint32_t>(varint::EncodedSize(max_entry_size_bytes)) +
max_entry_size_bytes) {}
- void push_back_overwrite(ConstByteSpan data) {
+ void push_overwrite(ConstByteSpan data) {
size_t encoded_size = varint::EncodedSize(data.size()) + data.size();
while (encoded_size > (raw_capacity_bytes_ - raw_size_bytes_)) {
- pop_front();
+ pop();
}
- push_back(data);
+ push(data);
}
- void push_back(ConstByteSpan data) {
+ void push(ConstByteSpan data) {
PW_ASSERT(data.size() <= max_entry_size_bytes_);
size_t encoded_size = varint::EncodedSize(data.size()) + data.size();
@@ -53,7 +53,7 @@
raw_size_bytes_ += encoded_size;
}
- void pop_front() {
+ void pop() {
PW_ASSERT(!q_.empty());
raw_size_bytes_ -=
varint::EncodedSize(q_.front().size()) + q_.front().size();
diff --git a/pw_containers/variable_length_entry_queue.c b/pw_containers/variable_length_entry_queue.c
index b6c532d..8f7cc49 100644
--- a/pw_containers/variable_length_entry_queue.c
+++ b/pw_containers/variable_length_entry_queue.c
@@ -20,25 +20,25 @@
#include "pw_varint/varint.h"
// Access the underlying buffer size and capacity (one less than size).
-static uint32_t BufferSize(const uint32_t* deque) { return deque[0]; }
-static uint32_t Capacity(const uint32_t* deque) {
- return BufferSize(deque) - 1;
+static uint32_t BufferSize(const uint32_t* queue) { return queue[0]; }
+static uint32_t Capacity(const uint32_t* queue) {
+ return BufferSize(queue) - 1;
}
// Access the head and tail offsets.
-#define HEAD(deque) deque[1]
-#define TAIL(deque) deque[2]
+#define HEAD(queue) queue[1]
+#define TAIL(queue) queue[2]
// Access the data. Strict aliasing rules do not apply to byte pointers.
-static uint8_t* WritableData(uint32_t* deque) { return (uint8_t*)&deque[3]; }
-static const uint8_t* Data(const uint32_t* deque) {
- return (const uint8_t*)&deque[3];
+static uint8_t* WritableData(uint32_t* queue) { return (uint8_t*)&queue[3]; }
+static const uint8_t* Data(const uint32_t* queue) {
+ return (const uint8_t*)&queue[3];
}
-static uint32_t WrapIndex(pw_VariableLengthEntryDeque_ConstHandle deque,
+static uint32_t WrapIndex(pw_VariableLengthEntryQueue_ConstHandle queue,
uint32_t offset) {
- if (offset >= BufferSize(deque)) {
- offset -= BufferSize(deque);
+ if (offset >= BufferSize(queue)) {
+ offset -= BufferSize(queue);
}
return offset;
}
@@ -49,7 +49,7 @@
} EntrySize;
// Returns the size of an entry, including both the prefix length and data size.
-static EntrySize ReadEntrySize(pw_VariableLengthEntryDeque_ConstHandle deque,
+static EntrySize ReadEntrySize(pw_VariableLengthEntryQueue_ConstHandle queue,
uint32_t offset) {
EntrySize size = {0, 0};
@@ -58,120 +58,118 @@
PW_DCHECK_UINT_NE(size.prefix, PW_VARINT_MAX_INT32_SIZE_BYTES);
keep_going = pw_varint_DecodeOneByte32(
- Data(deque)[offset], size.prefix++, &size.data);
- offset = WrapIndex(deque, offset + 1);
+ Data(queue)[offset], size.prefix++, &size.data);
+ offset = WrapIndex(queue, offset + 1);
} while (keep_going);
return size;
}
-static uint32_t EncodePrefix(pw_VariableLengthEntryDeque_ConstHandle deque,
+static uint32_t EncodePrefix(pw_VariableLengthEntryQueue_ConstHandle queue,
uint8_t prefix[PW_VARINT_MAX_INT32_SIZE_BYTES],
uint32_t data_size_bytes) {
const uint32_t prefix_size = (uint32_t)pw_varint_Encode32(
data_size_bytes, prefix, PW_VARINT_MAX_INT32_SIZE_BYTES);
// Check that the ring buffer is capable of holding entries of this size.
- PW_CHECK_UINT_LE(prefix_size + data_size_bytes, Capacity(deque));
+ PW_CHECK_UINT_LE(prefix_size + data_size_bytes, Capacity(queue));
return prefix_size;
}
// Returns the total encoded size of an entry.
static uint32_t ReadEncodedEntrySize(
- pw_VariableLengthEntryDeque_ConstHandle deque, uint32_t offset) {
- const EntrySize entry_size = ReadEntrySize(deque, offset);
+ pw_VariableLengthEntryQueue_ConstHandle queue, uint32_t offset) {
+ const EntrySize entry_size = ReadEntrySize(queue, offset);
return entry_size.prefix + entry_size.data;
}
-static uint32_t PopFrontNonEmpty(pw_VariableLengthEntryDeque_Handle deque) {
- const uint32_t entry_size = ReadEncodedEntrySize(deque, HEAD(deque));
- HEAD(deque) = WrapIndex(deque, HEAD(deque) + entry_size);
+static uint32_t PopNonEmpty(pw_VariableLengthEntryQueue_Handle queue) {
+ const uint32_t entry_size = ReadEncodedEntrySize(queue, HEAD(queue));
+ HEAD(queue) = WrapIndex(queue, HEAD(queue) + entry_size);
return entry_size;
}
// Copies data to the buffer, wrapping around the end if needed.
-static uint32_t CopyAndWrap(pw_VariableLengthEntryDeque_Handle deque,
+static uint32_t CopyAndWrap(pw_VariableLengthEntryQueue_Handle queue,
uint32_t tail,
const uint8_t* data,
uint32_t size) {
// Copy the new data in one or two chunks. The first chunk is copied to the
// byte after the tail, the second from the beginning of the buffer. Both may
// be zero bytes.
- uint32_t first_chunk = BufferSize(deque) - tail;
+ uint32_t first_chunk = BufferSize(queue) - tail;
if (first_chunk >= size) {
first_chunk = size;
} else { // Copy 2nd chunk from the beginning of the buffer (may be 0 bytes).
- memcpy(WritableData(deque),
+ memcpy(WritableData(queue),
(const uint8_t*)data + first_chunk,
size - first_chunk);
}
- memcpy(&WritableData(deque)[tail], data, first_chunk);
- return WrapIndex(deque, tail + size);
+ memcpy(&WritableData(queue)[tail], data, first_chunk);
+ return WrapIndex(queue, tail + size);
}
-static void AppendEntryKnownToFit(pw_VariableLengthEntryDeque_Handle deque,
+static void AppendEntryKnownToFit(pw_VariableLengthEntryQueue_Handle queue,
const uint8_t* prefix,
uint32_t prefix_size,
const void* data,
uint32_t size) {
// Calculate the new tail offset. Don't update it until the copy is complete.
- uint32_t tail = TAIL(deque);
- tail = CopyAndWrap(deque, tail, prefix, prefix_size);
- TAIL(deque) = CopyAndWrap(deque, tail, data, size);
+ uint32_t tail = TAIL(queue);
+ tail = CopyAndWrap(queue, tail, prefix, prefix_size);
+ TAIL(queue) = CopyAndWrap(queue, tail, data, size);
}
-void pw_VariableLengthEntryDeque_PushBack(
- pw_VariableLengthEntryDeque_Handle deque,
- const void* data,
- const uint32_t data_size_bytes) {
+void pw_VariableLengthEntryQueue_Push(pw_VariableLengthEntryQueue_Handle queue,
+ const void* data,
+ const uint32_t data_size_bytes) {
uint8_t prefix[PW_VARINT_MAX_INT32_SIZE_BYTES];
- uint32_t prefix_size = EncodePrefix(deque, prefix, data_size_bytes);
+ uint32_t prefix_size = EncodePrefix(queue, prefix, data_size_bytes);
PW_CHECK(prefix_size + data_size_bytes <=
- Capacity(deque) - pw_VariableLengthEntryDeque_RawSizeBytes(deque));
+ Capacity(queue) - pw_VariableLengthEntryQueue_RawSizeBytes(queue));
- AppendEntryKnownToFit(deque, prefix, prefix_size, data, data_size_bytes);
+ AppendEntryKnownToFit(queue, prefix, prefix_size, data, data_size_bytes);
}
-void pw_VariableLengthEntryDeque_PushBackOverwrite(
- pw_VariableLengthEntryDeque_Handle deque,
+void pw_VariableLengthEntryQueue_PushOverwrite(
+ pw_VariableLengthEntryQueue_Handle queue,
const void* data,
const uint32_t data_size_bytes) {
uint8_t prefix[PW_VARINT_MAX_INT32_SIZE_BYTES];
- uint32_t prefix_size = EncodePrefix(deque, prefix, data_size_bytes);
+ uint32_t prefix_size = EncodePrefix(queue, prefix, data_size_bytes);
uint32_t available_bytes =
- Capacity(deque) - pw_VariableLengthEntryDeque_RawSizeBytes(deque);
+ Capacity(queue) - pw_VariableLengthEntryQueue_RawSizeBytes(queue);
while (data_size_bytes + prefix_size > available_bytes) {
- available_bytes += PopFrontNonEmpty(deque);
+ available_bytes += PopNonEmpty(queue);
}
- AppendEntryKnownToFit(deque, prefix, prefix_size, data, data_size_bytes);
+ AppendEntryKnownToFit(queue, prefix, prefix_size, data, data_size_bytes);
}
-void pw_VariableLengthEntryDeque_PopFront(
- pw_VariableLengthEntryDeque_Handle deque) {
- PW_CHECK(!pw_VariableLengthEntryDeque_Empty(deque));
- PopFrontNonEmpty(deque);
+void pw_VariableLengthEntryQueue_Pop(pw_VariableLengthEntryQueue_Handle queue) {
+ PW_CHECK(!pw_VariableLengthEntryQueue_Empty(queue));
+ PopNonEmpty(queue);
}
-void pw_VariableLengthEntryDeque_Iterator_Advance(
- pw_VariableLengthEntryDeque_Iterator* iterator) {
+void pw_VariableLengthEntryQueue_Iterator_Advance(
+ pw_VariableLengthEntryQueue_Iterator* iterator) {
iterator->_pw_offset = WrapIndex(
- iterator->_pw_deque,
+ iterator->_pw_queue,
iterator->_pw_offset +
- ReadEncodedEntrySize(iterator->_pw_deque, iterator->_pw_offset));
+ ReadEncodedEntrySize(iterator->_pw_queue, iterator->_pw_offset));
}
-pw_VariableLengthEntryDeque_Entry pw_VariableLengthEntryDeque_GetEntry(
- const pw_VariableLengthEntryDeque_Iterator* iterator) {
- pw_VariableLengthEntryDeque_ConstHandle deque = iterator->_pw_deque;
+pw_VariableLengthEntryQueue_Entry pw_VariableLengthEntryQueue_GetEntry(
+ const pw_VariableLengthEntryQueue_Iterator* iterator) {
+ pw_VariableLengthEntryQueue_ConstHandle queue = iterator->_pw_queue;
- pw_VariableLengthEntryDeque_Entry entry;
- EntrySize size = ReadEntrySize(deque, iterator->_pw_offset);
- uint32_t offset_1 = WrapIndex(deque, iterator->_pw_offset + size.prefix);
+ pw_VariableLengthEntryQueue_Entry entry;
+ EntrySize size = ReadEntrySize(queue, iterator->_pw_offset);
+ uint32_t offset_1 = WrapIndex(queue, iterator->_pw_offset + size.prefix);
- const uint32_t first_chunk = BufferSize(deque) - offset_1;
+ const uint32_t first_chunk = BufferSize(queue) - offset_1;
if (size.data <= first_chunk) {
entry.size_1 = size.data;
@@ -181,13 +179,13 @@
entry.size_2 = size.data - first_chunk;
}
- entry.data_1 = Data(deque) + offset_1;
- entry.data_2 = Data(deque) + WrapIndex(deque, offset_1 + entry.size_1);
+ entry.data_1 = Data(queue) + offset_1;
+ entry.data_2 = Data(queue) + WrapIndex(queue, offset_1 + entry.size_1);
return entry;
}
-uint32_t pw_VariableLengthEntryDeque_Entry_Copy(
- const pw_VariableLengthEntryDeque_Entry* entry,
+uint32_t pw_VariableLengthEntryQueue_Entry_Copy(
+ const pw_VariableLengthEntryQueue_Entry* entry,
void* dest,
uint32_t count) {
PW_DCHECK(dest != NULL || count == 0u);
@@ -209,13 +207,13 @@
return to_copy;
}
-uint32_t pw_VariableLengthEntryDeque_Size(
- pw_VariableLengthEntryDeque_ConstHandle deque) {
+uint32_t pw_VariableLengthEntryQueue_Size(
+ pw_VariableLengthEntryQueue_ConstHandle queue) {
uint32_t entry_count = 0;
- uint32_t offset = HEAD(deque);
+ uint32_t offset = HEAD(queue);
- while (offset != TAIL(deque)) {
- offset = WrapIndex(deque, offset + ReadEncodedEntrySize(deque, offset));
+ while (offset != TAIL(queue)) {
+ offset = WrapIndex(queue, offset + ReadEncodedEntrySize(queue, offset));
entry_count += 1;
}
return entry_count;
diff --git a/pw_containers/variable_length_entry_queue_test.cc b/pw_containers/variable_length_entry_queue_test.cc
index a0262ca..f329f60 100644
--- a/pw_containers/variable_length_entry_queue_test.cc
+++ b/pw_containers/variable_length_entry_queue_test.cc
@@ -40,69 +40,69 @@
// Copies an entry, which might be wrapped, to a single std::vector.
std::vector<std::byte> ReadEntry(
- const pw_VariableLengthEntryDeque_Iterator& it) {
- auto entry = pw_VariableLengthEntryDeque_GetEntry(&it);
+ const pw_VariableLengthEntryQueue_Iterator& it) {
+ auto entry = pw_VariableLengthEntryQueue_GetEntry(&it);
std::vector<std::byte> value(entry.size_1 + entry.size_2);
EXPECT_EQ(value.size(),
- pw_VariableLengthEntryDeque_Entry_Copy(
+ pw_VariableLengthEntryQueue_Entry_Copy(
&entry, value.data(), entry.size_1 + entry.size_2));
return value;
}
-#define ASSERT_CONTENTS_EQ(oracle, deque) \
+#define ASSERT_CONTENTS_EQ(oracle, queue) \
auto oracle_it = oracle.begin(); \
- auto deque_it = pw_VariableLengthEntryDeque_Begin(deque); \
- const auto deque_end = pw_VariableLengthEntryDeque_End(deque); \
+ auto queue_it = pw_VariableLengthEntryQueue_Begin(queue); \
+ const auto queue_end = pw_VariableLengthEntryQueue_End(queue); \
uint32_t entries_compared = 0; \
while (oracle_it != oracle.end() && \
- !pw_VariableLengthEntryDeque_Iterator_Equal(&deque_it, &deque_end)) { \
- ASSERT_EQ(*oracle_it++, ReadEntry(deque_it)); \
- pw_VariableLengthEntryDeque_Iterator_Advance(&deque_it); \
+ !pw_VariableLengthEntryQueue_Iterator_Equal(&queue_it, &queue_end)) { \
+ ASSERT_EQ(*oracle_it++, ReadEntry(queue_it)); \
+ pw_VariableLengthEntryQueue_Iterator_Advance(&queue_it); \
entries_compared += 1; \
} \
ASSERT_EQ(entries_compared, oracle.size())
// Declares a test that performs a series of operations on a
-// VariableLengthEntryDeque and the "oracle" class, and checks that they match
+// VariableLengthEntryQueue and the "oracle" class, and checks that they match
// after every step.
#define DATA_DRIVEN_TEST(program, max_entry_size) \
- TEST(VariableLengthEntryDeque, \
+ TEST(VariableLengthEntryQueue, \
DataDrivenTest_##program##_MaxEntrySize##max_entry_size) { \
- pw::containers::VariableLengthEntryDequeTestOracle oracle(max_entry_size); \
- PW_VARIABLE_LENGTH_ENTRY_DEQUE_DECLARE(c_deque, max_entry_size); \
+ pw::containers::VariableLengthEntryQueueTestOracle oracle(max_entry_size); \
+ PW_VARIABLE_LENGTH_ENTRY_QUEUE_DECLARE(c_queue, max_entry_size); \
\
for (const TestStep& step : program) { \
/* Take the action */ \
if (auto ow = std::get_if<PushOverwrite>(&step); ow != nullptr) { \
- pw_VariableLengthEntryDeque_PushBackOverwrite( \
- c_deque, ow->data.data(), static_cast<uint32_t>(ow->data.size())); \
- oracle.push_back_overwrite(pw::as_bytes(pw::span(ow->data))); \
+ pw_VariableLengthEntryQueue_PushOverwrite( \
+ c_queue, ow->data.data(), static_cast<uint32_t>(ow->data.size())); \
+ oracle.push_overwrite(pw::as_bytes(pw::span(ow->data))); \
} else if (auto push = std::get_if<Push>(&step); push != nullptr) { \
- pw_VariableLengthEntryDeque_PushBack( \
- c_deque, \
+ pw_VariableLengthEntryQueue_Push( \
+ c_queue, \
push->data.data(), \
static_cast<uint32_t>(push->data.size())); \
- oracle.push_back(pw::as_bytes(pw::span(push->data))); \
+ oracle.push(pw::as_bytes(pw::span(push->data))); \
} else if (auto pop = std::get_if<Pop>(&step); pop != nullptr) { \
- pw_VariableLengthEntryDeque_PopFront(c_deque); \
- oracle.pop_front(); \
+ pw_VariableLengthEntryQueue_Pop(c_queue); \
+ oracle.pop(); \
} else if (auto size = std::get_if<SizeEquals>(&step); \
size != nullptr) { \
- size_t actual = pw_VariableLengthEntryDeque_Size(c_deque); \
+ size_t actual = pw_VariableLengthEntryQueue_Size(c_queue); \
ASSERT_EQ(oracle.size(), actual); \
ASSERT_EQ(size->expected, actual); \
} else { \
FAIL() << "Unhandled case"; \
} \
/* Check size and other functions */ \
- ASSERT_EQ(pw_VariableLengthEntryDeque_Size(c_deque), oracle.size()); \
- ASSERT_EQ(pw_VariableLengthEntryDeque_RawSizeBytes(c_deque), \
+ ASSERT_EQ(pw_VariableLengthEntryQueue_Size(c_queue), oracle.size()); \
+ ASSERT_EQ(pw_VariableLengthEntryQueue_RawSizeBytes(c_queue), \
oracle.raw_size_bytes()); \
- ASSERT_EQ(pw_VariableLengthEntryDeque_RawCapacityBytes(c_deque), \
+ ASSERT_EQ(pw_VariableLengthEntryQueue_RawCapacityBytes(c_queue), \
oracle.raw_capacity_bytes()); \
- ASSERT_EQ(pw_VariableLengthEntryDeque_MaxEntrySizeBytes(c_deque), \
+ ASSERT_EQ(pw_VariableLengthEntryQueue_MaxEntrySizeBytes(c_queue), \
oracle.max_entry_size_bytes()); \
- ASSERT_CONTENTS_EQ(oracle, c_deque); \
+ ASSERT_CONTENTS_EQ(oracle, c_queue); \
} \
} \
static_assert(true, "use a semicolon")
@@ -188,68 +188,68 @@
};
DATA_DRIVEN_TEST(kTwoBytePrefix, 130);
-TEST(VariableLengthEntryDeque, DeclareMacro) {
- PW_VARIABLE_LENGTH_ENTRY_DEQUE_DECLARE(deque, 123);
+TEST(VariableLengthEntryQueue, DeclareMacro) {
+ PW_VARIABLE_LENGTH_ENTRY_QUEUE_DECLARE(queue, 123);
constexpr size_t kArraySizeBytes =
123 + 1 /*prefix*/ + 1 /* end */ + 3 /* round up */ +
- PW_VARIABLE_LENGTH_ENTRY_DEQUE_HEADER_SIZE_UINT32 * 4;
- static_assert(sizeof(deque) == kArraySizeBytes);
- EXPECT_EQ(pw_VariableLengthEntryDeque_RawStorageSizeBytes(deque),
+ PW_VARIABLE_LENGTH_ENTRY_QUEUE_HEADER_SIZE_UINT32 * 4;
+ static_assert(sizeof(queue) == kArraySizeBytes);
+ EXPECT_EQ(pw_VariableLengthEntryQueue_RawStorageSizeBytes(queue),
kArraySizeBytes - 3 /* padding isn't included */);
- EXPECT_EQ(pw_VariableLengthEntryDeque_MaxEntrySizeBytes(deque), 123u);
- EXPECT_EQ(pw_VariableLengthEntryDeque_RawSizeBytes(deque), 0u);
- EXPECT_TRUE(pw_VariableLengthEntryDeque_Empty(deque));
+ EXPECT_EQ(pw_VariableLengthEntryQueue_MaxEntrySizeBytes(queue), 123u);
+ EXPECT_EQ(pw_VariableLengthEntryQueue_RawSizeBytes(queue), 0u);
+ EXPECT_TRUE(pw_VariableLengthEntryQueue_Empty(queue));
}
-TEST(VariableLengthEntryDeque, InitializeExistingBuffer) {
+TEST(VariableLengthEntryQueue, InitializeExistingBuffer) {
constexpr size_t kArraySize =
- 10 + PW_VARIABLE_LENGTH_ENTRY_DEQUE_HEADER_SIZE_UINT32;
- uint32_t deque[kArraySize];
- pw_VariableLengthEntryDeque_Init(deque, kArraySize);
+ 10 + PW_VARIABLE_LENGTH_ENTRY_QUEUE_HEADER_SIZE_UINT32;
+ uint32_t queue[kArraySize];
+ pw_VariableLengthEntryQueue_Init(queue, kArraySize);
- EXPECT_EQ(pw_VariableLengthEntryDeque_RawStorageSizeBytes(deque),
- sizeof(deque));
- EXPECT_EQ(pw_VariableLengthEntryDeque_MaxEntrySizeBytes(deque),
+ EXPECT_EQ(pw_VariableLengthEntryQueue_RawStorageSizeBytes(queue),
+ sizeof(queue));
+ EXPECT_EQ(pw_VariableLengthEntryQueue_MaxEntrySizeBytes(queue),
sizeof(uint32_t) * 10u - 1 /*prefix*/ - 1 /*end*/);
- EXPECT_EQ(pw_VariableLengthEntryDeque_RawSizeBytes(deque), 0u);
- EXPECT_EQ(pw_VariableLengthEntryDeque_Size(deque), 0u);
- EXPECT_TRUE(pw_VariableLengthEntryDeque_Empty(deque));
+ EXPECT_EQ(pw_VariableLengthEntryQueue_RawSizeBytes(queue), 0u);
+ EXPECT_EQ(pw_VariableLengthEntryQueue_Size(queue), 0u);
+ EXPECT_TRUE(pw_VariableLengthEntryQueue_Empty(queue));
}
-TEST(VariableLengthEntryDeque, MaxSizeElement) {
+TEST(VariableLengthEntryQueue, MaxSizeElement) {
// Test max size elements for a few sizes. Commented out statements fail an
// assert because the elements are too large.
- PW_VARIABLE_LENGTH_ENTRY_DEQUE_DECLARE(dq16, 126);
- PW_VARIABLE_LENGTH_ENTRY_DEQUE_DECLARE(dq17, 127);
- PW_VARIABLE_LENGTH_ENTRY_DEQUE_DECLARE(dq18, 128);
- PW_VARIABLE_LENGTH_ENTRY_DEQUE_DECLARE(dq19, 129);
+ PW_VARIABLE_LENGTH_ENTRY_QUEUE_DECLARE(q16, 126);
+ PW_VARIABLE_LENGTH_ENTRY_QUEUE_DECLARE(q17, 127);
+ PW_VARIABLE_LENGTH_ENTRY_QUEUE_DECLARE(q18, 128);
+ PW_VARIABLE_LENGTH_ENTRY_QUEUE_DECLARE(q19, 129);
- pw_VariableLengthEntryDeque_PushBackOverwrite(dq16, kBigEntryBytes, 126);
- pw_VariableLengthEntryDeque_PushBackOverwrite(dq17, kBigEntryBytes, 126);
- pw_VariableLengthEntryDeque_PushBackOverwrite(dq18, kBigEntryBytes, 126);
- pw_VariableLengthEntryDeque_PushBackOverwrite(dq19, kBigEntryBytes, 126);
+ pw_VariableLengthEntryQueue_PushOverwrite(q16, kBigEntryBytes, 126);
+ pw_VariableLengthEntryQueue_PushOverwrite(q17, kBigEntryBytes, 126);
+ pw_VariableLengthEntryQueue_PushOverwrite(q18, kBigEntryBytes, 126);
+ pw_VariableLengthEntryQueue_PushOverwrite(q19, kBigEntryBytes, 126);
- // pw_VariableLengthEntryDeque_PushBackOverwrite(dq16, kBigEntryBytes, 127);
- pw_VariableLengthEntryDeque_PushBackOverwrite(dq17, kBigEntryBytes, 127);
- pw_VariableLengthEntryDeque_PushBackOverwrite(dq18, kBigEntryBytes, 127);
- pw_VariableLengthEntryDeque_PushBackOverwrite(dq19, kBigEntryBytes, 127);
+ // pw_VariableLengthEntryQueue_PushOverwrite(q16, kBigEntryBytes, 127);
+ pw_VariableLengthEntryQueue_PushOverwrite(q17, kBigEntryBytes, 127);
+ pw_VariableLengthEntryQueue_PushOverwrite(q18, kBigEntryBytes, 127);
+ pw_VariableLengthEntryQueue_PushOverwrite(q19, kBigEntryBytes, 127);
- // pw_VariableLengthEntryDeque_PushBackOverwrite(dq16, kBigEntryBytes, 128);
- // pw_VariableLengthEntryDeque_PushBackOverwrite(dq17, kBigEntryBytes, 128);
- pw_VariableLengthEntryDeque_PushBackOverwrite(dq18, kBigEntryBytes, 128);
- pw_VariableLengthEntryDeque_PushBackOverwrite(dq19, kBigEntryBytes, 128);
+ // pw_VariableLengthEntryQueue_PushOverwrite(q16, kBigEntryBytes, 128);
+ // pw_VariableLengthEntryQueue_PushOverwrite(q17, kBigEntryBytes, 128);
+ pw_VariableLengthEntryQueue_PushOverwrite(q18, kBigEntryBytes, 128);
+ pw_VariableLengthEntryQueue_PushOverwrite(q19, kBigEntryBytes, 128);
- // pw_VariableLengthEntryDeque_PushBackOverwrite(dq16, kBigEntryBytes, 129);
- // pw_VariableLengthEntryDeque_PushBackOverwrite(dq17, kBigEntryBytes, 129);
- // pw_VariableLengthEntryDeque_PushBackOverwrite(dq18, kBigEntryBytes, 129);
- pw_VariableLengthEntryDeque_PushBackOverwrite(dq19, kBigEntryBytes, 129);
+ // pw_VariableLengthEntryQueue_PushOverwrite(q16, kBigEntryBytes, 129);
+ // pw_VariableLengthEntryQueue_PushOverwrite(q17, kBigEntryBytes, 129);
+ // pw_VariableLengthEntryQueue_PushOverwrite(q18, kBigEntryBytes, 129);
+ pw_VariableLengthEntryQueue_PushOverwrite(q19, kBigEntryBytes, 129);
- EXPECT_EQ(pw_VariableLengthEntryDeque_Size(dq16), 1u);
- EXPECT_EQ(pw_VariableLengthEntryDeque_Size(dq17), 1u);
- EXPECT_EQ(pw_VariableLengthEntryDeque_Size(dq18), 1u);
- EXPECT_EQ(pw_VariableLengthEntryDeque_Size(dq19), 1u);
+ EXPECT_EQ(pw_VariableLengthEntryQueue_Size(q16), 1u);
+ EXPECT_EQ(pw_VariableLengthEntryQueue_Size(q17), 1u);
+ EXPECT_EQ(pw_VariableLengthEntryQueue_Size(q18), 1u);
+ EXPECT_EQ(pw_VariableLengthEntryQueue_Size(q19), 1u);
}
} // namespace
diff --git a/pw_tokenizer/tokenize_c99_test.c b/pw_tokenizer/tokenize_c99_test.c
index 2fe0b43..62bd7c4 100644
--- a/pw_tokenizer/tokenize_c99_test.c
+++ b/pw_tokenizer/tokenize_c99_test.c
@@ -43,7 +43,7 @@
#error "This test should be compiled with -std=c99."
#endif // __STDC_VERSION__ != 199901L
-PW_VARIABLE_LENGTH_ENTRY_DEQUE_DECLARE(buffer, 256);
+PW_VARIABLE_LENGTH_ENTRY_QUEUE_DECLARE(buffer, 256);
// Encodes a tokenized message with any number of int arguments.
static void TokenizeIntegersOnly(uint32_t token, int arg_count, ...) {
@@ -66,7 +66,7 @@
}
// Write the encoded log to the ring buffer
- pw_VariableLengthEntryDeque_PushBackOverwrite(buffer, encoded, index);
+ pw_VariableLengthEntryQueue_PushOverwrite(buffer, encoded, index);
va_end(args);
}
@@ -100,35 +100,35 @@
TOKENIZE_INTS("One arg, 5 bytes: %ld", (long)INT32_MAX);
TOKENIZE_INTS("Three args, 4 bytes: %d %d %d", 1, 63, 128);
- ASSERT_EQ(pw_VariableLengthEntryDeque_Size(buffer), 4u);
+ ASSERT_EQ(pw_VariableLengthEntryQueue_Size(buffer), 4u);
- pw_VariableLengthEntryDeque_Iterator it =
- pw_VariableLengthEntryDeque_Begin(buffer);
- pw_VariableLengthEntryDeque_Entry entry =
- pw_VariableLengthEntryDeque_GetEntry(&it);
+ pw_VariableLengthEntryQueue_Iterator it =
+ pw_VariableLengthEntryQueue_Begin(buffer);
+ pw_VariableLengthEntryQueue_Entry entry =
+ pw_VariableLengthEntryQueue_GetEntry(&it);
ASSERT_EQ(entry.size_1, sizeof(uint32_t) + 0);
ASSERT_EQ(entry.size_2, 0u);
- pw_VariableLengthEntryDeque_Iterator_Advance(&it);
- entry = pw_VariableLengthEntryDeque_GetEntry(&it);
+ pw_VariableLengthEntryQueue_Iterator_Advance(&it);
+ entry = pw_VariableLengthEntryQueue_GetEntry(&it);
ASSERT_EQ(entry.size_1, sizeof(uint32_t) + 1);
ASSERT_EQ(entry.size_2, 0u);
- pw_VariableLengthEntryDeque_Iterator_Advance(&it);
- entry = pw_VariableLengthEntryDeque_GetEntry(&it);
+ pw_VariableLengthEntryQueue_Iterator_Advance(&it);
+ entry = pw_VariableLengthEntryQueue_GetEntry(&it);
ASSERT_EQ(entry.size_1, sizeof(uint32_t) + 5);
ASSERT_EQ(entry.size_2, 0u);
- pw_VariableLengthEntryDeque_Iterator_Advance(&it);
- entry = pw_VariableLengthEntryDeque_GetEntry(&it);
+ pw_VariableLengthEntryQueue_Iterator_Advance(&it);
+ entry = pw_VariableLengthEntryQueue_GetEntry(&it);
ASSERT_EQ(entry.size_1, sizeof(uint32_t) + 4);
ASSERT_EQ(entry.size_2, 0u);
- pw_VariableLengthEntryDeque_Iterator_Advance(&it);
- pw_VariableLengthEntryDeque_Iterator end =
- pw_VariableLengthEntryDeque_End(buffer);
- ASSERT_EQ(pw_VariableLengthEntryDeque_Iterator_Equal(&it, &end), true);
+ pw_VariableLengthEntryQueue_Iterator_Advance(&it);
+ pw_VariableLengthEntryQueue_Iterator end =
+ pw_VariableLengthEntryQueue_End(buffer);
+ ASSERT_EQ(pw_VariableLengthEntryQueue_Iterator_Equal(&it, &end), true);
return "passed";
}
