pw_span: Switch from pw::span to std::span
Replace pw::span with std::span and "pw_span/span.h" with <span>
throughout the codebase.
Change-Id: Ib1fa873168b6093794e861611d750fcad6285d6c
Reviewed-on: https://pigweed-review.googlesource.com/c/pigweed/pigweed/+/12801
Commit-Queue: Wyatt Hepler <hepler@google.com>
Reviewed-by: Rob Mohr <mohrr@google.com>
Reviewed-by: Keir Mierle <keir@google.com>
diff --git a/pw_allocator/block.cc b/pw_allocator/block.cc
index 8f93ff4..43fb209 100644
--- a/pw_allocator/block.cc
+++ b/pw_allocator/block.cc
@@ -16,7 +16,7 @@
namespace pw::allocator {
-Status Block::Init(const span<std::byte> region, Block** block) {
+Status Block::Init(const std::span<std::byte> region, Block** block) {
// Ensure the region we're given is aligned and sized accordingly
if (reinterpret_cast<uintptr_t>(region.data()) % alignof(Block) != 0) {
return Status::INVALID_ARGUMENT;
diff --git a/pw_allocator/block_test.cc b/pw_allocator/block_test.cc
index 7979bdc..9fa5678 100644
--- a/pw_allocator/block_test.cc
+++ b/pw_allocator/block_test.cc
@@ -14,8 +14,9 @@
#include "pw_allocator/block.h"
+#include <span>
+
#include "gtest/gtest.h"
-#include "pw_span/span.h"
using std::byte;
@@ -26,7 +27,7 @@
alignas(Block*) byte bytes[kN];
Block* block = nullptr;
- auto status = Block::Init(span(bytes, kN), &block);
+ auto status = Block::Init(std::span(bytes, kN), &block);
ASSERT_EQ(status, Status::OK);
EXPECT_EQ(block->OuterSize(), kN);
@@ -45,7 +46,7 @@
byte* byte_ptr = bytes;
Block* block = nullptr;
- auto status = Block::Init(span(byte_ptr + 1, kN - 1), &block);
+ auto status = Block::Init(std::span(byte_ptr + 1, kN - 1), &block);
EXPECT_EQ(status, Status::INVALID_ARGUMENT);
}
@@ -54,7 +55,7 @@
constexpr size_t kN = 2;
alignas(Block*) byte bytes[kN];
Block* block = nullptr;
- auto status = Block::Init(span(bytes, kN), &block);
+ auto status = Block::Init(std::span(bytes, kN), &block);
EXPECT_EQ(status, Status::INVALID_ARGUMENT);
}
@@ -65,7 +66,7 @@
alignas(Block*) byte bytes[kN];
Block* block = nullptr;
- Block::Init(span(bytes, kN), &block);
+ Block::Init(std::span(bytes, kN), &block);
Block* next_block = nullptr;
auto status = block->Split(kSplitN, &next_block);
@@ -96,7 +97,7 @@
uintptr_t split_len = split_addr - (uintptr_t)&bytes;
Block* block = nullptr;
- Block::Init(span(bytes, kN), &block);
+ Block::Init(std::span(bytes, kN), &block);
Block* next_block = nullptr;
auto status = block->Split(kSplitN, &next_block);
@@ -126,7 +127,7 @@
byte bytes[kN];
Block* block = nullptr;
- Block::Init(span(bytes, kN), &block);
+ Block::Init(std::span(bytes, kN), &block);
Block* block2 = nullptr;
block->Split(kSplit1, &block2);
@@ -146,7 +147,7 @@
byte bytes[kN];
Block* block = nullptr;
- Block::Init(span(bytes, kN), &block);
+ Block::Init(std::span(bytes, kN), &block);
Block* next_block = nullptr;
auto status = block->Split(kSplitN, &next_block);
@@ -161,7 +162,7 @@
byte bytes[kN];
Block* block = nullptr;
- Block::Init(span(bytes, kN), &block);
+ Block::Init(std::span(bytes, kN), &block);
auto status = block->Split(kSplitN, nullptr);
EXPECT_EQ(status, Status::INVALID_ARGUMENT);
@@ -173,7 +174,7 @@
byte bytes[kN];
Block* block = nullptr;
- Block::Init(span(bytes, kN), &block);
+ Block::Init(std::span(bytes, kN), &block);
Block* next_block = nullptr;
auto status = block->Split(block->InnerSize() + 1, &next_block);
@@ -187,7 +188,7 @@
byte bytes[kN];
Block* block = nullptr;
- Block::Init(span(bytes, kN), &block);
+ Block::Init(std::span(bytes, kN), &block);
Block* next_block = nullptr;
auto status = block->Split(0, &next_block);
@@ -202,7 +203,7 @@
byte bytes[kN];
Block* block = nullptr;
- Block::Init(span(bytes, kN), &block);
+ Block::Init(std::span(bytes, kN), &block);
Block* next_block = nullptr;
auto status = block->Split(block->InnerSize() - sizeof(Block), &next_block);
@@ -216,7 +217,7 @@
alignas(Block*) byte bytes[kN];
Block* block = nullptr;
- Block::Init(span(bytes, kN), &block);
+ Block::Init(std::span(bytes, kN), &block);
block->MarkUsed();
EXPECT_EQ(block->Used(), true);
@@ -234,7 +235,7 @@
alignas(Block*) byte bytes[kN];
Block* block = nullptr;
- Block::Init(span(bytes, kN), &block);
+ Block::Init(std::span(bytes, kN), &block);
block->MarkUsed();
@@ -252,7 +253,7 @@
byte bytes[kN];
Block* block = nullptr;
- Block::Init(pw::span(bytes, kN), &block);
+ Block::Init(std::span(bytes, kN), &block);
Block* block2 = nullptr;
block->Split(kSplit1, &block2);
@@ -278,7 +279,7 @@
// Do a split, just to sanity check that the checks on Next/Prev are
// different...
Block* block = nullptr;
- Block::Init(span(bytes, kN), &block);
+ Block::Init(std::span(bytes, kN), &block);
Block* next_block = nullptr;
block->Split(512, &next_block);
@@ -294,7 +295,7 @@
// Do a split, just to sanity check that the checks on Next/Prev are
// different...
Block* block = nullptr;
- Block::Init(span(bytes, kN), &block);
+ Block::Init(std::span(bytes, kN), &block);
Block* next_block = nullptr;
block->Split(512, &next_block);
diff --git a/pw_allocator/freelist.cc b/pw_allocator/freelist.cc
index 34bcbb7..4629a4f 100644
--- a/pw_allocator/freelist.cc
+++ b/pw_allocator/freelist.cc
@@ -16,7 +16,7 @@
namespace pw::allocator {
-Status FreeList::AddChunk(span<std::byte> chunk) {
+Status FreeList::AddChunk(std::span<std::byte> chunk) {
// Check that the size is enough to actually store what we need
if (chunk.size() < sizeof(FreeListNode)) {
return Status::OUT_OF_RANGE;
@@ -39,9 +39,9 @@
return Status::OK;
}
-span<std::byte> FreeList::FindChunk(size_t size) const {
+std::span<std::byte> FreeList::FindChunk(size_t size) const {
if (size == 0) {
- return span<std::byte>();
+ return std::span<std::byte>();
}
size_t chunk_ptr = FindChunkPtrForSize(size, true);
@@ -49,7 +49,7 @@
// Check that there's data. This catches the case where we run off the
// end of the array
if (chunks_[chunk_ptr] == nullptr) {
- return span<std::byte>();
+ return std::span<std::byte>();
}
// Now iterate up the buckets, walking each list to find a good candidate
@@ -62,7 +62,7 @@
while (aliased.node != nullptr) {
if (aliased.node->size >= size) {
- return span<std::byte>(aliased.data, aliased.node->size);
+ return std::span<std::byte>(aliased.data, aliased.node->size);
}
aliased.node = aliased.node->next;
@@ -71,10 +71,10 @@
// If we get here, we've checked every block in every bucket. There's
// nothing that can support this allocation.
- return span<std::byte>();
+ return std::span<std::byte>();
}
-Status FreeList::RemoveChunk(span<std::byte> chunk) {
+Status FreeList::RemoveChunk(std::span<std::byte> chunk) {
size_t chunk_ptr = FindChunkPtrForSize(chunk.size(), true);
// Walk that list, finding the chunk.
diff --git a/pw_allocator/freelist_heap.cc b/pw_allocator/freelist_heap.cc
index 7966bb8..dfaba56 100644
--- a/pw_allocator/freelist_heap.cc
+++ b/pw_allocator/freelist_heap.cc
@@ -18,7 +18,7 @@
namespace pw::allocator {
-FreeListHeap::FreeListHeap(span<std::byte> region, FreeList& freelist)
+FreeListHeap::FreeListHeap(std::span<std::byte> region, FreeList& freelist)
: freelist_(freelist) {
Block* block;
Block::Init(region, &block);
diff --git a/pw_allocator/freelist_heap_test.cc b/pw_allocator/freelist_heap_test.cc
index 5356c43..a28b31d 100644
--- a/pw_allocator/freelist_heap_test.cc
+++ b/pw_allocator/freelist_heap_test.cc
@@ -14,8 +14,9 @@
#include "pw_allocator/freelist_heap.h"
+#include <span>
+
#include "gtest/gtest.h"
-#include "pw_span/span.h"
namespace pw::allocator {
diff --git a/pw_allocator/freelist_test.cc b/pw_allocator/freelist_test.cc
index 9a1c5a3..0484a7a 100644
--- a/pw_allocator/freelist_test.cc
+++ b/pw_allocator/freelist_test.cc
@@ -14,8 +14,9 @@
#include "pw_allocator/freelist.h"
+#include <span>
+
#include "gtest/gtest.h"
-#include "pw_span/span.h"
#include "pw_status/status.h"
using std::byte;
@@ -41,7 +42,7 @@
byte data[kN] = {std::byte(0)};
- auto status = list.AddChunk(pw::span(data, kN));
+ auto status = list.AddChunk(std::span(data, kN));
EXPECT_EQ(status, Status::OK);
auto item = list.FindChunk(kN);
@@ -55,7 +56,7 @@
byte data[kN] = {std::byte(0)};
- list.AddChunk(pw::span(data, kN));
+ list.AddChunk(std::span(data, kN));
auto item = list.FindChunk(kN / 2);
EXPECT_EQ(item.size(), kN);
EXPECT_EQ(item.data(), data);
@@ -67,8 +68,8 @@
byte data[kN] = {std::byte(0)};
- list.AddChunk(pw::span(data, kN));
- auto status = list.RemoveChunk(pw::span(data, kN));
+ list.AddChunk(std::span(data, kN));
+ auto status = list.RemoveChunk(std::span(data, kN));
EXPECT_EQ(status, Status::OK);
auto item = list.FindChunk(kN);
@@ -83,8 +84,8 @@
byte data1[kN1] = {std::byte(0)};
byte data2[kN2] = {std::byte(0)};
- list.AddChunk(pw::span(data1, kN1));
- list.AddChunk(pw::span(data2, kN2));
+ list.AddChunk(std::span(data1, kN1));
+ list.AddChunk(std::span(data2, kN2));
auto chunk = list.FindChunk(kN1 / 2);
EXPECT_EQ(chunk.size(), kN1);
@@ -110,8 +111,8 @@
byte data2[kN2] = {std::byte(0)};
// List should now be 257 -> 512 -> NULL
- list.AddChunk(pw::span(data1, kN1));
- list.AddChunk(pw::span(data2, kN2));
+ list.AddChunk(std::span(data1, kN1));
+ list.AddChunk(std::span(data2, kN2));
auto chunk = list.FindChunk(kN2 + 1);
EXPECT_EQ(chunk.size(), kN1);
@@ -130,8 +131,8 @@
// List should now be:
// bkt[3] (257 bytes up to 512 bytes) -> 257 -> NULL
// bkt[4] (513 bytes up to 1024 bytes) -> 513 -> NULL
- list.AddChunk(pw::span(data1, kN1));
- list.AddChunk(pw::span(data2, kN2));
+ list.AddChunk(std::span(data1, kN1));
+ list.AddChunk(std::span(data2, kN2));
// Request a 300 byte chunk. This should return the 513 byte one
auto chunk = list.FindChunk(kN1 + 1);
@@ -145,8 +146,8 @@
byte data[kN] = {std::byte(0)};
byte data2[kN] = {std::byte(0)};
- list.AddChunk(pw::span(data, kN));
- auto status = list.RemoveChunk(pw::span(data2, kN));
+ list.AddChunk(std::span(data, kN));
+ auto status = list.RemoveChunk(std::span(data2, kN));
EXPECT_EQ(status, Status::NOT_FOUND);
}
@@ -157,8 +158,8 @@
byte data1[kN] = {std::byte(0)};
byte data2[kN] = {std::byte(0)};
- list.AddChunk(pw::span(data1, kN));
- list.AddChunk(pw::span(data2, kN));
+ list.AddChunk(std::span(data1, kN));
+ list.AddChunk(std::span(data2, kN));
auto chunk1 = list.FindChunk(kN);
list.RemoveChunk(chunk1);
diff --git a/pw_allocator/public/pw_allocator/block.h b/pw_allocator/public/pw_allocator/block.h
index 2fa4052..e12349a 100644
--- a/pw_allocator/public/pw_allocator/block.h
+++ b/pw_allocator/public/pw_allocator/block.h
@@ -16,7 +16,8 @@
// usable.
#pragma once
-#include "pw_span/span.h"
+#include <span>
+
#include "pw_status/status.h"
namespace pw::allocator {
@@ -80,7 +81,7 @@
// Returns:
// INVALID_ARGUMENT if the given region is unaligned to too small, or
// OK otherwise.
- static Status Init(const span<std::byte> region, Block** block);
+ static Status Init(const std::span<std::byte> region, Block** block);
// Returns a pointer to a Block, given a pointer to the start of the usable
// space inside the block (i.e. the opposite operation to UsableSpace()). In
diff --git a/pw_allocator/public/pw_allocator/freelist.h b/pw_allocator/public/pw_allocator/freelist.h
index ac4444a..207edba 100644
--- a/pw_allocator/public/pw_allocator/freelist.h
+++ b/pw_allocator/public/pw_allocator/freelist.h
@@ -14,9 +14,9 @@
#pragma once
#include <array>
+#include <span>
#include "pw_containers/vector.h"
-#include "pw_span/span.h"
#include "pw_status/status.h"
namespace pw::allocator {
@@ -64,19 +64,19 @@
// OK: The chunk was added successfully
// OUT_OF_RANGE: The chunk could not be added for size reasons (e.g. if
// the chunk is too small to store the FreeListNode).
- Status AddChunk(span<std::byte> chunk);
+ Status AddChunk(std::span<std::byte> chunk);
// Finds an eligible chunk for an allocation of size `size`. Note that this
// will return the first allocation possible within a given bucket, it does
- // not currently optimize for finding the smallest chunk. Returns a pw::span
+ // not currently optimize for finding the smallest chunk. Returns a std::span
// representing the chunk. This will be "valid" on success, and will have size
// = 0 on failure (if there were no chunks available for that allocation).
- span<std::byte> FindChunk(size_t size) const;
+ std::span<std::byte> FindChunk(size_t size) const;
// Remove a chunk from this freelist. Returns:
// OK: The chunk was removed successfully
// NOT_FOUND: The chunk could not be found in this freelist.
- Status RemoveChunk(span<std::byte> chunk);
+ Status RemoveChunk(std::span<std::byte> chunk);
private:
// For a given size, find which index into chunks_ the node should be written
diff --git a/pw_allocator/public/pw_allocator/freelist_heap.h b/pw_allocator/public/pw_allocator/freelist_heap.h
index c3c015e..cf44ffd 100644
--- a/pw_allocator/public/pw_allocator/freelist_heap.h
+++ b/pw_allocator/public/pw_allocator/freelist_heap.h
@@ -15,16 +15,16 @@
#pragma once
#include <cstddef>
+#include <span>
#include "pw_allocator/block.h"
#include "pw_allocator/freelist.h"
-#include "pw_span/span.h"
namespace pw::allocator {
class FreeListHeap {
public:
- FreeListHeap(span<std::byte> region, FreeList& freelist);
+ FreeListHeap(std::span<std::byte> region, FreeList& freelist);
void* Allocate(size_t size);
void Free(void* ptr);
@@ -32,11 +32,11 @@
void* Calloc(size_t num, size_t size);
private:
- span<std::byte> BlockToSpan(Block* block) {
- return span<std::byte>(block->UsableSpace(), block->InnerSize());
+ std::span<std::byte> BlockToSpan(Block* block) {
+ return std::span<std::byte>(block->UsableSpace(), block->InnerSize());
}
- span<std::byte> region_;
+ std::span<std::byte> region_;
FreeList& freelist_;
};
@@ -46,7 +46,7 @@
static constexpr std::array<size_t, N> defaultBuckets{
16, 32, 64, 128, 256, 512};
- FreeListHeapBuffer(span<std::byte> region)
+ FreeListHeapBuffer(std::span<std::byte> region)
: freelist_(defaultBuckets), heap_(region, freelist_) {}
void* Allocate(size_t size) { return heap_.Allocate(size); }
diff --git a/pw_assert/fake_backend.cc b/pw_assert/fake_backend.cc
index b81c106..8ab2279 100644
--- a/pw_assert/fake_backend.cc
+++ b/pw_assert/fake_backend.cc
@@ -15,8 +15,8 @@
#include "pw_assert_test/fake_backend.h"
#include <cstring>
+#include <span>
-#include "pw_span/span.h"
#include "pw_string/string_builder.h"
// Global that's publicly accessible to read captured assert contents.
diff --git a/pw_base64/base64.cc b/pw_base64/base64.cc
index c708bb5..7b2396c 100644
--- a/pw_base64/base64.cc
+++ b/pw_base64/base64.cc
@@ -154,7 +154,8 @@
return true;
}
-size_t Encode(span<const std::byte> binary, span<char> output_buffer) {
+size_t Encode(std::span<const std::byte> binary,
+ std::span<char> output_buffer) {
const size_t required_size = EncodedSize(binary.size_bytes());
if (output_buffer.size_bytes() < required_size) {
return 0;
@@ -163,7 +164,7 @@
return required_size;
}
-size_t Decode(std::string_view base64, span<std::byte> output_buffer) {
+size_t Decode(std::string_view base64, std::span<std::byte> output_buffer) {
if (output_buffer.size_bytes() < MaxDecodedSize(base64.size()) ||
!IsValid(base64)) {
return 0;
diff --git a/pw_base64/base64_test.cc b/pw_base64/base64_test.cc
index 0dfcfd7..17e5348 100644
--- a/pw_base64/base64_test.cc
+++ b/pw_base64/base64_test.cc
@@ -285,7 +285,8 @@
for (const EncodedData& data : kSingleCharTestData) {
const size_t size = EncodedSize(data.binary_size);
ASSERT_EQ(std::strlen(data.encoded_data), size);
- Encode(as_bytes(span(data.binary_data, data.binary_size)), output);
+ Encode(std::as_bytes(std::span(data.binary_data, data.binary_size)),
+ output);
output[size] = '\0';
EXPECT_STREQ(data.encoded_data, output);
}
@@ -296,7 +297,8 @@
for (const EncodedData& data : kRandomTestData) {
const size_t size = EncodedSize(data.binary_size);
ASSERT_EQ(std::strlen(data.encoded_data), size);
- Encode(as_bytes(span(data.binary_data, data.binary_size)), output);
+ Encode(std::as_bytes(std::span(data.binary_data, data.binary_size)),
+ output);
output[size] = '\0';
EXPECT_STREQ(data.encoded_data, output);
}
@@ -306,9 +308,9 @@
constexpr std::byte data[] = {std::byte{'h'}, std::byte{'i'}};
char output[5] = {};
- EXPECT_EQ(0u, Encode(data, span(output, 3)));
+ EXPECT_EQ(0u, Encode(data, std::span(output, 3)));
EXPECT_STREQ("", output);
- EXPECT_EQ(4u, Encode(data, span(output, 4)));
+ EXPECT_EQ(4u, Encode(data, std::span(output, 4)));
EXPECT_STREQ("aGk=", output);
}
@@ -334,9 +336,9 @@
constexpr const char encoded_data[] = "aGk=";
std::byte output[4] = {};
- EXPECT_EQ(0u, Decode(encoded_data, span(output, 2)));
+ EXPECT_EQ(0u, Decode(encoded_data, std::span(output, 2)));
EXPECT_STREQ("", reinterpret_cast<const char*>(output));
- EXPECT_EQ(2u, Decode(encoded_data, span(output, 3)));
+ EXPECT_EQ(2u, Decode(encoded_data, std::span(output, 3)));
EXPECT_STREQ("hi", reinterpret_cast<const char*>(output));
}
@@ -360,7 +362,7 @@
TEST(Base64, Empty) {
char buffer[] = "DO NOT TOUCH";
EXPECT_EQ(0u, EncodedSize(0));
- Encode(as_bytes(span("Something cool!!!", 0)), buffer);
+ Encode(std::as_bytes(std::span("Something cool!!!", 0)), buffer);
EXPECT_STREQ("DO NOT TOUCH", buffer);
EXPECT_EQ(0u, MaxDecodedSize(0));
@@ -372,11 +374,11 @@
constexpr uint8_t input[] = {0x14, 0xfb, 0x9c, 0x03, 0xd9, 0x7e};
char output[EncodedSize(sizeof(input)) + 1] = {};
- Encode(as_bytes(span(input)), output);
+ Encode(std::as_bytes(std::span(input)), output);
EXPECT_STREQ("FPucA9l+", output);
- Encode(as_bytes(span(input, 5)), output);
+ Encode(std::as_bytes(std::span(input, 5)), output);
EXPECT_STREQ("FPucA9k=", output);
- Encode(as_bytes(span(input, 4)), output);
+ Encode(std::as_bytes(std::span(input, 4)), output);
EXPECT_STREQ("FPucAw==", output);
EXPECT_EQ(6u, Decode("FPucA9l+", output));
@@ -391,19 +393,19 @@
char output[EncodedSize(sizeof("foobar")) + 1] = {};
const std::byte* foobar = reinterpret_cast<const std::byte*>("foobar");
- Encode(span(foobar, 0), output);
+ Encode(std::span(foobar, 0), output);
EXPECT_STREQ("", output);
- Encode(span(foobar, 1), output);
+ Encode(std::span(foobar, 1), output);
EXPECT_STREQ("Zg==", output);
- Encode(span(foobar, 2), output);
+ Encode(std::span(foobar, 2), output);
EXPECT_STREQ("Zm8=", output);
- Encode(span(foobar, 3), output);
+ Encode(std::span(foobar, 3), output);
EXPECT_STREQ("Zm9v", output);
- Encode(span(foobar, 4), output);
+ Encode(std::span(foobar, 4), output);
EXPECT_STREQ("Zm9vYg==", output);
- Encode(span(foobar, 5), output);
+ Encode(std::span(foobar, 5), output);
EXPECT_STREQ("Zm9vYmE=", output);
- Encode(span(foobar, 6), output);
+ Encode(std::span(foobar, 6), output);
EXPECT_STREQ("Zm9vYmFy", output);
std::memset(output, '\0', sizeof(output));
diff --git a/pw_base64/public/pw_base64/base64.h b/pw_base64/public/pw_base64/base64.h
index 24c425e..e90510c 100644
--- a/pw_base64/public/pw_base64/base64.h
+++ b/pw_base64/public/pw_base64/base64.h
@@ -63,11 +63,10 @@
#ifdef __cplusplus
} // extern "C"
+#include <span>
#include <string_view>
#include <type_traits>
-#include "pw_span/span.h"
-
namespace pw::base64 {
// Returns the size of the given number of bytes when encoded as Base64. Base64
@@ -84,14 +83,14 @@
// output buffers MUST NOT be the same; encoding cannot occur in place.
//
// The resulting string in the output is NOT null-terminated!
-inline void Encode(span<const std::byte> binary, char* output) {
+inline void Encode(std::span<const std::byte> binary, char* output) {
pw_Base64Encode(binary.data(), binary.size_bytes(), output);
}
// Encodes the provided data in Base64 if the result fits in the provided
// buffer. Returns the number of bytes written, which will be 0 if the output
// buffer is too small.
-size_t Encode(span<const std::byte> binary, span<char> output_buffer);
+size_t Encode(std::span<const std::byte> binary, std::span<char> output_buffer);
// Returns the maximum size of decoded Base64 data in bytes. base64_size_bytes
// must be a multiple of 4, since Base64 encodes 3-byte groups into 4-character
@@ -117,7 +116,7 @@
// Decodes the provided Base64 data, if the data is valid and fits in the output
// buffer. Returns the number of bytes written, which will be 0 if the data is
// invalid or doesn't fit.
-size_t Decode(std::string_view base64, span<std::byte> output_buffer);
+size_t Decode(std::string_view base64, std::span<std::byte> output_buffer);
// Returns true if the provided string is valid Base64 encoded data. Accepts
// either the standard (+/) or URL-safe (-_) alphabets.
diff --git a/pw_checksum/ccitt_crc16_test.cc b/pw_checksum/ccitt_crc16_test.cc
index 19b9c9c..e78f0e9 100644
--- a/pw_checksum/ccitt_crc16_test.cc
+++ b/pw_checksum/ccitt_crc16_test.cc
@@ -35,7 +35,7 @@
constexpr uint16_t kStringCrc = 0xC184;
TEST(Crc16, Empty) {
- EXPECT_EQ(CcittCrc16(span<std::byte>()), kCcittCrc16DefaultInitialValue);
+ EXPECT_EQ(CcittCrc16(std::span<std::byte>()), kCcittCrc16DefaultInitialValue);
}
TEST(Crc16, ByteByByte) {
@@ -47,11 +47,11 @@
}
TEST(Crc16, Buffer) {
- EXPECT_EQ(CcittCrc16(as_bytes(span(kBytes))), kBufferCrc);
+ EXPECT_EQ(CcittCrc16(std::as_bytes(std::span(kBytes))), kBufferCrc);
}
TEST(Crc16, String) {
- EXPECT_EQ(CcittCrc16(as_bytes(span(kString))), kStringCrc);
+ EXPECT_EQ(CcittCrc16(std::as_bytes(std::span(kString))), kStringCrc);
}
extern "C" uint16_t CallChecksumCcittCrc16(const void* data, size_t size_bytes);
diff --git a/pw_checksum/public/pw_checksum/ccitt_crc16.h b/pw_checksum/public/pw_checksum/ccitt_crc16.h
index c5679a8..4d43f93 100644
--- a/pw_checksum/public/pw_checksum/ccitt_crc16.h
+++ b/pw_checksum/public/pw_checksum/ccitt_crc16.h
@@ -34,7 +34,7 @@
#ifdef __cplusplus
} // extern "C"
-#include "pw_span/span.h"
+#include <span>
namespace pw::checksum {
@@ -43,7 +43,7 @@
// Calculates the CCITT CRC16 for the provided data. To update an existing CRC,
// pass the previous value as the initial_value argument.
inline uint16_t CcittCrc16(
- span<const std::byte> data,
+ std::span<const std::byte> data,
uint16_t initial_value = kCcittCrc16DefaultInitialValue) {
return pw_ChecksumCcittCrc16(data.data(), data.size_bytes(), initial_value);
}
diff --git a/pw_cpu_exception/public/pw_cpu_exception/cpu_exception.h b/pw_cpu_exception/public/pw_cpu_exception/cpu_exception.h
index c01d25f..b9b76f2 100644
--- a/pw_cpu_exception/public/pw_cpu_exception/cpu_exception.h
+++ b/pw_cpu_exception/public/pw_cpu_exception/cpu_exception.h
@@ -28,9 +28,9 @@
// some part of your application.
#include <cstdint>
+#include <span>
#include "pw_preprocessor/compiler.h"
-#include "pw_span/span.h"
#include "pw_string/string_builder.h"
namespace pw::cpu_exception {
@@ -40,7 +40,7 @@
// Gets raw CPU state as a single contiguous block of data. The particular
// contents will depend on the specific backend and platform.
-span<const uint8_t> RawFaultingCpuState(const CpuState& cpu_state);
+std::span<const uint8_t> RawFaultingCpuState(const CpuState& cpu_state);
// Writes CPU state as a formatted string to a string builder.
// NEVER depend on the format of this output. This is exclusively FYI human
diff --git a/pw_cpu_exception_armv7m/cpu_state.cc b/pw_cpu_exception_armv7m/cpu_state.cc
index 9526c60..d3245a4 100644
--- a/pw_cpu_exception_armv7m/cpu_state.cc
+++ b/pw_cpu_exception_armv7m/cpu_state.cc
@@ -16,15 +16,16 @@
#include <cinttypes>
#include <cstdint>
+#include <span>
#include "pw_cpu_exception/cpu_exception.h"
-#include "pw_span/span.h"
#include "pw_string/string_builder.h"
namespace pw::cpu_exception {
-span<const uint8_t> RawFaultingCpuState(const CpuState& cpu_state) {
- return span(reinterpret_cast<const uint8_t*>(&cpu_state), sizeof(cpu_state));
+std::span<const uint8_t> RawFaultingCpuState(const CpuState& cpu_state) {
+ return std::span(reinterpret_cast<const uint8_t*>(&cpu_state),
+ sizeof(cpu_state));
}
// Using this function adds approximately 100 bytes to binary size.
diff --git a/pw_cpu_exception_armv7m/exception_entry_test.cc b/pw_cpu_exception_armv7m/exception_entry_test.cc
index 545c7a1..fbd5fb3 100644
--- a/pw_cpu_exception_armv7m/exception_entry_test.cc
+++ b/pw_cpu_exception_armv7m/exception_entry_test.cc
@@ -13,12 +13,12 @@
// the License.
#include <cstdint>
+#include <span>
#include <type_traits>
#include "gtest/gtest.h"
#include "pw_cpu_exception/cpu_exception.h"
#include "pw_cpu_exception_armv7m/cpu_state.h"
-#include "pw_span/span.h"
namespace pw::cpu_exception {
namespace {
@@ -137,7 +137,7 @@
CpuState captured_states[kMaxFaultDepth] = {};
CpuState& captured_state = captured_states[0];
-// Flag used to check if the contents of span matches the captured state.
+// Flag used to check if the contents of std::span matches the captured state.
bool span_matches = false;
// Variable to be manipulated by function that uses floating
@@ -582,8 +582,8 @@
// Copy captured state to check later.
std::memcpy(&captured_states[exceptions_handled], state, sizeof(CpuState));
- // Ensure span compares to be the same.
- span<const uint8_t> state_span = RawFaultingCpuState(*state);
+ // Ensure std::span compares to be the same.
+ std::span<const uint8_t> state_span = RawFaultingCpuState(*state);
EXPECT_EQ(state_span.size(), sizeof(CpuState));
if (std::memcmp(state, state_span.data(), state_span.size()) == 0) {
span_matches = true;
diff --git a/pw_kvs/alignment.cc b/pw_kvs/alignment.cc
index 081d6c8..198ec14 100644
--- a/pw_kvs/alignment.cc
+++ b/pw_kvs/alignment.cc
@@ -18,7 +18,7 @@
namespace pw {
-StatusWithSize AlignedWriter::Write(span<const std::byte> data) {
+StatusWithSize AlignedWriter::Write(std::span<const std::byte> data) {
while (!data.empty()) {
size_t to_copy = std::min(write_size_ - bytes_in_buffer_, data.size());
diff --git a/pw_kvs/alignment_test.cc b/pw_kvs/alignment_test.cc
index 2b25e94..0f3dc89 100644
--- a/pw_kvs/alignment_test.cc
+++ b/pw_kvs/alignment_test.cc
@@ -125,11 +125,11 @@
"123456789_123456789_123456789_123456789_123456789_" // 50
"123456789_123456789_123456789_123456789_123456789_"; // 100
-const span<const byte> kBytes = as_bytes(span(kData));
+const std::span<const byte> kBytes = std::as_bytes(std::span(kData));
// The output function checks that the data is properly aligned and matches
// the expected value (should always be 123456789_...).
-OutputToFunction check_against_data([](span<const byte> data) {
+OutputToFunction check_against_data([](std::span<const byte> data) {
EXPECT_EQ(data.size() % kAlignment, 0u);
EXPECT_EQ(kData.substr(0, data.size()),
std::string_view(reinterpret_cast<const char*>(data.data()),
@@ -168,14 +168,14 @@
static size_t called_with_bytes;
called_with_bytes = 0;
- OutputToFunction output([](span<const byte> data) {
+ OutputToFunction output([](std::span<const byte> data) {
called_with_bytes += data.size();
return StatusWithSize(data.size());
});
{
AlignedWriterBuffer<64> writer(3, output);
- writer.Write(as_bytes(span("What is this?")));
+ writer.Write(std::as_bytes(std::span("What is this?")));
EXPECT_EQ(called_with_bytes, 0u); // Buffer not full; no output yet.
}
@@ -191,7 +191,7 @@
enum { kKeepGoing, kBreakOnNext, kBroken } state = kKeepGoing;
private:
- StatusWithSize DoWrite(span<const byte> data) override {
+ StatusWithSize DoWrite(std::span<const byte> data) override {
switch (state) {
case kKeepGoing:
return StatusWithSize(data.size());
@@ -211,10 +211,11 @@
{
AlignedWriterBuffer<4> writer(3, output);
- writer.Write(as_bytes(span("Everything is fine.")));
+ writer.Write(std::as_bytes(std::span("Everything is fine.")));
output.state = OutputWithErrorInjection::kBreakOnNext;
EXPECT_EQ(Status::UNKNOWN,
- writer.Write(as_bytes(span("No more writes, okay?"))).status());
+ writer.Write(std::as_bytes(std::span("No more writes, okay?")))
+ .status());
writer.Flush();
}
}
@@ -223,34 +224,36 @@
static Status return_status;
return_status = Status::OK;
- OutputToFunction output([](span<const byte> data) {
+ OutputToFunction output([](std::span<const byte> data) {
return StatusWithSize(return_status, data.size());
});
AlignedWriterBuffer<22> writer(10, output);
- StatusWithSize result = writer.Write(as_bytes(span("12345678901"sv)));
+ StatusWithSize result =
+ writer.Write(std::as_bytes(std::span("12345678901"sv)));
EXPECT_EQ(Status::OK, result.status());
EXPECT_EQ(0u, result.size()); // No writes; haven't filled buffer.
- result = writer.Write(as_bytes(span("2345678901"sv)));
+ result = writer.Write(std::as_bytes(std::span("2345678901"sv)));
EXPECT_EQ(Status::OK, result.status());
EXPECT_EQ(20u, result.size());
return_status = Status::PERMISSION_DENIED;
- result = writer.Write(as_bytes(span("2345678901234567890"sv)));
+ result = writer.Write(std::as_bytes(std::span("2345678901234567890"sv)));
EXPECT_EQ(Status::PERMISSION_DENIED, result.status());
EXPECT_EQ(40u, result.size());
}
TEST(AlignedWriter, Flush_Ok_ReturnsTotalBytesWritten) {
OutputToFunction output(
- [](span<const byte> data) { return StatusWithSize(data.size()); });
+ [](std::span<const byte> data) { return StatusWithSize(data.size()); });
AlignedWriterBuffer<4> writer(2, output);
- EXPECT_EQ(Status::OK, writer.Write(as_bytes(span("12345678901"sv))).status());
+ EXPECT_EQ(Status::OK,
+ writer.Write(std::as_bytes(std::span("12345678901"sv))).status());
StatusWithSize result = writer.Flush();
EXPECT_EQ(Status::OK, result.status());
@@ -258,13 +261,13 @@
}
TEST(AlignedWriter, Flush_Error_ReturnsTotalBytesWritten) {
- OutputToFunction output([](span<const byte> data) {
+ OutputToFunction output([](std::span<const byte> data) {
return StatusWithSize(Status::ABORTED, data.size());
});
AlignedWriterBuffer<20> writer(10, output);
- EXPECT_EQ(0u, writer.Write(as_bytes(span("12345678901"sv))).size());
+ EXPECT_EQ(0u, writer.Write(std::as_bytes(std::span("12345678901"sv))).size());
StatusWithSize result = writer.Flush();
EXPECT_EQ(Status::ABORTED, result.status());
@@ -277,7 +280,7 @@
void BreakOnIndex(size_t index) { break_on_index_ = index; }
private:
- StatusWithSize DoRead(span<byte> data) override {
+ StatusWithSize DoRead(std::span<byte> data) override {
EXPECT_LE(index_ + data.size(), kBytes.size());
if (index_ + data.size() > kBytes.size()) {
diff --git a/pw_kvs/checksum.cc b/pw_kvs/checksum.cc
index f5db069..0a885f7 100644
--- a/pw_kvs/checksum.cc
+++ b/pw_kvs/checksum.cc
@@ -20,7 +20,7 @@
using std::byte;
-Status ChecksumAlgorithm::Verify(span<const byte> checksum) const {
+Status ChecksumAlgorithm::Verify(std::span<const byte> checksum) const {
if (checksum.size() < size_bytes()) {
return Status::INVALID_ARGUMENT;
}
diff --git a/pw_kvs/checksum_test.cc b/pw_kvs/checksum_test.cc
index 4f0d8c5..0db5ed2 100644
--- a/pw_kvs/checksum_test.cc
+++ b/pw_kvs/checksum_test.cc
@@ -32,19 +32,20 @@
ChecksumAlgorithm& algo = crc16_algo;
algo.Update(kString.data(), kString.size());
- EXPECT_EQ(Status::OK, algo.Verify(as_bytes(span(&kStringCrc, 1))));
+ EXPECT_EQ(Status::OK, algo.Verify(std::as_bytes(std::span(&kStringCrc, 1))));
}
TEST(Checksum, Verify_Failure) {
ChecksumCrc16 algo;
- EXPECT_EQ(Status::DATA_LOSS, algo.Verify(as_bytes(span(kString.data(), 2))));
+ EXPECT_EQ(Status::DATA_LOSS,
+ algo.Verify(std::as_bytes(std::span(kString.data(), 2))));
}
TEST(Checksum, Verify_InvalidSize) {
ChecksumCrc16 algo;
EXPECT_EQ(Status::INVALID_ARGUMENT, algo.Verify({}));
EXPECT_EQ(Status::INVALID_ARGUMENT,
- algo.Verify(as_bytes(span(kString.substr(0, 1)))));
+ algo.Verify(std::as_bytes(std::span(kString.substr(0, 1)))));
}
TEST(Checksum, Verify_LargerState_ComparesToTruncatedData) {
@@ -52,17 +53,17 @@
ChecksumCrc16 algo;
ASSERT_GT(sizeof(crc), algo.size_bytes());
- algo.Update(as_bytes(span(kString)));
+ algo.Update(std::as_bytes(std::span(kString)));
EXPECT_EQ(Status::OK, algo.Verify(crc));
}
TEST(Checksum, Reset) {
ChecksumCrc16 crc_algo;
- crc_algo.Update(as_bytes(span(kString)));
+ crc_algo.Update(std::as_bytes(std::span(kString)));
crc_algo.Reset();
- span state = crc_algo.Finish();
+ std::span state = crc_algo.Finish();
EXPECT_EQ(state[0], byte{0xFF});
EXPECT_EQ(state[1], byte{0xFF});
}
@@ -76,13 +77,13 @@
TEST(IgnoreChecksum, NeverUpdate_VerifyWithData) {
IgnoreChecksum checksum;
- EXPECT_EQ(Status::OK, checksum.Verify(as_bytes(span(kString))));
+ EXPECT_EQ(Status::OK, checksum.Verify(std::as_bytes(std::span(kString))));
}
TEST(IgnoreChecksum, AfterUpdate_Verify) {
IgnoreChecksum checksum;
- checksum.Update(as_bytes(span(kString)));
+ checksum.Update(std::as_bytes(std::span(kString)));
EXPECT_EQ(Status::OK, checksum.Verify({}));
}
@@ -91,7 +92,7 @@
constexpr std::string_view kData =
"123456789_123456789_123456789_123456789_123456789_" // 50
"123456789_123456789_123456789_123456789_123456789_"; // 100
-const span<const byte> kBytes = as_bytes(span(kData));
+const std::span<const byte> kBytes = std::as_bytes(std::span(kData));
class PickyChecksum final : public AlignedChecksum<kAlignment, 32> {
public:
@@ -101,7 +102,7 @@
void FinalizeAligned() override { EXPECT_EQ(kData.size(), size_); }
- void UpdateAligned(span<const std::byte> data) override {
+ void UpdateAligned(std::span<const std::byte> data) override {
ASSERT_EQ(data.size() % kAlignment, 0u);
EXPECT_EQ(kData.substr(0, data.size()),
std::string_view(reinterpret_cast<const char*>(data.data()),
diff --git a/pw_kvs/entry.cc b/pw_kvs/entry.cc
index 801a636..3343548 100644
--- a/pw_kvs/entry.cc
+++ b/pw_kvs/entry.cc
@@ -34,7 +34,7 @@
EntryHeader header;
TRY(partition.Read(address, sizeof(header), &header));
- if (partition.AppearsErased(as_bytes(span(&header.magic, 1)))) {
+ if (partition.AppearsErased(std::as_bytes(std::span(&header.magic, 1)))) {
return Status::NOT_FOUND;
}
if (header.key_length_bytes > kMaxKeyLength) {
@@ -69,7 +69,7 @@
Address address,
const EntryFormat& format,
string_view key,
- span<const byte> value,
+ std::span<const byte> value,
uint16_t value_size_bytes,
uint32_t transaction_id)
: Entry(&partition,
@@ -83,19 +83,21 @@
.value_size_bytes = value_size_bytes,
.transaction_id = transaction_id}) {
if (checksum_algo_ != nullptr) {
- span<const byte> checksum = CalculateChecksum(key, value);
+ std::span<const byte> checksum = CalculateChecksum(key, value);
std::memcpy(&header_.checksum,
checksum.data(),
std::min(checksum.size(), sizeof(header_.checksum)));
}
}
-StatusWithSize Entry::Write(string_view key, span<const byte> value) const {
+StatusWithSize Entry::Write(string_view key,
+ std::span<const byte> value) const {
FlashPartition::Output flash(partition(), address_);
- return AlignedWrite<64>(
- flash,
- alignment_bytes(),
- {as_bytes(span(&header_, 1)), as_bytes(span(key)), value});
+ return AlignedWrite<64>(flash,
+ alignment_bytes(),
+ {std::as_bytes(std::span(&header_, 1)),
+ std::as_bytes(std::span(key)),
+ value});
}
Status Entry::Update(const EntryFormat& new_format,
@@ -132,7 +134,8 @@
return writer.Flush();
}
-StatusWithSize Entry::ReadValue(span<byte> buffer, size_t offset_bytes) const {
+StatusWithSize Entry::ReadValue(std::span<byte> buffer,
+ size_t offset_bytes) const {
if (offset_bytes > value_size()) {
return StatusWithSize::OUT_OF_RANGE;
}
@@ -151,7 +154,7 @@
return StatusWithSize(read_size);
}
-Status Entry::ValueMatches(span<const std::byte> value) const {
+Status Entry::ValueMatches(std::span<const std::byte> value) const {
if (value_size() != value.size_bytes()) {
return Status::NOT_FOUND;
}
@@ -163,7 +166,7 @@
std::array<std::byte, 2 * kMinAlignmentBytes> buffer;
while (address < end) {
const size_t read_size = std::min(size_t(end - address), buffer.size());
- TRY(partition_->Read(address, span(buffer).first(read_size)));
+ TRY(partition_->Read(address, std::span(buffer).first(read_size)));
if (std::memcmp(buffer.data(), value_ptr, read_size) != 0) {
return Status::NOT_FOUND;
@@ -176,7 +179,8 @@
return Status::OK;
}
-Status Entry::VerifyChecksum(string_view key, span<const byte> value) const {
+Status Entry::VerifyChecksum(string_view key,
+ std::span<const byte> value) const {
if (checksum_algo_ == nullptr) {
return header_.checksum == 0 ? Status::OK : Status::DATA_LOSS;
}
@@ -247,8 +251,8 @@
PW_LOG_DEBUG(" Alignment = 0x%x", unsigned(alignment_bytes()));
}
-span<const byte> Entry::CalculateChecksum(const string_view key,
- span<const byte> value) const {
+std::span<const byte> Entry::CalculateChecksum(
+ const string_view key, std::span<const byte> value) const {
checksum_algo_->Reset();
{
@@ -256,7 +260,7 @@
header_for_checksum.checksum = 0;
checksum_algo_->Update(&header_for_checksum, sizeof(header_for_checksum));
- checksum_algo_->Update(as_bytes(span(key)));
+ checksum_algo_->Update(std::as_bytes(std::span(key)));
checksum_algo_->Update(value);
}
@@ -283,7 +287,7 @@
std::array<std::byte, 2 * kMinAlignmentBytes> buffer;
while (address < end) {
const size_t read_size = std::min(size_t(end - address), buffer.size());
- TRY(partition_->Read(address, span(buffer).first(read_size)));
+ TRY(partition_->Read(address, std::span(buffer).first(read_size)));
checksum_algo_->Update(buffer.data(), read_size);
address += read_size;
@@ -291,7 +295,7 @@
AddPaddingBytesToChecksum();
- span checksum = checksum_algo_->Finish();
+ std::span checksum = checksum_algo_->Finish();
std::memcpy(&header_.checksum,
checksum.data(),
std::min(checksum.size(), sizeof(header_.checksum)));
diff --git a/pw_kvs/entry_cache.cc b/pw_kvs/entry_cache.cc
index 599ae80..116f27f 100644
--- a/pw_kvs/entry_cache.cc
+++ b/pw_kvs/entry_cache.cc
@@ -44,7 +44,7 @@
// Remove the back entry of the address list.
addresses_.back() = kNoAddress;
- addresses_ = span(addresses_.begin(), addresses_.size() - 1);
+ addresses_ = std::span(addresses_.begin(), addresses_.size() - 1);
break;
}
}
@@ -123,7 +123,7 @@
// TODO(hepler): DCHECK(!full());
Address* first_address = ResetAddresses(descriptors_.size(), entry_address);
descriptors_.push_back(descriptor);
- return EntryMetadata(descriptors_.back(), span(first_address, 1));
+ return EntryMetadata(descriptors_.back(), std::span(first_address, 1));
}
// TODO: This method is the trigger of the O(valid_entries * all_entries) time
@@ -214,7 +214,8 @@
}
}
-span<EntryCache::Address> EntryCache::addresses(size_t descriptor_index) const {
+std::span<EntryCache::Address> EntryCache::addresses(
+ size_t descriptor_index) const {
Address* const addresses = first_address(descriptor_index);
size_t size = 0;
@@ -222,7 +223,7 @@
size += 1;
}
- return span(addresses, size);
+ return std::span(addresses, size);
}
EntryCache::Address* EntryCache::ResetAddresses(size_t descriptor_index,
diff --git a/pw_kvs/entry_test.cc b/pw_kvs/entry_test.cc
index 553ed52..d250039 100644
--- a/pw_kvs/entry_test.cc
+++ b/pw_kvs/entry_test.cc
@@ -14,6 +14,7 @@
#include "pw_kvs/internal/entry.h"
+#include <span>
#include <string_view>
#include "gtest/gtest.h"
@@ -24,7 +25,6 @@
#include "pw_kvs/flash_memory.h"
#include "pw_kvs/format.h"
#include "pw_kvs_private/byte_utils.h"
-#include "pw_span/span.h"
namespace pw::kvs::internal {
namespace {
@@ -58,8 +58,8 @@
FakeFlashMemoryBuffer<64, 2> flash(16);
FlashPartition partition(&flash, 0, flash.sector_count());
- auto entry =
- Entry::Valid(partition, 1, kFormat, "k", as_bytes(span("123")), 9876);
+ auto entry = Entry::Valid(
+ partition, 1, kFormat, "k", std::as_bytes(std::span("123")), 9876);
EXPECT_FALSE(entry.deleted());
EXPECT_EQ(entry.magic(), kFormat.magic);
@@ -138,7 +138,7 @@
TEST_F(ValidEntryInFlash, ReadValue) {
char value[32] = {};
- auto result = entry_.ReadValue(as_writable_bytes(span(value)));
+ auto result = entry_.ReadValue(std::as_writable_bytes(std::span(value)));
ASSERT_EQ(Status::OK, result.status());
EXPECT_EQ(result.size(), entry_.value_size());
@@ -147,7 +147,7 @@
TEST_F(ValidEntryInFlash, ReadValue_BufferTooSmall) {
char value[3] = {};
- auto result = entry_.ReadValue(as_writable_bytes(span(value)));
+ auto result = entry_.ReadValue(std::as_writable_bytes(std::span(value)));
ASSERT_EQ(Status::RESOURCE_EXHAUSTED, result.status());
EXPECT_EQ(3u, result.size());
@@ -158,7 +158,7 @@
TEST_F(ValidEntryInFlash, ReadValue_WithOffset) {
char value[3] = {};
- auto result = entry_.ReadValue(as_writable_bytes(span(value)), 3);
+ auto result = entry_.ReadValue(std::as_writable_bytes(std::span(value)), 3);
ASSERT_EQ(Status::OK, result.status());
EXPECT_EQ(3u, result.size());
@@ -169,7 +169,7 @@
TEST_F(ValidEntryInFlash, ReadValue_WithOffset_BufferTooSmall) {
char value[1] = {};
- auto result = entry_.ReadValue(as_writable_bytes(span(value)), 4);
+ auto result = entry_.ReadValue(std::as_writable_bytes(std::span(value)), 4);
ASSERT_EQ(Status::RESOURCE_EXHAUSTED, result.status());
EXPECT_EQ(1u, result.size());
@@ -178,7 +178,7 @@
TEST_F(ValidEntryInFlash, ReadValue_WithOffset_EmptyRead) {
char value[16] = {'?'};
- auto result = entry_.ReadValue(as_writable_bytes(span(value)), 6);
+ auto result = entry_.ReadValue(std::as_writable_bytes(std::span(value)), 6);
ASSERT_EQ(Status::OK, result.status());
EXPECT_EQ(0u, result.size());
@@ -187,7 +187,7 @@
TEST_F(ValidEntryInFlash, ReadValue_WithOffset_PastEnd) {
char value[16] = {};
- auto result = entry_.ReadValue(as_writable_bytes(span(value)), 7);
+ auto result = entry_.ReadValue(std::as_writable_bytes(std::span(value)), 7);
EXPECT_EQ(Status::OUT_OF_RANGE, result.status());
EXPECT_EQ(0u, result.size());
@@ -254,7 +254,7 @@
TEST_F(TombstoneEntryInFlash, ReadValue) {
char value[32] = {};
- auto result = entry_.ReadValue(as_writable_bytes(span(value)));
+ auto result = entry_.ReadValue(std::as_writable_bytes(std::span(value)));
ASSERT_EQ(Status::OK, result.status());
EXPECT_EQ(0u, result.size());
@@ -366,7 +366,7 @@
EXPECT_EQ(0u, result.size());
}
-constexpr uint32_t ByteSum(span<const byte> bytes, uint32_t value = 0) {
+constexpr uint32_t ByteSum(std::span<const byte> bytes, uint32_t value = 0) {
for (byte b : bytes) {
value += unsigned(b);
}
@@ -376,11 +376,12 @@
// Sums the bytes, adding one to each byte so that zeroes change the checksum.
class ChecksumSummation final : public ChecksumAlgorithm {
public:
- ChecksumSummation() : ChecksumAlgorithm(as_bytes(span(&sum_, 1))), sum_(0) {}
+ ChecksumSummation()
+ : ChecksumAlgorithm(std::as_bytes(std::span(&sum_, 1))), sum_(0) {}
void Reset() override { sum_ = 0; }
- void Update(span<const byte> data) override {
+ void Update(std::span<const byte> data) override {
for (byte b : data) {
sum_ += unsigned(b) + 1; // Add 1 so zero-value bytes affect checksum.
}
diff --git a/pw_kvs/fake_flash_memory.cc b/pw_kvs/fake_flash_memory.cc
index 95987f3..39f5590 100644
--- a/pw_kvs/fake_flash_memory.cc
+++ b/pw_kvs/fake_flash_memory.cc
@@ -20,7 +20,7 @@
namespace pw::kvs {
-Status FlashError::Check(span<FlashError> errors,
+Status FlashError::Check(std::span<FlashError> errors,
FlashMemory::Address address,
size_t size) {
for (auto& error : errors) {
@@ -77,7 +77,8 @@
return Status::OK;
}
-StatusWithSize FakeFlashMemory::Read(Address address, span<std::byte> output) {
+StatusWithSize FakeFlashMemory::Read(Address address,
+ std::span<std::byte> output) {
if (address + output.size() >= sector_count() * size_bytes()) {
return StatusWithSize::OUT_OF_RANGE;
}
@@ -89,7 +90,7 @@
}
StatusWithSize FakeFlashMemory::Write(Address address,
- span<const std::byte> data) {
+ std::span<const std::byte> data) {
if (address % alignment_bytes() != 0 ||
data.size() % alignment_bytes() != 0) {
PW_LOG_ERROR("Unaligned write; address %x, size %u B, alignment %u",
diff --git a/pw_kvs/flash_memory.cc b/pw_kvs/flash_memory.cc
index 242f13e..30af38f 100644
--- a/pw_kvs/flash_memory.cc
+++ b/pw_kvs/flash_memory.cc
@@ -28,13 +28,13 @@
using std::byte;
-StatusWithSize FlashPartition::Output::DoWrite(span<const byte> data) {
+StatusWithSize FlashPartition::Output::DoWrite(std::span<const byte> data) {
TRY_WITH_SIZE(flash_.Write(address_, data));
address_ += data.size();
return StatusWithSize(data.size());
}
-StatusWithSize FlashPartition::Input::DoRead(span<byte> data) {
+StatusWithSize FlashPartition::Input::DoRead(std::span<byte> data) {
StatusWithSize result = flash_.Read(address_, data);
address_ += result.size();
return result;
@@ -49,12 +49,13 @@
return flash_.Erase(PartitionToFlashAddress(address), num_sectors);
}
-StatusWithSize FlashPartition::Read(Address address, span<byte> output) {
+StatusWithSize FlashPartition::Read(Address address, std::span<byte> output) {
TRY_WITH_SIZE(CheckBounds(address, output.size()));
return flash_.Read(PartitionToFlashAddress(address), output);
}
-StatusWithSize FlashPartition::Write(Address address, span<const byte> data) {
+StatusWithSize FlashPartition::Write(Address address,
+ std::span<const byte> data) {
if (permission_ == PartitionPermission::kReadOnly) {
return StatusWithSize::PERMISSION_DENIED;
}
@@ -102,7 +103,7 @@
return Status::OK;
}
-bool FlashPartition::AppearsErased(span<const byte> data) const {
+bool FlashPartition::AppearsErased(std::span<const byte> data) const {
for (byte b : data) {
if (b != flash_.erased_memory_content()) {
return false;
diff --git a/pw_kvs/key_value_store.cc b/pw_kvs/key_value_store.cc
index 68a8412..a106592 100644
--- a/pw_kvs/key_value_store.cc
+++ b/pw_kvs/key_value_store.cc
@@ -39,7 +39,7 @@
} // namespace
KeyValueStore::KeyValueStore(FlashPartition* partition,
- span<const EntryFormat> formats,
+ std::span<const EntryFormat> formats,
const Options& options,
size_t redundancy,
Vector<SectorDescriptor>& sector_descriptor_list,
@@ -385,7 +385,7 @@
address += Entry::kMinAlignmentBytes) {
uint32_t magic;
StatusWithSize read_result =
- partition_.Read(address, as_writable_bytes(span(&magic, 1)));
+ partition_.Read(address, std::as_writable_bytes(std::span(&magic, 1)));
if (!read_result.ok()) {
continue;
}
@@ -400,7 +400,7 @@
}
StatusWithSize KeyValueStore::Get(string_view key,
- span<byte> value_buffer,
+ std::span<byte> value_buffer,
size_t offset_bytes) const {
TRY_WITH_SIZE(CheckReadOperation(key));
@@ -410,7 +410,7 @@
return Get(key, metadata, value_buffer, offset_bytes);
}
-Status KeyValueStore::PutBytes(string_view key, span<const byte> value) {
+Status KeyValueStore::PutBytes(string_view key, std::span<const byte> value) {
TRY(CheckWriteOperation(key));
DBG("Writing key/value; key length=%u, value length=%u",
unsigned(key.size()),
@@ -537,7 +537,7 @@
StatusWithSize KeyValueStore::Get(string_view key,
const EntryMetadata& metadata,
- span<std::byte> value_buffer,
+ std::span<std::byte> value_buffer,
size_t offset_bytes) const {
Entry entry;
@@ -584,7 +584,7 @@
}
StatusWithSize result =
- Get(key, metadata, span(static_cast<byte*>(value), size_bytes), 0);
+ Get(key, metadata, std::span(static_cast<byte*>(value), size_bytes), 0);
return result.status();
}
@@ -624,7 +624,7 @@
Status KeyValueStore::WriteEntryForExistingKey(EntryMetadata& metadata,
EntryState new_state,
string_view key,
- span<const byte> value) {
+ std::span<const byte> value) {
// Read the original entry to get the size for sector accounting purposes.
Entry entry;
TRY(ReadEntry(metadata, entry));
@@ -633,7 +633,7 @@
}
Status KeyValueStore::WriteEntryForNewKey(string_view key,
- span<const byte> value) {
+ std::span<const byte> value) {
if (entry_cache_.full()) {
WRN("KVS full: trying to store a new entry, but can't. Have %u entries",
unsigned(entry_cache_.total_entries()));
@@ -644,7 +644,7 @@
}
Status KeyValueStore::WriteEntry(string_view key,
- span<const byte> value,
+ std::span<const byte> value,
EntryState new_state,
EntryMetadata* prior_metadata,
const Entry* prior_entry) {
@@ -721,7 +721,7 @@
size_t write_size) {
for (size_t i = 0; i < redundancy(); i++) {
SectorDescriptor* sector;
- TRY(GetSectorForWrite(§or, write_size, span(write_addresses, i)));
+ TRY(GetSectorForWrite(§or, write_size, std::span(write_addresses, i)));
write_addresses[i] = sectors_.NextWritableAddress(*sector);
DBG("Found space for entry in sector %u at address %u",
@@ -739,7 +739,7 @@
// RESOURCE_EXHAUSTED: No sector available with the needed space.
Status KeyValueStore::GetSectorForWrite(SectorDescriptor** sector,
size_t entry_size,
- span<const Address> reserved) {
+ std::span<const Address> reserved) {
Status result = sectors_.FindSpace(sector, entry_size, reserved);
size_t gc_sector_count = 0;
@@ -793,7 +793,7 @@
Status KeyValueStore::AppendEntry(const Entry& entry,
string_view key,
- span<const byte> value) {
+ std::span<const byte> value) {
const StatusWithSize result = entry.Write(key, value);
SectorDescriptor& sector = sectors_.FromAddress(entry.address());
@@ -839,9 +839,10 @@
return result;
}
-Status KeyValueStore::RelocateEntry(const EntryMetadata& metadata,
- KeyValueStore::Address& address,
- span<const Address> reserved_addresses) {
+Status KeyValueStore::RelocateEntry(
+ const EntryMetadata& metadata,
+ KeyValueStore::Address& address,
+ std::span<const Address> reserved_addresses) {
Entry entry;
TRY(ReadEntry(metadata, entry));
@@ -937,10 +938,11 @@
if (error_detected_ && options_.recovery != ErrorRecovery::kManual) {
TRY(Repair());
}
- return GarbageCollect(span<const Address>());
+ return GarbageCollect(std::span<const Address>());
}
-Status KeyValueStore::GarbageCollect(span<const Address> reserved_addresses) {
+Status KeyValueStore::GarbageCollect(
+ std::span<const Address> reserved_addresses) {
DBG("Garbage Collect a single sector");
for (Address address : reserved_addresses) {
DBG(" Avoid address %u", unsigned(address));
@@ -962,7 +964,7 @@
Status KeyValueStore::RelocateKeyAddressesInSector(
SectorDescriptor& sector_to_gc,
const EntryMetadata& metadata,
- span<const Address> reserved_addresses) {
+ std::span<const Address> reserved_addresses) {
for (FlashPartition::Address& address : metadata.addresses()) {
if (sectors_.AddressInSector(sector_to_gc, address)) {
DBG(" Relocate entry for Key 0x%08" PRIx32 ", sector %u",
@@ -976,7 +978,8 @@
};
Status KeyValueStore::GarbageCollectSector(
- SectorDescriptor& sector_to_gc, span<const Address> reserved_addresses) {
+ SectorDescriptor& sector_to_gc,
+ std::span<const Address> reserved_addresses) {
DBG(" Garbage Collect sector %u", sectors_.Index(sector_to_gc));
// Step 1: Move any valid entries in the GC sector to other sectors
if (sector_to_gc.valid_bytes() != 0) {
@@ -1121,7 +1124,7 @@
}
if (empty_sector_found == false) {
DBG(" No empty sector found, attempting to GC a free sector");
- Status sector_status = GarbageCollect(span<const Address, 0>());
+ Status sector_status = GarbageCollect(std::span<const Address, 0>());
if (repair_status.ok() && !sector_status.ok()) {
DBG(" Unable to free an empty sector");
repair_status = sector_status;
@@ -1207,7 +1210,7 @@
KeyValueStore::Entry KeyValueStore::CreateEntry(Address address,
string_view key,
- span<const byte> value,
+ std::span<const byte> value,
EntryState state) {
// Always bump the transaction ID when creating a new entry.
//
diff --git a/pw_kvs/key_value_store_binary_format_test.cc b/pw_kvs/key_value_store_binary_format_test.cc
index 079396d..5921e82 100644
--- a/pw_kvs/key_value_store_binary_format_test.cc
+++ b/pw_kvs/key_value_store_binary_format_test.cc
@@ -33,7 +33,7 @@
constexpr size_t kMaxEntries = 256;
constexpr size_t kMaxUsableSectors = 256;
-constexpr uint32_t SimpleChecksum(span<const byte> data, uint32_t state) {
+constexpr uint32_t SimpleChecksum(std::span<const byte> data, uint32_t state) {
for (byte b : data) {
state += uint32_t(b);
}
@@ -43,18 +43,19 @@
template <typename State>
class ChecksumFunction final : public ChecksumAlgorithm {
public:
- ChecksumFunction(State (&algorithm)(span<const byte>, State))
- : ChecksumAlgorithm(as_bytes(span(&state_, 1))), algorithm_(algorithm) {}
+ ChecksumFunction(State (&algorithm)(std::span<const byte>, State))
+ : ChecksumAlgorithm(std::as_bytes(std::span(&state_, 1))),
+ algorithm_(algorithm) {}
void Reset() override { state_ = {}; }
- void Update(span<const byte> data) override {
+ void Update(std::span<const byte> data) override {
state_ = algorithm_(data, state_);
}
private:
State state_;
- State (&algorithm_)(span<const byte>, State);
+ State (&algorithm_)(std::span<const byte>, State);
};
ChecksumFunction<uint32_t> default_checksum(SimpleChecksum);
@@ -68,7 +69,8 @@
}
// Creates a buffer containing a valid entry at compile time.
-template <uint32_t (*kChecksum)(span<const byte>, uint32_t) = &SimpleChecksum,
+template <uint32_t (*kChecksum)(std::span<const byte>,
+ uint32_t) = &SimpleChecksum,
size_t kAlignmentBytes = sizeof(internal::EntryHeader),
size_t kKeyLengthWithNull,
size_t kValueSize>
@@ -85,7 +87,7 @@
uint16_t(kValueSize),
id,
ByteStr(key),
- span(value),
+ std::span(value),
EntryPadding<kAlignmentBytes, kKeyLength, kValueSize>());
// Calculate the checksum
@@ -99,7 +101,8 @@
}
// Creates a buffer containing a deleted entry at compile time.
-template <uint32_t (*kChecksum)(span<const byte>, uint32_t) = &SimpleChecksum,
+template <uint32_t (*kChecksum)(std::span<const byte>,
+ uint32_t) = &SimpleChecksum,
size_t kAlignmentBytes = sizeof(internal::EntryHeader),
size_t kKeyLengthWithNull>
constexpr auto MakeDeletedEntry(uint32_t magic,
@@ -166,7 +169,7 @@
partition_(&flash_),
kvs_(&partition_, default_format, kNoGcOptions) {}
- void InitFlashTo(span<const byte> contents) {
+ void InitFlashTo(std::span<const byte> contents) {
partition_.Erase();
std::memcpy(flash_.buffer().data(), contents.data(), contents.size());
}
@@ -329,7 +332,7 @@
EXPECT_EQ(1u, kvs_.size());
- auto result = kvs_.Get("my_key", as_writable_bytes(span(buffer)));
+ auto result = kvs_.Get("my_key", std::as_writable_bytes(std::span(buffer)));
EXPECT_EQ(Status::OK, result.status());
EXPECT_EQ(sizeof("version 7") - 1, result.size());
EXPECT_STREQ("version 7", buffer);
@@ -346,7 +349,7 @@
EXPECT_EQ(Status::UNAVAILABLE, kvs_.Put("key1", ByteStr("value1")));
- EXPECT_EQ(Status::NOT_FOUND, kvs_.Get("key1", span<byte>()).status());
+ EXPECT_EQ(Status::NOT_FOUND, kvs_.Get("key1", std::span<byte>()).status());
ASSERT_TRUE(kvs_.empty());
auto stats = kvs_.GetStorageStats();
@@ -373,7 +376,7 @@
{.magic = kMagic, .checksum = &default_checksum},
kRecoveryNoGcOptions) {}
- void InitFlashTo(span<const byte> contents) {
+ void InitFlashTo(std::span<const byte> contents) {
partition_.Erase();
std::memcpy(flash_.buffer().data(), contents.data(), contents.size());
}
@@ -549,7 +552,7 @@
EXPECT_EQ(1u, kvs_.size());
- auto result = kvs_.Get("my_key", as_writable_bytes(span(buffer)));
+ auto result = kvs_.Get("my_key", std::as_writable_bytes(std::span(buffer)));
EXPECT_EQ(Status::OK, result.status());
EXPECT_EQ(sizeof("version 7") - 1, result.size());
EXPECT_STREQ("version 7", buffer);
@@ -567,7 +570,7 @@
EXPECT_EQ(Status::UNAVAILABLE, kvs_.Put("key1", ByteStr("value1")));
EXPECT_EQ(true, kvs_.error_detected());
- EXPECT_EQ(Status::NOT_FOUND, kvs_.Get("key1", span<byte>()).status());
+ EXPECT_EQ(Status::NOT_FOUND, kvs_.Get("key1", std::span<byte>()).status());
ASSERT_TRUE(kvs_.empty());
auto stats = kvs_.GetStorageStats();
@@ -591,7 +594,7 @@
constexpr uint32_t kAltMagic = 0xbadD00D;
-constexpr uint32_t AltChecksum(span<const byte> data, uint32_t state) {
+constexpr uint32_t AltChecksum(std::span<const byte> data, uint32_t state) {
for (byte b : data) {
state = (state << 8) | uint32_t(byte(state >> 24) ^ b);
}
@@ -603,7 +606,7 @@
constexpr auto kAltEntry =
MakeValidEntry<AltChecksum>(kAltMagic, 32, "A Key", ByteStr("XD"));
-constexpr uint32_t NoChecksum(span<const byte>, uint32_t) { return 0; }
+constexpr uint32_t NoChecksum(std::span<const byte>, uint32_t) { return 0; }
constexpr uint32_t kNoChecksumMagic = 0x6000061e;
constexpr auto kNoChecksumEntry =
@@ -640,13 +643,14 @@
KeyValueStoreBuffer<kMaxEntries, kMaxUsableSectors, 2, 3> kvs_;
};
-#define ASSERT_CONTAINS_ENTRY(key, str_value) \
- do { \
- char val[sizeof(str_value)] = {}; \
- StatusWithSize stat = kvs_.Get(key, as_writable_bytes(span(val))); \
- ASSERT_EQ(Status::OK, stat.status()); \
- ASSERT_EQ(sizeof(str_value) - 1, stat.size()); \
- ASSERT_STREQ(str_value, val); \
+#define ASSERT_CONTAINS_ENTRY(key, str_value) \
+ do { \
+ char val[sizeof(str_value)] = {}; \
+ StatusWithSize stat = \
+ kvs_.Get(key, std::as_writable_bytes(std::span(val))); \
+ ASSERT_EQ(Status::OK, stat.status()); \
+ ASSERT_EQ(sizeof(str_value) - 1, stat.size()); \
+ ASSERT_STREQ(str_value, val); \
} while (0)
TEST_F(InitializedRedundantMultiMagicKvs, AllEntriesArePresent) {
@@ -756,8 +760,9 @@
EXPECT_EQ(stats.missing_redundant_entries_recovered, 0u);
char val[20] = {};
- EXPECT_EQ(Status::OK,
- kvs_.Get("new key", as_writable_bytes(span(val))).status());
+ EXPECT_EQ(
+ Status::OK,
+ kvs_.Get("new key", std::as_writable_bytes(std::span(val))).status());
EXPECT_EQ(Status::OK, kvs_.FullMaintenance());
stats = kvs_.GetStorageStats();
@@ -767,8 +772,9 @@
EXPECT_EQ(stats.corrupt_sectors_recovered, 0u);
EXPECT_EQ(stats.missing_redundant_entries_recovered, 0u);
- EXPECT_EQ(Status::OK,
- kvs_.Get("new key", as_writable_bytes(span(val))).status());
+ EXPECT_EQ(
+ Status::OK,
+ kvs_.Get("new key", std::as_writable_bytes(std::span(val))).status());
}
TEST_F(InitializedRedundantMultiMagicKvs, DataLossAfterLosingBothCopies) {
@@ -776,15 +782,15 @@
char val[20] = {};
EXPECT_EQ(Status::DATA_LOSS,
- kvs_.Get("key1", as_writable_bytes(span(val))).status());
+ kvs_.Get("key1", std::as_writable_bytes(std::span(val))).status());
EXPECT_EQ(Status::DATA_LOSS,
- kvs_.Get("k2", as_writable_bytes(span(val))).status());
+ kvs_.Get("k2", std::as_writable_bytes(std::span(val))).status());
EXPECT_EQ(Status::DATA_LOSS,
- kvs_.Get("k3y", as_writable_bytes(span(val))).status());
+ kvs_.Get("k3y", std::as_writable_bytes(std::span(val))).status());
EXPECT_EQ(Status::DATA_LOSS,
- kvs_.Get("A Key", as_writable_bytes(span(val))).status());
+ kvs_.Get("A Key", std::as_writable_bytes(std::span(val))).status());
EXPECT_EQ(Status::DATA_LOSS,
- kvs_.Get("kee", as_writable_bytes(span(val))).status());
+ kvs_.Get("kee", std::as_writable_bytes(std::span(val))).status());
EXPECT_EQ(true, kvs_.error_detected());
@@ -820,13 +826,14 @@
ASSERT_CONTAINS_ENTRY("A Key", "New value!");
}
-#define ASSERT_KVS_CONTAINS_ENTRY(kvs, key, str_value) \
- do { \
- char val[sizeof(str_value)] = {}; \
- StatusWithSize stat = kvs.Get(key, as_writable_bytes(span(val))); \
- ASSERT_EQ(Status::OK, stat.status()); \
- ASSERT_EQ(sizeof(str_value) - 1, stat.size()); \
- ASSERT_STREQ(str_value, val); \
+#define ASSERT_KVS_CONTAINS_ENTRY(kvs, key, str_value) \
+ do { \
+ char val[sizeof(str_value)] = {}; \
+ StatusWithSize stat = \
+ kvs.Get(key, std::as_writable_bytes(std::span(val))); \
+ ASSERT_EQ(Status::OK, stat.status()); \
+ ASSERT_EQ(sizeof(str_value) - 1, stat.size()); \
+ ASSERT_STREQ(str_value, val); \
} while (0)
TEST_F(InitializedRedundantMultiMagicKvs, UpdateEntryFormat) {
@@ -932,13 +939,13 @@
char val[20] = {};
EXPECT_EQ(Status::DATA_LOSS,
- kvs_.Get("key1", as_writable_bytes(span(val))).status());
+ kvs_.Get("key1", std::as_writable_bytes(std::span(val))).status());
EXPECT_EQ(Status::DATA_LOSS,
- kvs_.Get("k2", as_writable_bytes(span(val))).status());
+ kvs_.Get("k2", std::as_writable_bytes(std::span(val))).status());
EXPECT_EQ(Status::DATA_LOSS,
- kvs_.Get("k3y", as_writable_bytes(span(val))).status());
+ kvs_.Get("k3y", std::as_writable_bytes(std::span(val))).status());
EXPECT_EQ(Status::DATA_LOSS,
- kvs_.Get("4k", as_writable_bytes(span(val))).status());
+ kvs_.Get("4k", std::as_writable_bytes(std::span(val))).status());
EXPECT_EQ(true, kvs_.error_detected());
diff --git a/pw_kvs/key_value_store_fuzz_test.cc b/pw_kvs/key_value_store_fuzz_test.cc
index 8ef1ebc..2a34750 100644
--- a/pw_kvs/key_value_store_fuzz_test.cc
+++ b/pw_kvs/key_value_store_fuzz_test.cc
@@ -63,7 +63,7 @@
for (unsigned value_size = 0; value_size < sizeof(value); ++value_size) {
ASSERT_EQ(Status::OK,
kvs_.Put(std::string_view(value, key_size),
- as_bytes(span(value, value_size))));
+ std::as_bytes(std::span(value, value_size))));
}
}
}
diff --git a/pw_kvs/key_value_store_test.cc b/pw_kvs/key_value_store_test.cc
index 1333364..35840ef 100644
--- a/pw_kvs/key_value_store_test.cc
+++ b/pw_kvs/key_value_store_test.cc
@@ -21,6 +21,7 @@
#include <array>
#include <cstdio>
#include <cstring>
+#include <span>
#if DUMP_KVS_STATE_TO_FILE
#include <vector>
@@ -34,7 +35,6 @@
#include "pw_kvs_private/byte_utils.h"
#include "pw_kvs_private/macros.h"
#include "pw_log/log.h"
-#include "pw_span/span.h"
#include "pw_status/status.h"
#include "pw_string/string_builder.h"
@@ -76,7 +76,7 @@
static_assert(kAsBytesTest[14] == std::byte{0xff});
// Test that the ConvertsToSpan trait correctly idenitifies types that convert
-// to span.
+// to std::span.
static_assert(!ConvertsToSpan<int>());
static_assert(!ConvertsToSpan<void>());
static_assert(!ConvertsToSpan<std::byte>());
@@ -97,12 +97,12 @@
static_assert(ConvertsToSpan<char[35]>());
static_assert(ConvertsToSpan<const int[35]>());
-static_assert(ConvertsToSpan<span<int>>());
-static_assert(ConvertsToSpan<span<byte>>());
-static_assert(ConvertsToSpan<span<const int*>>());
-static_assert(ConvertsToSpan<span<bool>&&>());
-static_assert(ConvertsToSpan<const span<bool>&>());
-static_assert(ConvertsToSpan<span<bool>&&>());
+static_assert(ConvertsToSpan<std::span<int>>());
+static_assert(ConvertsToSpan<std::span<byte>>());
+static_assert(ConvertsToSpan<std::span<const int*>>());
+static_assert(ConvertsToSpan<std::span<bool>&&>());
+static_assert(ConvertsToSpan<const std::span<bool>&>());
+static_assert(ConvertsToSpan<std::span<bool>&&>());
// This is a self contained flash unit with both memory and a single partition.
template <uint32_t sector_size_bytes, uint16_t sector_count>
@@ -125,7 +125,7 @@
}
std::vector<std::byte> out_vec(memory.size_bytes());
Status status =
- memory.Read(0, pw::span<std::byte>(out_vec.data(), out_vec.size()));
+ memory.Read(0, std::span<std::byte>(out_vec.data(), out_vec.size()));
if (status != Status::OK) {
fclose(out_file);
return status;
@@ -233,9 +233,9 @@
buffer[0] = static_cast<byte>(static_cast<uint8_t>(buffer[0]) + 1);
ASSERT_EQ(Status::OK,
kvs_.Put(key,
- span(buffer.data(),
- chunk_len - kvs_attr.ChunkHeaderSize() -
- kvs_attr.KeySize())));
+ std::span(buffer.data(),
+ chunk_len - kvs_attr.ChunkHeaderSize() -
+ kvs_attr.KeySize())));
size_to_fill -= chunk_len;
chunk_len = std::min(size_to_fill, kMaxPutSize);
}
@@ -251,7 +251,8 @@
std::array<char, 8> value{'v', 'a', 'l', 'u', 'e', '6', '7', '\0'};
for (int i = 0; i < 1000; ++i) {
- ASSERT_EQ(Status::OK, kvs_.Put("The Key!", as_bytes(span(value))));
+ ASSERT_EQ(Status::OK,
+ kvs_.Put("The Key!", std::as_bytes(std::span(value))));
}
}
@@ -259,7 +260,8 @@
std::array<char, 7> value{'v', 'a', 'l', 'u', 'e', '6', '\0'};
for (int i = 0; i < 1000; ++i) {
- ASSERT_EQ(Status::OK, kvs_.Put("The Key!", as_bytes(span(value))));
+ ASSERT_EQ(Status::OK,
+ kvs_.Put("The Key!", std::as_bytes(std::span(value))));
}
}
@@ -279,7 +281,7 @@
// Use the large_test_flash as a big chunk of data for the Put statement.
ASSERT_GT(sizeof(large_test_flash), max_value_size + 2 * sizeof(EntryHeader));
- auto big_data = as_bytes(span(&large_test_flash, 1));
+ auto big_data = std::as_bytes(std::span(&large_test_flash, 1));
EXPECT_EQ(Status::OK, kvs_.Put("K", big_data.subspan(0, max_value_size)));
@@ -301,7 +303,7 @@
TEST_F(EmptyInitializedKvs, PutAndGetByValue_Span) {
float input[] = {1.0, -3.5};
- ASSERT_EQ(Status::OK, kvs_.Put("key", span(input)));
+ ASSERT_EQ(Status::OK, kvs_.Put("key", std::span(input)));
float output[2] = {};
ASSERT_EQ(Status::OK, kvs_.Get("key", &output));
@@ -325,41 +327,48 @@
}
TEST_F(EmptyInitializedKvs, Get_Simple) {
- ASSERT_EQ(Status::OK, kvs_.Put("Charles", as_bytes(span("Mingus"))));
+ ASSERT_EQ(Status::OK,
+ kvs_.Put("Charles", std::as_bytes(std::span("Mingus"))));
char value[16];
- auto result = kvs_.Get("Charles", as_writable_bytes(span(value)));
+ auto result = kvs_.Get("Charles", std::as_writable_bytes(std::span(value)));
EXPECT_EQ(Status::OK, result.status());
EXPECT_EQ(sizeof("Mingus"), result.size());
EXPECT_STREQ("Mingus", value);
}
TEST_F(EmptyInitializedKvs, Get_WithOffset) {
- ASSERT_EQ(Status::OK, kvs_.Put("Charles", as_bytes(span("Mingus"))));
+ ASSERT_EQ(Status::OK,
+ kvs_.Put("Charles", std::as_bytes(std::span("Mingus"))));
char value[16];
- auto result = kvs_.Get("Charles", as_writable_bytes(span(value)), 4);
+ auto result =
+ kvs_.Get("Charles", std::as_writable_bytes(std::span(value)), 4);
EXPECT_EQ(Status::OK, result.status());
EXPECT_EQ(sizeof("Mingus") - 4, result.size());
EXPECT_STREQ("us", value);
}
TEST_F(EmptyInitializedKvs, Get_WithOffset_FillBuffer) {
- ASSERT_EQ(Status::OK, kvs_.Put("Charles", as_bytes(span("Mingus"))));
+ ASSERT_EQ(Status::OK,
+ kvs_.Put("Charles", std::as_bytes(std::span("Mingus"))));
char value[4] = {};
- auto result = kvs_.Get("Charles", as_writable_bytes(span(value, 3)), 1);
+ auto result =
+ kvs_.Get("Charles", std::as_writable_bytes(std::span(value, 3)), 1);
EXPECT_EQ(Status::RESOURCE_EXHAUSTED, result.status());
EXPECT_EQ(3u, result.size());
EXPECT_STREQ("ing", value);
}
TEST_F(EmptyInitializedKvs, Get_WithOffset_PastEnd) {
- ASSERT_EQ(Status::OK, kvs_.Put("Charles", as_bytes(span("Mingus"))));
+ ASSERT_EQ(Status::OK,
+ kvs_.Put("Charles", std::as_bytes(std::span("Mingus"))));
char value[16];
- auto result =
- kvs_.Get("Charles", as_writable_bytes(span(value)), sizeof("Mingus") + 1);
+ auto result = kvs_.Get("Charles",
+ std::as_writable_bytes(std::span(value)),
+ sizeof("Mingus") + 1);
EXPECT_EQ(Status::OUT_OF_RANGE, result.status());
EXPECT_EQ(0u, result.size());
}
@@ -389,7 +398,7 @@
}
TEST_F(EmptyInitializedKvs, Delete_GetDeletedKey_ReturnsNotFound) {
- ASSERT_EQ(Status::OK, kvs_.Put("kEy", as_bytes(span("123"))));
+ ASSERT_EQ(Status::OK, kvs_.Put("kEy", std::as_bytes(std::span("123"))));
ASSERT_EQ(Status::OK, kvs_.Delete("kEy"));
EXPECT_EQ(Status::NOT_FOUND, kvs_.Get("kEy", {}).status());
@@ -397,10 +406,10 @@
}
TEST_F(EmptyInitializedKvs, Delete_AddBackKey_PersistsAfterInitialization) {
- ASSERT_EQ(Status::OK, kvs_.Put("kEy", as_bytes(span("123"))));
+ ASSERT_EQ(Status::OK, kvs_.Put("kEy", std::as_bytes(std::span("123"))));
ASSERT_EQ(Status::OK, kvs_.Delete("kEy"));
- EXPECT_EQ(Status::OK, kvs_.Put("kEy", as_bytes(span("45678"))));
+ EXPECT_EQ(Status::OK, kvs_.Put("kEy", std::as_bytes(std::span("45678"))));
char data[6] = {};
ASSERT_EQ(Status::OK, kvs_.Get("kEy", &data));
EXPECT_STREQ(data, "45678");
@@ -410,14 +419,14 @@
default_format);
ASSERT_EQ(Status::OK, new_kvs.Init());
- EXPECT_EQ(Status::OK, new_kvs.Put("kEy", as_bytes(span("45678"))));
+ EXPECT_EQ(Status::OK, new_kvs.Put("kEy", std::as_bytes(std::span("45678"))));
char new_data[6] = {};
EXPECT_EQ(Status::OK, new_kvs.Get("kEy", &new_data));
EXPECT_STREQ(data, "45678");
}
TEST_F(EmptyInitializedKvs, Delete_AllItems_KvsIsEmpty) {
- ASSERT_EQ(Status::OK, kvs_.Put("kEy", as_bytes(span("123"))));
+ ASSERT_EQ(Status::OK, kvs_.Put("kEy", std::as_bytes(std::span("123"))));
ASSERT_EQ(Status::OK, kvs_.Delete("kEy"));
EXPECT_EQ(0u, kvs_.size());
@@ -476,7 +485,7 @@
}
TEST_F(EmptyInitializedKvs, Iteration_OneItem) {
- ASSERT_EQ(Status::OK, kvs_.Put("kEy", as_bytes(span("123"))));
+ ASSERT_EQ(Status::OK, kvs_.Put("kEy", std::as_bytes(std::span("123"))));
for (KeyValueStore::Item entry : kvs_) {
EXPECT_STREQ(entry.key(), "kEy"); // Make sure null-terminated.
@@ -488,11 +497,11 @@
}
TEST_F(EmptyInitializedKvs, Iteration_GetWithOffset) {
- ASSERT_EQ(Status::OK, kvs_.Put("key", as_bytes(span("not bad!"))));
+ ASSERT_EQ(Status::OK, kvs_.Put("key", std::as_bytes(std::span("not bad!"))));
for (KeyValueStore::Item entry : kvs_) {
char temp[5];
- auto result = entry.Get(as_writable_bytes(span(temp)), 4);
+ auto result = entry.Get(std::as_writable_bytes(std::span(temp)), 4);
EXPECT_EQ(Status::OK, result.status());
EXPECT_EQ(5u, result.size());
EXPECT_STREQ("bad!", temp);
@@ -530,7 +539,7 @@
}
TEST_F(EmptyInitializedKvs, Iteration_EmptyAfterDeletion) {
- ASSERT_EQ(Status::OK, kvs_.Put("kEy", as_bytes(span("123"))));
+ ASSERT_EQ(Status::OK, kvs_.Put("kEy", std::as_bytes(std::span("123"))));
ASSERT_EQ(Status::OK, kvs_.Delete("kEy"));
for (KeyValueStore::Item entry : kvs_) {
@@ -570,9 +579,9 @@
}
// Delete and re-add everything
ASSERT_EQ(Status::OK, kvs_.Delete(key1));
- ASSERT_EQ(Status::OK, kvs_.Put(key1, span(buf1, size1)));
+ ASSERT_EQ(Status::OK, kvs_.Put(key1, std::span(buf1, size1)));
ASSERT_EQ(Status::OK, kvs_.Delete(key2));
- ASSERT_EQ(Status::OK, kvs_.Put(key2, span(buf2, size2)));
+ ASSERT_EQ(Status::OK, kvs_.Put(key2, std::span(buf2, size2)));
for (size_t j = 0; j < keys.size(); j++) {
ASSERT_EQ(Status::OK, kvs_.Delete(keys[j]));
ASSERT_EQ(Status::OK, kvs_.Put(keys[j], j));
@@ -581,9 +590,9 @@
// Re-enable and verify
ASSERT_EQ(Status::OK, kvs_.Init());
static byte buf[4 * 1024];
- ASSERT_EQ(Status::OK, kvs_.Get(key1, span(buf, size1)).status());
+ ASSERT_EQ(Status::OK, kvs_.Get(key1, std::span(buf, size1)).status());
ASSERT_EQ(std::memcmp(buf, buf1, size1), 0);
- ASSERT_EQ(Status::OK, kvs_.Get(key2, span(buf, size2)).status());
+ ASSERT_EQ(Status::OK, kvs_.Get(key2, std::span(buf, size2)).status());
ASSERT_EQ(std::memcmp(buf2, buf2, size2), 0);
for (size_t j = 0; j < keys.size(); j++) {
size_t ret = 1000;
@@ -596,8 +605,9 @@
TEST_F(EmptyInitializedKvs, Basic) {
// Add some data
uint8_t value1 = 0xDA;
- ASSERT_EQ(Status::OK,
- kvs_.Put(keys[0], as_bytes(span(&value1, sizeof(value1)))));
+ ASSERT_EQ(
+ Status::OK,
+ kvs_.Put(keys[0], std::as_bytes(std::span(&value1, sizeof(value1)))));
uint32_t value2 = 0xBAD0301f;
ASSERT_EQ(Status::OK, kvs_.Put(keys[1], value2));
@@ -617,10 +627,10 @@
// Verify it was erased
EXPECT_EQ(kvs_.Get(keys[0], &test1), Status::NOT_FOUND);
test2 = 0;
- ASSERT_EQ(
- Status::OK,
- kvs_.Get(keys[1], span(reinterpret_cast<byte*>(&test2), sizeof(test2)))
- .status());
+ ASSERT_EQ(Status::OK,
+ kvs_.Get(keys[1],
+ std::span(reinterpret_cast<byte*>(&test2), sizeof(test2)))
+ .status());
EXPECT_EQ(test2, value2);
// Delete other key
@@ -818,7 +828,7 @@
// Add two entries with different keys and values.
uint8_t value1 = 0xDA;
- ASSERT_OK(kvs.Put(key1, as_bytes(span(&value1, sizeof(value1)))));
+ ASSERT_OK(kvs.Put(key1, std::as_bytes(std::span(&value1, sizeof(value1)))));
EXPECT_EQ(kvs.size(), 1u);
uint32_t value2 = 0xBAD0301f;
@@ -996,20 +1006,22 @@
const uint8_t kValue1 = 0xDA;
const uint8_t kValue2 = 0x12;
const char* key = "the_key";
- ASSERT_EQ(Status::OK, kvs_.Put(key, as_bytes(span(&kValue1, 1))));
+ ASSERT_EQ(Status::OK, kvs_.Put(key, std::as_bytes(std::span(&kValue1, 1))));
// Verify
uint8_t value;
- ASSERT_EQ(Status::OK,
- kvs_.Get(key, as_writable_bytes(span(&value, 1))).status());
+ ASSERT_EQ(
+ Status::OK,
+ kvs_.Get(key, std::as_writable_bytes(std::span(&value, 1))).status());
EXPECT_EQ(kValue1, value);
// Write new value for key
- ASSERT_EQ(Status::OK, kvs_.Put(key, as_bytes(span(&kValue2, 1))));
+ ASSERT_EQ(Status::OK, kvs_.Put(key, std::as_bytes(std::span(&kValue2, 1))));
// Verify
- ASSERT_EQ(Status::OK,
- kvs_.Get(key, as_writable_bytes(span(&value, 1))).status());
+ ASSERT_EQ(
+ Status::OK,
+ kvs_.Get(key, std::as_writable_bytes(std::span(&value, 1))).status());
EXPECT_EQ(kValue2, value);
// Verify only 1 element exists
@@ -1035,11 +1047,11 @@
// the only entries in the env. The size of this initial entry
// we vary between no bytes to sizeof(set_buf).
ASSERT_EQ(Status::OK,
- kvs_.Put("const_entry", span(set_buf, test_iteration)));
+ kvs_.Put("const_entry", std::span(set_buf, test_iteration)));
// The value we read back should be the last value we set
std::memset(get_buf, 0, sizeof(get_buf));
- result = kvs_.Get("const_entry", span(get_buf));
+ result = kvs_.Get("const_entry", std::span(get_buf));
ASSERT_EQ(Status::OK, result.status());
ASSERT_EQ(result.size(), test_iteration);
for (size_t j = 0; j < test_iteration; j++) {
@@ -1053,10 +1065,11 @@
std::byte get_entry_buf[sizeof(set_entry_buf)];
for (size_t i = 0; i < 5; i++) {
set_entry[0] = static_cast<std::byte>(i);
- ASSERT_EQ(Status::OK,
- kvs_.Put("test_entry", span(set_entry, sizeof(set_entry_buf))));
+ ASSERT_EQ(
+ Status::OK,
+ kvs_.Put("test_entry", std::span(set_entry, sizeof(set_entry_buf))));
std::memset(get_entry_buf, 0, sizeof(get_entry_buf));
- result = kvs_.Get("test_entry", span(get_entry_buf));
+ result = kvs_.Get("test_entry", std::span(get_entry_buf));
ASSERT_TRUE(result.ok());
ASSERT_EQ(result.size(), sizeof(get_entry_buf));
for (uint32_t j = 0; j < sizeof(set_entry_buf); j++) {
@@ -1066,7 +1079,7 @@
// Check that the const entry is still present and has the right value
std::memset(get_buf, 0, sizeof(get_buf));
- result = kvs_.Get("const_entry", span(get_buf));
+ result = kvs_.Get("const_entry", std::span(get_buf));
ASSERT_TRUE(result.ok());
ASSERT_EQ(result.size(), test_iteration);
for (size_t j = 0; j < test_iteration; j++) {
@@ -1086,14 +1099,15 @@
for (size_t i = 0; i < kTestBufferSize; i++) {
buffer[i] = byte(i);
}
- ASSERT_EQ(Status::OK, kvs_.Put(key, span(buffer.data(), kTestBufferSize)));
+ ASSERT_EQ(Status::OK,
+ kvs_.Put(key, std::span(buffer.data(), kTestBufferSize)));
EXPECT_EQ(kvs_.size(), 1u);
// Read in small chunks and verify
for (unsigned i = 0; i < kTestBufferSize / kReadSize; i++) {
std::memset(buffer.data(), 0, buffer.size());
StatusWithSize result =
- kvs_.Get(key, span(buffer.data(), kReadSize), i * kReadSize);
+ kvs_.Get(key, std::span(buffer.data(), kReadSize), i * kReadSize);
ASSERT_EQ(kReadSize, result.size());
@@ -1145,11 +1159,11 @@
std::memset(
buffer.data(), static_cast<int>(kKey0Pattern), kvs_attr.DataSize());
ASSERT_EQ(Status::OK,
- kvs_.Put(keys[0], span(buffer.data(), kvs_attr.DataSize())));
+ kvs_.Put(keys[0], std::span(buffer.data(), kvs_attr.DataSize())));
bytes_remaining -= kvs_attr.MinPutSize();
std::memset(buffer.data(), 1, kvs_attr.DataSize());
ASSERT_EQ(Status::OK,
- kvs_.Put(keys[2], span(buffer.data(), kvs_attr.DataSize())));
+ kvs_.Put(keys[2], std::span(buffer.data(), kvs_attr.DataSize())));
bytes_remaining -= kvs_attr.MinPutSize();
EXPECT_EQ(kvs_.size(), 2u);
ASSERT_EQ(Status::OK, kvs_.Delete(keys[2]));
@@ -1162,9 +1176,9 @@
// Verify key[0]
std::memset(buffer.data(), 0, kvs_attr.DataSize());
- ASSERT_EQ(
- Status::OK,
- kvs_.Get(keys[0], span(buffer.data(), kvs_attr.DataSize())).status());
+ ASSERT_EQ(Status::OK,
+ kvs_.Get(keys[0], std::span(buffer.data(), kvs_attr.DataSize()))
+ .status());
for (uint32_t i = 0; i < kvs_attr.DataSize(); i++) {
EXPECT_EQ(buffer[i], kKey0Pattern);
}
@@ -1178,7 +1192,8 @@
EXPECT_EQ(kvs_.size(), 1u);
ASSERT_EQ(Status::OK, kvs_.Delete(keys[0]));
EXPECT_EQ(kvs_.Get(keys[0], &value), Status::NOT_FOUND);
- ASSERT_EQ(Status::OK, kvs_.Put(keys[1], as_bytes(span(&kValue1, 1))));
+ ASSERT_EQ(Status::OK,
+ kvs_.Put(keys[1], std::as_bytes(std::span(&kValue1, 1))));
ASSERT_EQ(Status::OK, kvs_.Put(keys[2], kValue2));
ASSERT_EQ(Status::OK, kvs_.Delete(keys[1]));
EXPECT_EQ(Status::OK, kvs_.Get(keys[2], &value));
@@ -1264,15 +1279,16 @@
new_keyvalue_size -= kValueLessThanChunkHeaderSize;
std::memset(buffer.data(), static_cast<int>(kTestPattern), new_keyvalue_size);
ASSERT_EQ(Status::OK,
- kvs_.Put(kNewKey, span(buffer.data(), new_keyvalue_size)));
+ kvs_.Put(kNewKey, std::span(buffer.data(), new_keyvalue_size)));
// In failed corner case, adding new key is deceptively successful. It isn't
// until KVS is disabled and reenabled that issue can be detected.
ASSERT_EQ(Status::OK, kvs_.Init());
// Might as well check that new key-value is what we expect it to be
- ASSERT_EQ(Status::OK,
- kvs_.Get(kNewKey, span(buffer.data(), new_keyvalue_size)).status());
+ ASSERT_EQ(
+ Status::OK,
+ kvs_.Get(kNewKey, std::span(buffer.data(), new_keyvalue_size)).status());
for (size_t i = 0; i < new_keyvalue_size; i++) {
EXPECT_EQ(buffer[i], kTestPattern);
}
@@ -1289,7 +1305,7 @@
}
TEST_F(EmptyInitializedKvs, ValueSize_Zero) {
- ASSERT_EQ(Status::OK, kvs_.Put("TheKey", as_bytes(span("123", 3))));
+ ASSERT_EQ(Status::OK, kvs_.Put("TheKey", std::as_bytes(std::span("123", 3))));
auto result = kvs_.ValueSize("TheKey");
EXPECT_EQ(Status::OK, result.status());
@@ -1305,7 +1321,7 @@
}
TEST_F(EmptyInitializedKvs, ValueSize_DeletedKey) {
- ASSERT_EQ(Status::OK, kvs_.Put("TheKey", as_bytes(span("123", 3))));
+ ASSERT_EQ(Status::OK, kvs_.Put("TheKey", std::as_bytes(std::span("123", 3))));
ASSERT_EQ(Status::OK, kvs_.Delete("TheKey"));
EXPECT_EQ(Status::NOT_FOUND, kvs_.ValueSize("TheKey").status());
diff --git a/pw_kvs/key_value_store_wear_test.cc b/pw_kvs/key_value_store_wear_test.cc
index e907576..eb5f930 100644
--- a/pw_kvs/key_value_store_wear_test.cc
+++ b/pw_kvs/key_value_store_wear_test.cc
@@ -63,7 +63,7 @@
// written.
test_data[0]++;
- EXPECT_TRUE(kvs_.Put("large_entry", span(test_data)).ok());
+ EXPECT_TRUE(kvs_.Put("large_entry", std::span(test_data)).ok());
}
// Ensure every sector has been erased at several times due to garbage
@@ -91,7 +91,8 @@
EXPECT_EQ(
Status::OK,
- kvs_.Put("key", as_bytes(span(test_data, sizeof(test_data) - 70))));
+ kvs_.Put("key",
+ std::as_bytes(std::span(test_data, sizeof(test_data) - 70))));
}
// Add many copies of a differently sized entry that is larger than the
diff --git a/pw_kvs/public/pw_kvs/alignment.h b/pw_kvs/public/pw_kvs/alignment.h
index f153756..e8cf191 100644
--- a/pw_kvs/public/pw_kvs/alignment.h
+++ b/pw_kvs/public/pw_kvs/alignment.h
@@ -17,10 +17,10 @@
#include <cstddef>
#include <cstring>
#include <initializer_list>
+#include <span>
#include <utility>
#include "pw_kvs/io.h"
-#include "pw_span/span.h"
#include "pw_status/status_with_size.h"
namespace pw {
@@ -46,7 +46,9 @@
// called or the AlignedWriter goes out of scope.
class AlignedWriter {
public:
- AlignedWriter(span<std::byte> buffer, size_t alignment_bytes, Output& writer)
+ AlignedWriter(std::span<std::byte> buffer,
+ size_t alignment_bytes,
+ Output& writer)
: buffer_(buffer.data()),
write_size_(AlignDown(buffer.size(), alignment_bytes)),
alignment_bytes_(alignment_bytes),
@@ -66,10 +68,10 @@
// successful and failed Write calls. On a failed write call, knowing the
// bytes attempted may be important when working with flash memory, since it
// can only be written once between erases.
- StatusWithSize Write(span<const std::byte> data);
+ StatusWithSize Write(std::span<const std::byte> data);
StatusWithSize Write(const void* data, size_t size) {
- return Write(span(static_cast<const std::byte*>(data), size));
+ return Write(std::span(static_cast<const std::byte*>(data), size));
}
// Reads size bytes from the input and writes them to the output.
@@ -110,7 +112,7 @@
template <size_t kBufferSize>
StatusWithSize AlignedWrite(Output& output,
size_t alignment_bytes,
- span<const span<const std::byte>> data) {
+ std::span<const std::span<const std::byte>> data) {
// TODO: This should convert to PW_CHECK once that is available for use in
// host tests.
if (alignment_bytes > kBufferSize) {
@@ -119,7 +121,7 @@
AlignedWriterBuffer<kBufferSize> buffer(alignment_bytes, output);
- for (const span<const std::byte>& chunk : data) {
+ for (const std::span<const std::byte>& chunk : data) {
if (StatusWithSize result = buffer.Write(chunk); !result.ok()) {
return result;
}
@@ -130,11 +132,12 @@
// Calls AlignedWrite with an initializer list.
template <size_t kBufferSize>
-StatusWithSize AlignedWrite(Output& output,
- size_t alignment_bytes,
- std::initializer_list<span<const std::byte>> data) {
+StatusWithSize AlignedWrite(
+ Output& output,
+ size_t alignment_bytes,
+ std::initializer_list<std::span<const std::byte>> data) {
return AlignedWrite<kBufferSize>(
- output, alignment_bytes, span(data.begin(), data.size()));
+ output, alignment_bytes, std::span(data.begin(), data.size()));
}
} // namespace pw
diff --git a/pw_kvs/public/pw_kvs/checksum.h b/pw_kvs/public/pw_kvs/checksum.h
index ff89d44..5899566 100644
--- a/pw_kvs/public/pw_kvs/checksum.h
+++ b/pw_kvs/public/pw_kvs/checksum.h
@@ -14,9 +14,9 @@
#pragma once
#include <cstddef>
+#include <span>
#include "pw_kvs/alignment.h"
-#include "pw_span/span.h"
#include "pw_status/status.h"
namespace pw::kvs {
@@ -27,18 +27,18 @@
virtual void Reset() = 0;
// Updates the checksum with the provided data.
- virtual void Update(span<const std::byte> data) = 0;
+ virtual void Update(std::span<const std::byte> data) = 0;
// Updates the checksum from a pointer and size.
void Update(const void* data, size_t size_bytes) {
- return Update(span(static_cast<const std::byte*>(data), size_bytes));
+ return Update(std::span(static_cast<const std::byte*>(data), size_bytes));
}
// Returns the final result of the checksum. Update() can no longer be called
- // after this. The returned span is valid until a call to Reset().
+ // after this. The returned std::span is valid until a call to Reset().
//
// Finish MUST be called before calling Verify.
- span<const std::byte> Finish() {
+ std::span<const std::byte> Finish() {
Finalize(); // Implemented by derived classes, if required.
return state();
}
@@ -51,24 +51,25 @@
// size_bytes() are ignored.
//
// Finish MUST be called before calling Verify.
- Status Verify(span<const std::byte> checksum) const;
+ Status Verify(std::span<const std::byte> checksum) const;
protected:
- // A derived class provides a span of its state buffer.
- constexpr ChecksumAlgorithm(span<const std::byte> state) : state_(state) {}
+ // A derived class provides a std::span of its state buffer.
+ constexpr ChecksumAlgorithm(std::span<const std::byte> state)
+ : state_(state) {}
// Protected destructor prevents deleting ChecksumAlgorithms from the base
// class, so that it is safe to have a non-virtual destructor.
~ChecksumAlgorithm() = default;
// Returns the current checksum state.
- constexpr span<const std::byte> state() const { return state_; }
+ constexpr std::span<const std::byte> state() const { return state_; }
private:
// Checksums that require finalizing operations may override this method.
virtual void Finalize() {}
- span<const std::byte> state_;
+ std::span<const std::byte> state_;
};
// A checksum algorithm for which Verify always passes. This can be used to
@@ -78,7 +79,7 @@
constexpr IgnoreChecksum() : ChecksumAlgorithm({}) {}
void Reset() override {}
- void Update(span<const std::byte>) override {}
+ void Update(std::span<const std::byte>) override {}
};
// Calculates a checksum in kAlignmentBytes chunks. Checksum classes can inherit
@@ -87,10 +88,10 @@
template <size_t kAlignmentBytes, size_t kBufferSize = kAlignmentBytes>
class AlignedChecksum : public ChecksumAlgorithm {
public:
- void Update(span<const std::byte> data) final { writer_.Write(data); }
+ void Update(std::span<const std::byte> data) final { writer_.Write(data); }
protected:
- constexpr AlignedChecksum(span<const std::byte> state)
+ constexpr AlignedChecksum(std::span<const std::byte> state)
: ChecksumAlgorithm(state),
output_(this),
writer_(kAlignmentBytes, output_) {}
@@ -105,7 +106,7 @@
FinalizeAligned();
}
- virtual void UpdateAligned(span<const std::byte> data) = 0;
+ virtual void UpdateAligned(std::span<const std::byte> data) = 0;
virtual void FinalizeAligned() = 0;
diff --git a/pw_kvs/public/pw_kvs/crc16_checksum.h b/pw_kvs/public/pw_kvs/crc16_checksum.h
index 51b096b..6cbef1f 100644
--- a/pw_kvs/public/pw_kvs/crc16_checksum.h
+++ b/pw_kvs/public/pw_kvs/crc16_checksum.h
@@ -13,19 +13,20 @@
// the License.
#pragma once
+#include <span>
+
#include "pw_checksum/ccitt_crc16.h"
#include "pw_kvs/checksum.h"
-#include "pw_span/span.h"
namespace pw::kvs {
class ChecksumCrc16 final : public ChecksumAlgorithm {
public:
- ChecksumCrc16() : ChecksumAlgorithm(as_bytes(span(&crc_, 1))) {}
+ ChecksumCrc16() : ChecksumAlgorithm(std::as_bytes(std::span(&crc_, 1))) {}
void Reset() override { crc_ = checksum::kCcittCrc16DefaultInitialValue; }
- void Update(span<const std::byte> data) override {
+ void Update(std::span<const std::byte> data) override {
crc_ = checksum::CcittCrc16(data, crc_);
}
diff --git a/pw_kvs/public/pw_kvs/fake_flash_memory.h b/pw_kvs/public/pw_kvs/fake_flash_memory.h
index a0916bf..5dc839c 100644
--- a/pw_kvs/public/pw_kvs/fake_flash_memory.h
+++ b/pw_kvs/public/pw_kvs/fake_flash_memory.h
@@ -17,10 +17,10 @@
#include <array>
#include <cstddef>
#include <cstring>
+#include <span>
#include "pw_containers/vector.h"
#include "pw_kvs/flash_memory.h"
-#include "pw_span/span.h"
#include "pw_status/status.h"
namespace pw::kvs {
@@ -50,7 +50,7 @@
Status Check(FlashMemory::Address start_address, size_t size);
// Determines if any of a series of FlashErrors applies to the operation.
- static Status Check(span<FlashError> errors,
+ static Status Check(std::span<FlashError> errors,
FlashMemory::Address address,
size_t size);
@@ -88,7 +88,7 @@
static constexpr std::byte kErasedValue = std::byte{0xff};
- FakeFlashMemory(span<std::byte> buffer,
+ FakeFlashMemory(std::span<std::byte> buffer,
size_t sector_size,
size_t sector_count,
size_t alignment_bytes = kDefaultAlignmentBytes,
@@ -110,16 +110,17 @@
Status Erase(Address address, size_t num_sectors) override;
// Reads bytes from flash into buffer.
- StatusWithSize Read(Address address, span<std::byte> output) override;
+ StatusWithSize Read(Address address, std::span<std::byte> output) override;
// Writes bytes to flash.
- StatusWithSize Write(Address address, span<const std::byte> data) override;
+ StatusWithSize Write(Address address,
+ std::span<const std::byte> data) override;
// Testing API
// Access the underlying buffer for testing purposes. Not part of the
// FlashMemory API.
- span<std::byte> buffer() const { return buffer_; }
+ std::span<std::byte> buffer() const { return buffer_; }
bool InjectReadError(const FlashError& error) {
if (read_errors_.full()) {
@@ -138,7 +139,7 @@
}
private:
- const span<std::byte> buffer_;
+ const std::span<std::byte> buffer_;
Vector<FlashError>& read_errors_;
Vector<FlashError>& write_errors_;
};
@@ -156,7 +157,7 @@
// Creates a flash memory initialized to the provided contents.
explicit FakeFlashMemoryBuffer(
- span<const std::byte> contents,
+ std::span<const std::byte> contents,
size_t alignment_bytes = kDefaultAlignmentBytes)
: FakeFlashMemory(buffer_,
kSectorSize,
diff --git a/pw_kvs/public/pw_kvs/flash_memory.h b/pw_kvs/public/pw_kvs/flash_memory.h
index b284415..ac8f429 100644
--- a/pw_kvs/public/pw_kvs/flash_memory.h
+++ b/pw_kvs/public/pw_kvs/flash_memory.h
@@ -16,9 +16,9 @@
#include <cstddef>
#include <cstdint>
#include <initializer_list>
+#include <span>
#include "pw_kvs/alignment.h"
-#include "pw_span/span.h"
#include "pw_status/status.h"
#include "pw_status/status_with_size.h"
@@ -71,10 +71,10 @@
// OK: success
// DEADLINE_EXCEEDED: timeout
// OUT_OF_RANGE: write does not fit in the flash memory
- virtual StatusWithSize Read(Address address, span<std::byte> output) = 0;
+ virtual StatusWithSize Read(Address address, std::span<std::byte> output) = 0;
StatusWithSize Read(Address address, void* buffer, size_t len) {
- return Read(address, span(static_cast<std::byte*>(buffer), len));
+ return Read(address, std::span(static_cast<std::byte*>(buffer), len));
}
// Writes bytes to flash. Blocking call.
@@ -85,13 +85,13 @@
// OUT_OF_RANGE: write does not fit in the memory
//
virtual StatusWithSize Write(Address destination_flash_address,
- span<const std::byte> data) = 0;
+ std::span<const std::byte> data) = 0;
StatusWithSize Write(Address destination_flash_address,
const void* data,
size_t len) {
return Write(destination_flash_address,
- span(static_cast<const std::byte*>(data), len));
+ std::span(static_cast<const std::byte*>(data), len));
}
// Convert an Address to an MCU pointer, this can be used for memory
@@ -135,7 +135,7 @@
: flash_(flash), address_(address) {}
private:
- StatusWithSize DoWrite(span<const std::byte> data) override;
+ StatusWithSize DoWrite(std::span<const std::byte> data) override;
FlashPartition& flash_;
FlashPartition::Address address_;
@@ -148,7 +148,7 @@
: flash_(flash), address_(address) {}
private:
- StatusWithSize DoRead(span<std::byte> data) override;
+ StatusWithSize DoRead(std::span<std::byte> data) override;
FlashPartition& flash_;
FlashPartition::Address address_;
@@ -196,10 +196,10 @@
// TIMEOUT, on timeout.
// INVALID_ARGUMENT, if address or length is invalid.
// UNKNOWN, on HAL error
- virtual StatusWithSize Read(Address address, span<std::byte> output);
+ virtual StatusWithSize Read(Address address, std::span<std::byte> output);
StatusWithSize Read(Address address, size_t length, void* output) {
- return Read(address, span(static_cast<std::byte*>(output), length));
+ return Read(address, std::span(static_cast<std::byte*>(output), length));
}
// Writes bytes to flash. Blocking call.
@@ -208,7 +208,8 @@
// INVALID_ARGUMENT, if address or length is invalid.
// PERMISSION_DENIED, if partition is read only.
// UNKNOWN, on HAL error
- virtual StatusWithSize Write(Address address, span<const std::byte> data);
+ virtual StatusWithSize Write(Address address,
+ std::span<const std::byte> data);
// Check to see if chunk of flash memory is erased. Address and len need to
// be aligned with FlashMemory.
@@ -224,7 +225,7 @@
// Checks to see if the data appears to be erased. No reads or writes occur;
// the FlashPartition simply compares the data to
// flash_.erased_memory_content().
- bool AppearsErased(span<const std::byte> data) const;
+ bool AppearsErased(std::span<const std::byte> data) const;
// Overridden by derived classes. The reported sector size is space available
// to users of FlashPartition. It accounts for space reserved in the sector
diff --git a/pw_kvs/public/pw_kvs/flash_partition_with_stats.h b/pw_kvs/public/pw_kvs/flash_partition_with_stats.h
index 9393fd9..569ab9f 100644
--- a/pw_kvs/public/pw_kvs/flash_partition_with_stats.h
+++ b/pw_kvs/public/pw_kvs/flash_partition_with_stats.h
@@ -38,8 +38,8 @@
Status Erase(Address address, size_t num_sectors) override;
- span<size_t> sector_erase_counters() {
- return span(sector_counters_.data(), sector_counters_.size());
+ std::span<size_t> sector_erase_counters() {
+ return std::span(sector_counters_.data(), sector_counters_.size());
}
size_t min_erase_count() const {
diff --git a/pw_kvs/public/pw_kvs/format.h b/pw_kvs/public/pw_kvs/format.h
index a2d843a..f6b33e7 100644
--- a/pw_kvs/public/pw_kvs/format.h
+++ b/pw_kvs/public/pw_kvs/format.h
@@ -14,9 +14,9 @@
#pragma once
#include <cstdint>
+#include <span>
#include "pw_kvs/checksum.h"
-#include "pw_span/span.h"
namespace pw::kvs {
@@ -56,7 +56,7 @@
// simultaneously supported formats.
class EntryFormats {
public:
- explicit constexpr EntryFormats(span<const EntryFormat> formats)
+ explicit constexpr EntryFormats(std::span<const EntryFormat> formats)
: formats_(formats) {}
explicit constexpr EntryFormats(const EntryFormat& format)
@@ -69,7 +69,7 @@
const EntryFormat* Find(uint32_t magic) const;
private:
- const span<const EntryFormat> formats_;
+ const std::span<const EntryFormat> formats_;
};
} // namespace internal
diff --git a/pw_kvs/public/pw_kvs/internal/entry.h b/pw_kvs/public/pw_kvs/internal/entry.h
index 3e75aeb..5305ab6 100644
--- a/pw_kvs/public/pw_kvs/internal/entry.h
+++ b/pw_kvs/public/pw_kvs/internal/entry.h
@@ -19,6 +19,7 @@
#include <array>
#include <cstddef>
#include <cstdint>
+#include <span>
#include <string_view>
#include "pw_kvs/alignment.h"
@@ -27,7 +28,6 @@
#include "pw_kvs/format.h"
#include "pw_kvs/internal/hash.h"
#include "pw_kvs/internal/key_descriptor.h"
-#include "pw_span/span.h"
namespace pw::kvs::internal {
@@ -64,7 +64,7 @@
Address address,
const EntryFormat& format,
std::string_view key,
- span<const std::byte> value,
+ std::span<const std::byte> value,
uint32_t transaction_id) {
return Entry(
partition, address, format, key, value, value.size(), transaction_id);
@@ -97,7 +97,8 @@
deleted() ? EntryState::kDeleted : EntryState::kValid};
}
- StatusWithSize Write(std::string_view key, span<const std::byte> value) const;
+ StatusWithSize Write(std::string_view key,
+ std::span<const std::byte> value) const;
// Changes the format and transcation ID for this entry. In order to calculate
// the new checksum, the entire entry is read into a small stack-allocated
@@ -119,20 +120,20 @@
ReadKey(partition(), address_, key_length(), key.data()), key_length());
}
- StatusWithSize ReadValue(span<std::byte> buffer,
+ StatusWithSize ReadValue(std::span<std::byte> buffer,
size_t offset_bytes = 0) const;
- Status ValueMatches(span<const std::byte> value) const;
+ Status ValueMatches(std::span<const std::byte> value) const;
Status VerifyChecksum(std::string_view key,
- span<const std::byte> value) const;
+ std::span<const std::byte> value) const;
Status VerifyChecksumInFlash() const;
// Calculates the total size of an entry, including padding.
static size_t size(const FlashPartition& partition,
std::string_view key,
- span<const std::byte> value) {
+ std::span<const std::byte> value) {
return AlignUp(sizeof(EntryHeader) + key.size() + value.size(),
std::max(partition.alignment_bytes(), kMinAlignmentBytes));
}
@@ -174,7 +175,7 @@
Address address,
const EntryFormat& format,
std::string_view key,
- span<const std::byte> value,
+ std::span<const std::byte> value,
uint16_t value_size_bytes,
uint32_t transaction_id);
@@ -196,12 +197,12 @@
return sizeof(EntryHeader) + key_length() + value_size();
}
- span<const std::byte> checksum_bytes() const {
- return as_bytes(span(&header_.checksum, 1));
+ std::span<const std::byte> checksum_bytes() const {
+ return std::as_bytes(std::span(&header_.checksum, 1));
}
- span<const std::byte> CalculateChecksum(std::string_view key,
- span<const std::byte> value) const;
+ std::span<const std::byte> CalculateChecksum(
+ std::string_view key, std::span<const std::byte> value) const;
Status CalculateChecksumFromFlash();
diff --git a/pw_kvs/public/pw_kvs/internal/entry_cache.h b/pw_kvs/public/pw_kvs/internal/entry_cache.h
index 5ed2f15..f347738 100644
--- a/pw_kvs/public/pw_kvs/internal/entry_cache.h
+++ b/pw_kvs/public/pw_kvs/internal/entry_cache.h
@@ -15,6 +15,7 @@
#include <cstddef>
#include <cstdint>
+#include <span>
#include <string_view>
#include <type_traits>
@@ -23,7 +24,6 @@
#include "pw_kvs/format.h"
#include "pw_kvs/internal/key_descriptor.h"
#include "pw_kvs/internal/sectors.h"
-#include "pw_span/span.h"
namespace pw::kvs::internal {
@@ -45,7 +45,7 @@
uint32_t first_address() const { return addresses_[0]; }
// All addresses for this entry, including redundant entries, if any.
- const span<Address>& addresses() const { return addresses_; }
+ const std::span<Address>& addresses() const { return addresses_; }
// True if the KeyDesctiptor's transaction ID is newer than the specified ID.
bool IsNewerThan(uint32_t other_transaction_id) const {
@@ -57,7 +57,7 @@
// than allowed by the redundancy.
void AddNewAddress(Address address) {
addresses_[addresses_.size()] = address;
- addresses_ = span(addresses_.begin(), addresses_.size() + 1);
+ addresses_ = std::span(addresses_.begin(), addresses_.size() + 1);
}
// Remove an address from the entry metadata.
@@ -70,11 +70,12 @@
private:
friend class EntryCache;
- constexpr EntryMetadata(KeyDescriptor& descriptor, span<Address> addresses)
+ constexpr EntryMetadata(KeyDescriptor& descriptor,
+ std::span<Address> addresses)
: descriptor_(&descriptor), addresses_(addresses) {}
KeyDescriptor* descriptor_;
- span<Address> addresses_;
+ std::span<Address> addresses_;
};
// Tracks entry metadata. Combines KeyDescriptors and with their associated
@@ -215,8 +216,8 @@
// address slot available.
void AddAddressIfRoom(size_t descriptor_index, Address address) const;
- // Returns a span of the valid addresses for the descriptor.
- span<Address> addresses(size_t descriptor_index) const;
+ // Returns a std::span of the valid addresses for the descriptor.
+ std::span<Address> addresses(size_t descriptor_index) const;
Address* first_address(size_t descriptor_index) const {
return &addresses_[descriptor_index * redundancy_];
diff --git a/pw_kvs/public/pw_kvs/internal/sectors.h b/pw_kvs/public/pw_kvs/internal/sectors.h
index 7f89bb5..d2f4565 100644
--- a/pw_kvs/public/pw_kvs/internal/sectors.h
+++ b/pw_kvs/public/pw_kvs/internal/sectors.h
@@ -16,10 +16,10 @@
#include <climits>
#include <cstddef>
#include <cstdint>
+#include <span>
#include "pw_containers/vector.h"
#include "pw_kvs/flash_memory.h"
-#include "pw_span/span.h"
namespace pw::kvs::internal {
@@ -159,7 +159,7 @@
// least 1 empty sector. Addresses in reserved_addresses are avoided.
Status FindSpace(SectorDescriptor** found_sector,
size_t size,
- span<const Address> reserved_addresses) {
+ std::span<const Address> reserved_addresses) {
return Find(kAppendEntry, found_sector, size, {}, reserved_addresses);
}
@@ -168,8 +168,8 @@
Status FindSpaceDuringGarbageCollection(
SectorDescriptor** found_sector,
size_t size,
- span<const Address> addresses_to_skip,
- span<const Address> reserved_addresses) {
+ std::span<const Address> addresses_to_skip,
+ std::span<const Address> reserved_addresses) {
return Find(kGarbageCollect,
found_sector,
size,
@@ -180,7 +180,7 @@
// Finds a sector that is ready to be garbage collected. Returns nullptr if no
// sectors can / need to be garbage collected.
SectorDescriptor* FindSectorToGarbageCollect(
- span<const Address> addresses_to_avoid) const;
+ std::span<const Address> addresses_to_avoid) const;
// The number of sectors in use.
size_t size() const { return descriptors_.size(); }
@@ -210,8 +210,8 @@
Status Find(FindMode find_mode,
SectorDescriptor** found_sector,
size_t size,
- span<const Address> addresses_to_skip,
- span<const Address> reserved_addresses);
+ std::span<const Address> addresses_to_skip,
+ std::span<const Address> reserved_addresses);
SectorDescriptor& WearLeveledSectorFromIndex(size_t idx) const;
diff --git a/pw_kvs/public/pw_kvs/internal/span_traits.h b/pw_kvs/public/pw_kvs/internal/span_traits.h
index 18098ed..4c4ab56 100644
--- a/pw_kvs/public/pw_kvs/internal/span_traits.h
+++ b/pw_kvs/public/pw_kvs/internal/span_traits.h
@@ -18,12 +18,13 @@
namespace pw::kvs {
namespace internal {
-template <typename T, typename = decltype(span(std::declval<T>()))>
+template <typename T, typename = decltype(std::span(std::declval<T>()))>
constexpr bool ConvertsToSpan(int) {
return true;
}
-// If the expression span(T) fails, then the type can't be converted to a span.
+// If the expression std::span(T) fails, then the type can't be converted to a
+// std::span.
template <typename T>
constexpr bool ConvertsToSpan(...) {
return false;
@@ -31,7 +32,7 @@
} // namespace internal
-// Traits class to detect if the type converts to a span.
+// Traits class to detect if the type converts to a std::span.
template <typename T>
struct ConvertsToSpan
: public std::bool_constant<
diff --git a/pw_kvs/public/pw_kvs/io.h b/pw_kvs/public/pw_kvs/io.h
index 71d1eb2..167182f 100644
--- a/pw_kvs/public/pw_kvs/io.h
+++ b/pw_kvs/public/pw_kvs/io.h
@@ -14,9 +14,9 @@
#pragma once
#include <cstddef>
+#include <span>
#include <type_traits>
-#include "pw_span/span.h"
#include "pw_status/status_with_size.h"
namespace pw {
@@ -34,41 +34,43 @@
} // namespace internal
// Writes bytes to an unspecified output. Provides a Write function that takes a
-// span of bytes and returns a Status.
+// std::span of bytes and returns a Status.
class Output {
public:
- StatusWithSize Write(span<const std::byte> data) { return DoWrite(data); }
+ StatusWithSize Write(std::span<const std::byte> data) {
+ return DoWrite(data);
+ }
// Convenience wrapper for writing data from a pointer and length.
StatusWithSize Write(const void* data, size_t size_bytes) {
- return Write(span(static_cast<const std::byte*>(data), size_bytes));
+ return Write(std::span(static_cast<const std::byte*>(data), size_bytes));
}
protected:
~Output() = default;
private:
- virtual StatusWithSize DoWrite(span<const std::byte> data) = 0;
+ virtual StatusWithSize DoWrite(std::span<const std::byte> data) = 0;
};
class Input {
public:
- StatusWithSize Read(span<std::byte> data) { return DoRead(data); }
+ StatusWithSize Read(std::span<std::byte> data) { return DoRead(data); }
// Convenience wrapper for reading data from a pointer and length.
StatusWithSize Read(void* data, size_t size_bytes) {
- return Read(span(static_cast<std::byte*>(data), size_bytes));
+ return Read(std::span(static_cast<std::byte*>(data), size_bytes));
}
protected:
~Input() = default;
private:
- virtual StatusWithSize DoRead(span<std::byte> data) = 0;
+ virtual StatusWithSize DoRead(std::span<std::byte> data) = 0;
};
-// Output adapter that calls a method on a class with a span of bytes. If the
-// method returns void instead of the expected Status, Write always returns
+// Output adapter that calls a method on a class with a std::span of bytes. If
+// the method returns void instead of the expected Status, Write always returns
// Status::OK.
template <auto kMethod>
class OutputToMethod final : public Output {
@@ -78,7 +80,7 @@
constexpr OutputToMethod(Class* object) : object_(*object) {}
private:
- StatusWithSize DoWrite(span<const std::byte> data) override {
+ StatusWithSize DoWrite(std::span<const std::byte> data) override {
using Return = typename internal::FunctionTraits<decltype(kMethod)>::Return;
if constexpr (std::is_void_v<Return>) {
@@ -96,15 +98,15 @@
// Output adapter that calls a free function.
class OutputToFunction final : public Output {
public:
- OutputToFunction(StatusWithSize (*function)(span<const std::byte>))
+ OutputToFunction(StatusWithSize (*function)(std::span<const std::byte>))
: function_(function) {}
private:
- StatusWithSize DoWrite(span<const std::byte> data) override {
+ StatusWithSize DoWrite(std::span<const std::byte> data) override {
return function_(data);
}
- StatusWithSize (*function_)(span<const std::byte>);
+ StatusWithSize (*function_)(std::span<const std::byte>);
};
} // namespace pw
diff --git a/pw_kvs/public/pw_kvs/key_value_store.h b/pw_kvs/public/pw_kvs/key_value_store.h
index f382c60..01b055d 100644
--- a/pw_kvs/public/pw_kvs/key_value_store.h
+++ b/pw_kvs/public/pw_kvs/key_value_store.h
@@ -16,6 +16,7 @@
#include <array>
#include <cstddef>
#include <cstdint>
+#include <span>
#include <string_view>
#include <type_traits>
@@ -28,7 +29,6 @@
#include "pw_kvs/internal/key_descriptor.h"
#include "pw_kvs/internal/sectors.h"
#include "pw_kvs/internal/span_traits.h"
-#include "pw_span/span.h"
#include "pw_status/status.h"
#include "pw_status/status_with_size.h"
@@ -116,12 +116,13 @@
// INVALID_ARGUMENT: key is empty or too long or value is too large
//
StatusWithSize Get(std::string_view key,
- span<std::byte> value,
+ std::span<std::byte> value,
size_t offset_bytes = 0) const;
// This overload of Get accepts a pointer to a trivially copyable object.
- // If the value is an array, call Get with as_writable_bytes(span(array)),
- // or pass a pointer to the array instead of the array itself.
+ // If the value is an array, call Get with
+ // std::as_writable_bytes(std::span(array)), or pass a pointer to the array
+ // instead of the array itself.
template <typename Pointer,
typename = std::enable_if_t<std::is_pointer_v<Pointer>>>
Status Get(const std::string_view& key, const Pointer& pointer) const {
@@ -133,7 +134,7 @@
// Adds a key-value entry to the KVS. If the key was already present, its
// value is overwritten.
//
- // The value may be a span of bytes or a trivially copyable object.
+ // The value may be a std::span of bytes or a trivially copyable object.
//
// In the current implementation, all keys in the KVS must have a unique hash.
// If Put is called with a key whose hash matches an existing key, nothing
@@ -150,10 +151,10 @@
template <typename T>
Status Put(const std::string_view& key, const T& value) {
if constexpr (ConvertsToSpan<T>::value) {
- return PutBytes(key, as_bytes(span(value)));
+ return PutBytes(key, std::as_bytes(std::span(value)));
} else {
CheckThatObjectCanBePutOrGet<T>();
- return PutBytes(key, as_bytes(span(&value, 1)));
+ return PutBytes(key, std::as_bytes(std::span(&value, 1)));
}
}
@@ -202,7 +203,7 @@
// Gets the value referred to by this iterator. Equivalent to
// KeyValueStore::Get.
- StatusWithSize Get(span<std::byte> value_buffer,
+ StatusWithSize Get(std::span<std::byte> value_buffer,
size_t offset_bytes = 0) const {
return kvs_.Get(key(), *iterator_, value_buffer, offset_bytes);
}
@@ -315,7 +316,7 @@
// In the future, will be able to provide additional EntryFormats for
// backwards compatibility.
KeyValueStore(FlashPartition* partition,
- span<const EntryFormat> formats,
+ std::span<const EntryFormat> formats,
const Options& options,
size_t redundancy,
Vector<SectorDescriptor>& sector_descriptor_list,
@@ -332,8 +333,9 @@
static_assert(
std::is_trivially_copyable_v<T> && !std::is_pointer_v<T>,
"Only trivially copyable, non-pointer objects may be Put and Get by "
- "value. Any value may be stored by converting it to a byte span with "
- "as_bytes(span(&value, 1)) or as_writable_bytes(span(&value, 1)).");
+ "value. Any value may be stored by converting it to a byte std::span "
+ "with std::as_bytes(std::span(&value, 1)) or "
+ "std::as_writable_bytes(std::span(&value, 1)).");
}
Status InitializeMetadata();
@@ -342,7 +344,7 @@
Address start_address,
Address* next_entry_address);
- Status PutBytes(std::string_view key, span<const std::byte> value);
+ Status PutBytes(std::string_view key, std::span<const std::byte> value);
StatusWithSize ValueSize(const EntryMetadata& metadata) const;
@@ -372,7 +374,7 @@
StatusWithSize Get(std::string_view key,
const EntryMetadata& metadata,
- span<std::byte> value_buffer,
+ std::span<std::byte> value_buffer,
size_t offset_bytes) const;
Status FixedSizeGet(std::string_view key,
@@ -390,12 +392,13 @@
Status WriteEntryForExistingKey(EntryMetadata& metadata,
EntryState new_state,
std::string_view key,
- span<const std::byte> value);
+ std::span<const std::byte> value);
- Status WriteEntryForNewKey(std::string_view key, span<const std::byte> value);
+ Status WriteEntryForNewKey(std::string_view key,
+ std::span<const std::byte> value);
Status WriteEntry(std::string_view key,
- span<const std::byte> value,
+ std::span<const std::byte> value,
EntryState new_state,
EntryMetadata* prior_metadata = nullptr,
const internal::Entry* prior_entry = nullptr);
@@ -414,13 +417,13 @@
Status GetSectorForWrite(SectorDescriptor** sector,
size_t entry_size,
- span<const Address> addresses_to_skip);
+ std::span<const Address> addresses_to_skip);
Status MarkSectorCorruptIfNotOk(Status status, SectorDescriptor* sector);
Status AppendEntry(const Entry& entry,
std::string_view key,
- span<const std::byte> value);
+ std::span<const std::byte> value);
StatusWithSize CopyEntryToSector(Entry& entry,
SectorDescriptor* new_sector,
@@ -428,18 +431,19 @@
Status RelocateEntry(const EntryMetadata& metadata,
KeyValueStore::Address& address,
- span<const Address> addresses_to_skip);
+ std::span<const Address> addresses_to_skip);
// Find and garbage collect a singe sector that does not include an address to
// skip.
- Status GarbageCollect(span<const Address> addresses_to_skip);
+ Status GarbageCollect(std::span<const Address> addresses_to_skip);
- Status RelocateKeyAddressesInSector(SectorDescriptor& sector_to_gc,
- const EntryMetadata& descriptor,
- span<const Address> addresses_to_skip);
+ Status RelocateKeyAddressesInSector(
+ SectorDescriptor& sector_to_gc,
+ const EntryMetadata& descriptor,
+ std::span<const Address> addresses_to_skip);
Status GarbageCollectSector(SectorDescriptor& sector_to_gc,
- span<const Address> addresses_to_skip);
+ std::span<const Address> addresses_to_skip);
// Ensure that all entries are on the primary (first) format. Entries that are
// not on the primary format are rewritten.
@@ -461,7 +465,7 @@
internal::Entry CreateEntry(Address address,
std::string_view key,
- span<const std::byte> value,
+ std::span<const std::byte> value,
EntryState state);
void LogSectors() const;
@@ -525,7 +529,7 @@
const Options& options = {})
: KeyValueStoreBuffer(
partition,
- span(reinterpret_cast<const EntryFormat (&)[1]>(format)),
+ std::span(reinterpret_cast<const EntryFormat (&)[1]>(format)),
options) {
static_assert(kEntryFormats == 1,
"kEntryFormats EntryFormats must be specified");
@@ -534,7 +538,7 @@
// Constructs a KeyValueStore on the partition. Supports multiple entry
// formats. The first EntryFormat is used for new entries.
KeyValueStoreBuffer(FlashPartition* partition,
- span<const EntryFormat, kEntryFormats> formats,
+ std::span<const EntryFormat, kEntryFormats> formats,
const Options& options = {})
: KeyValueStore(partition,
formats_,
diff --git a/pw_kvs/sectors.cc b/pw_kvs/sectors.cc
index d36e01c..01547ec 100644
--- a/pw_kvs/sectors.cc
+++ b/pw_kvs/sectors.cc
@@ -33,8 +33,8 @@
Status Sectors::Find(FindMode find_mode,
SectorDescriptor** found_sector,
size_t size,
- span<const Address> addresses_to_skip,
- span<const Address> reserved_addresses) {
+ std::span<const Address> addresses_to_skip,
+ std::span<const Address> reserved_addresses) {
SectorDescriptor* first_empty_sector = nullptr;
bool at_least_two_empty_sectors = (find_mode == kGarbageCollect);
@@ -99,7 +99,7 @@
}
// Skip sectors in the skip list.
- if (Contains(span(temp_sectors_to_skip_, sectors_to_skip), sector)) {
+ if (Contains(std::span(temp_sectors_to_skip_, sectors_to_skip), sector)) {
continue;
}
@@ -161,7 +161,7 @@
// TODO: Consider breaking this function into smaller sub-chunks.
SectorDescriptor* Sectors::FindSectorToGarbageCollect(
- span<const Address> reserved_addresses) const {
+ std::span<const Address> reserved_addresses) const {
const size_t sector_size_bytes = partition_.sector_size_bytes();
SectorDescriptor* sector_candidate = nullptr;
size_t candidate_bytes = 0;
@@ -171,7 +171,8 @@
temp_sectors_to_skip_[i] = &FromAddress(reserved_addresses[i]);
DBG(" Skip sector %u", Index(reserved_addresses[i]));
}
- const span sectors_to_skip(temp_sectors_to_skip_, reserved_addresses.size());
+ const std::span sectors_to_skip(temp_sectors_to_skip_,
+ reserved_addresses.size());
// Step 1: Try to find a sectors with stale keys and no valid keys (no
// relocation needed). Use the first such sector found, as that will help the
diff --git a/pw_protobuf/codegen_test.cc b/pw_protobuf/codegen_test.cc
index 1001a86..c9845c9 100644
--- a/pw_protobuf/codegen_test.cc
+++ b/pw_protobuf/codegen_test.cc
@@ -166,7 +166,7 @@
};
// clang-format on
- span<const std::byte> proto;
+ std::span<const std::byte> proto;
EXPECT_EQ(encoder.Encode(&proto), Status::OK);
EXPECT_EQ(proto.size(), sizeof(expected_proto));
EXPECT_EQ(std::memcmp(proto.data(), expected_proto, sizeof(expected_proto)),
@@ -185,7 +185,7 @@
constexpr uint8_t expected_proto[] = {
0x08, 0x00, 0x08, 0x10, 0x08, 0x20, 0x08, 0x30};
- span<const std::byte> proto;
+ std::span<const std::byte> proto;
EXPECT_EQ(encoder.Encode(&proto), Status::OK);
EXPECT_EQ(proto.size(), sizeof(expected_proto));
EXPECT_EQ(std::memcmp(proto.data(), expected_proto, sizeof(expected_proto)),
@@ -201,7 +201,7 @@
repeated_test.WriteUint32s(values);
constexpr uint8_t expected_proto[] = {0x0a, 0x04, 0x00, 0x10, 0x20, 0x30};
- span<const std::byte> proto;
+ std::span<const std::byte> proto;
EXPECT_EQ(encoder.Encode(&proto), Status::OK);
EXPECT_EQ(proto.size(), sizeof(expected_proto));
EXPECT_EQ(std::memcmp(proto.data(), expected_proto, sizeof(expected_proto)),
@@ -221,7 +221,7 @@
constexpr uint8_t expected_proto[] = {
0x1a, 0x03, 't', 'h', 'e', 0x1a, 0x5, 'q', 'u', 'i', 'c', 'k',
0x1a, 0x5, 'b', 'r', 'o', 'w', 'n', 0x1a, 0x3, 'f', 'o', 'x'};
- span<const std::byte> proto;
+ std::span<const std::byte> proto;
EXPECT_EQ(encoder.Encode(&proto), Status::OK);
EXPECT_EQ(proto.size(), sizeof(expected_proto));
EXPECT_EQ(std::memcmp(proto.data(), expected_proto, sizeof(expected_proto)),
@@ -245,7 +245,7 @@
0x01, 0x10, 0x02, 0x2a, 0x04, 0x08, 0x02, 0x10, 0x04};
// clang-format on
- span<const std::byte> proto;
+ std::span<const std::byte> proto;
EXPECT_EQ(encoder.Encode(&proto), Status::OK);
EXPECT_EQ(proto.size(), sizeof(expected_proto));
EXPECT_EQ(std::memcmp(proto.data(), expected_proto, sizeof(expected_proto)),
@@ -269,7 +269,7 @@
constexpr uint8_t expected_proto[] = {
0x08, 0x03, 0x1a, 0x06, 0x0a, 0x04, 0xde, 0xad, 0xbe, 0xef};
- span<const std::byte> proto;
+ std::span<const std::byte> proto;
EXPECT_EQ(encoder.Encode(&proto), Status::OK);
EXPECT_EQ(proto.size(), sizeof(expected_proto));
EXPECT_EQ(std::memcmp(proto.data(), expected_proto, sizeof(expected_proto)),
@@ -293,7 +293,7 @@
end.WriteNanoseconds(490367432);
}
- span<const std::byte> proto;
+ std::span<const std::byte> proto;
EXPECT_EQ(encoder.Encode(&proto), Status::OK);
}
@@ -306,7 +306,7 @@
packed.WriteRep(std::span<const int64_t>(repeated));
packed.WritePacked("packed");
- span<const std::byte> proto;
+ std::span<const std::byte> proto;
EXPECT_EQ(encoder.Encode(&proto), Status::OK);
}
diff --git a/pw_protobuf/decoder.cc b/pw_protobuf/decoder.cc
index 3183556..72127be 100644
--- a/pw_protobuf/decoder.cc
+++ b/pw_protobuf/decoder.cc
@@ -100,7 +100,7 @@
}
Status Decoder::ReadString(std::string_view* out) {
- span<const std::byte> bytes;
+ std::span<const std::byte> bytes;
Status status = ReadDelimited(&bytes);
if (!status.ok()) {
return status;
@@ -117,7 +117,7 @@
return 0;
}
- span<const std::byte> remainder = proto_.subspan(key_size);
+ std::span<const std::byte> remainder = proto_.subspan(key_size);
WireType wire_type = static_cast<WireType>(key & kWireTypeMask);
uint64_t value = 0;
size_t expected_size = 0;
@@ -207,7 +207,7 @@
return Status::OK;
}
-Status Decoder::ReadDelimited(span<const std::byte>* out) {
+Status Decoder::ReadDelimited(std::span<const std::byte>* out) {
Status status = ConsumeKey(WireType::kDelimited);
if (!status.ok()) {
return status;
@@ -231,7 +231,7 @@
return Status::OK;
}
-Status CallbackDecoder::Decode(span<const std::byte> proto) {
+Status CallbackDecoder::Decode(std::span<const std::byte> proto) {
if (handler_ == nullptr || state_ != kReady) {
return Status::FAILED_PRECONDITION;
}
diff --git a/pw_protobuf/decoder_test.cc b/pw_protobuf/decoder_test.cc
index abc9d54..7dad4b2 100644
--- a/pw_protobuf/decoder_test.cc
+++ b/pw_protobuf/decoder_test.cc
@@ -80,7 +80,7 @@
};
// clang-format on
- Decoder decoder(as_bytes(span(encoded_proto)));
+ Decoder decoder(std::as_bytes(std::span(encoded_proto)));
int32_t v1 = 0;
EXPECT_EQ(decoder.Next(), Status::OK);
@@ -142,7 +142,7 @@
};
// clang-format on
- Decoder decoder(as_bytes(span(encoded_proto)));
+ Decoder decoder(std::as_bytes(std::span(encoded_proto)));
// Don't process any fields except for the fourth. Next should still iterate
// correctly despite field values not being consumed.
@@ -178,7 +178,8 @@
// clang-format on
decoder.set_handler(&handler);
- EXPECT_EQ(decoder.Decode(as_bytes(span(encoded_proto))), Status::OK);
+ EXPECT_EQ(decoder.Decode(std::as_bytes(std::span(encoded_proto))),
+ Status::OK);
EXPECT_TRUE(handler.called);
EXPECT_EQ(handler.test_int32, 42);
EXPECT_EQ(handler.test_sint32, -13);
@@ -204,7 +205,8 @@
// clang-format on
decoder.set_handler(&handler);
- EXPECT_EQ(decoder.Decode(as_bytes(span(encoded_proto))), Status::OK);
+ EXPECT_EQ(decoder.Decode(std::as_bytes(std::span(encoded_proto))),
+ Status::OK);
EXPECT_TRUE(handler.called);
EXPECT_EQ(handler.test_int32, 44);
}
@@ -214,7 +216,7 @@
TestDecodeHandler handler;
decoder.set_handler(&handler);
- EXPECT_EQ(decoder.Decode(span<std::byte>()), Status::OK);
+ EXPECT_EQ(decoder.Decode(std::span<std::byte>()), Status::OK);
EXPECT_FALSE(handler.called);
EXPECT_EQ(handler.test_int32, 0);
EXPECT_EQ(handler.test_sint32, 0);
@@ -228,7 +230,8 @@
uint8_t encoded_proto[] = {0x08};
decoder.set_handler(&handler);
- EXPECT_EQ(decoder.Decode(as_bytes(span(encoded_proto))), Status::DATA_LOSS);
+ EXPECT_EQ(decoder.Decode(std::as_bytes(std::span(encoded_proto))),
+ Status::DATA_LOSS);
}
// Only processes fields numbered 1 or 3.
@@ -282,7 +285,8 @@
// clang-format on
decoder.set_handler(&handler);
- EXPECT_EQ(decoder.Decode(as_bytes(span(encoded_proto))), Status::OK);
+ EXPECT_EQ(decoder.Decode(std::as_bytes(std::span(encoded_proto))),
+ Status::OK);
EXPECT_TRUE(handler.called);
EXPECT_EQ(handler.field_one, 42);
EXPECT_EQ(handler.field_three, 99);
@@ -331,7 +335,8 @@
// clang-format on
decoder.set_handler(&handler);
- EXPECT_EQ(decoder.Decode(as_bytes(span(encoded_proto))), Status::CANCELLED);
+ EXPECT_EQ(decoder.Decode(std::as_bytes(std::span(encoded_proto))),
+ Status::CANCELLED);
EXPECT_EQ(handler.field_one, 42);
EXPECT_EQ(handler.field_three, 1111);
}
diff --git a/pw_protobuf/encoder.cc b/pw_protobuf/encoder.cc
index c20b093..96b9b7d 100644
--- a/pw_protobuf/encoder.cc
+++ b/pw_protobuf/encoder.cc
@@ -30,7 +30,7 @@
return encode_status_;
}
- span varint_buf = buffer_.last(RemainingSize());
+ std::span varint_buf = buffer_.last(RemainingSize());
if (varint_buf.empty()) {
encode_status_ = Status::RESOURCE_EXHAUSTED;
return encode_status_;
@@ -126,9 +126,9 @@
return Status::OK;
}
-Status Encoder::Encode(span<const std::byte>* out) {
+Status Encoder::Encode(std::span<const std::byte>* out) {
if (!encode_status_.ok()) {
- *out = span<const std::byte>();
+ *out = std::span<const std::byte>();
return encode_status_;
}
@@ -152,7 +152,7 @@
while (read_cursor < cursor_) {
SizeType nested_size = *size_cursor;
- span<std::byte> varint_buf(write_cursor, sizeof(*size_cursor));
+ std::span<std::byte> varint_buf(write_cursor, sizeof(*size_cursor));
size_t varint_size =
pw::varint::EncodeLittleEndianBase128(nested_size, varint_buf);
diff --git a/pw_protobuf/encoder_fuzzer.cc b/pw_protobuf/encoder_fuzzer.cc
index a59e3b3..e0991d0 100644
--- a/pw_protobuf/encoder_fuzzer.cc
+++ b/pw_protobuf/encoder_fuzzer.cc
@@ -18,10 +18,10 @@
#include <cstddef>
#include <cstdint>
#include <cstring>
+#include <span>
#include <vector>
#include "pw_protobuf/encoder.h"
-#include "pw_span/span.h"
namespace {
@@ -72,11 +72,11 @@
}
// Uses the given |provider| to generate several instances of T, store them in
-// |data|, and then return a span to them. It is the caller's responsbility to
-// ensure |data| remains in scope as long as the returned span.
+// |data|, and then return a std::span to them. It is the caller's responsbility
+// to ensure |data| remains in scope as long as the returned std::span.
template <typename T>
-pw::span<const T> ConsumeSpan(FuzzedDataProvider* provider,
- std::vector<T>* data) {
+std::span<const T> ConsumeSpan(FuzzedDataProvider* provider,
+ std::vector<T>* data) {
size_t num = ConsumeSize<T>(provider);
size_t off = data->size();
data->reserve(off + num);
@@ -87,7 +87,7 @@
data->push_back(provider->ConsumeIntegral<T>());
}
}
- return pw::span(&((*data)[off]), num);
+ return std::span(&((*data)[off]), num);
}
// Uses the given |provider| to generate a string, store it in |data|, and
@@ -104,16 +104,16 @@
}
// Uses the given |provider| to generate non-arithmetic bytes, store them in
-// |data|, and return a span to them. It is the caller's responsbility to
-// ensure |data| remains in scope as long as the returned span.
-pw::span<const std::byte> ConsumeBytes(FuzzedDataProvider* provider,
- std::vector<std::byte>* data) {
+// |data|, and return a std::span to them. It is the caller's responsbility to
+// ensure |data| remains in scope as long as the returned std::span.
+std::span<const std::byte> ConsumeBytes(FuzzedDataProvider* provider,
+ std::vector<std::byte>* data) {
size_t num = ConsumeSize<std::byte>(provider);
auto added = provider->ConsumeBytes<std::byte>(num);
size_t off = data->size();
num = added.size();
data->insert(data->end(), added.begin(), added.end());
- return pw::span(&((*data)[off]), num);
+ return std::span(&((*data)[off]), num);
}
} // namespace
@@ -127,13 +127,13 @@
// the rest.
size_t unpoisoned_length =
provider.ConsumeIntegralInRange<size_t>(0, sizeof(buffer));
- pw::span<std::byte> unpoisoned(buffer, unpoisoned_length);
+ std::span<std::byte> unpoisoned(buffer, unpoisoned_length);
void* poisoned = &buffer[unpoisoned_length];
size_t poisoned_length = sizeof(buffer) - unpoisoned_length;
ASAN_POISON_MEMORY_REGION(poisoned, poisoned_length);
pw::protobuf::NestedEncoder encoder(unpoisoned);
- pw::span<const std::byte> out;
+ std::span<const std::byte> out;
// Storage for generated spans
std::vector<uint32_t> u32s;
diff --git a/pw_protobuf/encoder_test.cc b/pw_protobuf/encoder_test.cc
index e812dca..8a86057 100644
--- a/pw_protobuf/encoder_test.cc
+++ b/pw_protobuf/encoder_test.cc
@@ -93,7 +93,7 @@
EXPECT_EQ(encoder.WriteString(kTestProtoErrorMessageField, "broken 💩"),
Status::OK);
- span<const std::byte> encoded;
+ std::span<const std::byte> encoded;
EXPECT_EQ(encoder.Encode(&encoded), Status::OK);
EXPECT_EQ(encoded.size(), sizeof(encoded_proto));
EXPECT_EQ(std::memcmp(encoded.data(), encoded_proto, encoded.size()), 0);
@@ -115,7 +115,7 @@
EXPECT_EQ(encoder.WriteFloat(kTestProtoRatioField, 1.618034),
Status::RESOURCE_EXHAUSTED);
- span<const std::byte> encoded;
+ std::span<const std::byte> encoded;
EXPECT_EQ(encoder.Encode(&encoded), Status::RESOURCE_EXHAUSTED);
EXPECT_EQ(encoded.size(), 0u);
}
@@ -133,7 +133,7 @@
encoder.Clear();
EXPECT_EQ(encoder.WriteBool(19091, false), Status::INVALID_ARGUMENT);
- span<const std::byte> encoded;
+ std::span<const std::byte> encoded;
EXPECT_EQ(encoder.Encode(&encoded), Status::INVALID_ARGUMENT);
EXPECT_EQ(encoded.size(), 0u);
}
@@ -213,7 +213,7 @@
};
// clang-format on
- span<const std::byte> encoded;
+ std::span<const std::byte> encoded;
EXPECT_EQ(encoder.Encode(&encoded), Status::OK);
EXPECT_EQ(encoded.size(), sizeof(encoded_proto));
EXPECT_EQ(std::memcmp(encoded.data(), encoded_proto, encoded.size()), 0);
@@ -273,7 +273,7 @@
constexpr uint8_t encoded_proto[] = {
0x08, 0x00, 0x08, 0x32, 0x08, 0x64, 0x08, 0x96, 0x01, 0x08, 0xc8, 0x01};
- span<const std::byte> encoded;
+ std::span<const std::byte> encoded;
EXPECT_EQ(encoder.Encode(&encoded), Status::OK);
EXPECT_EQ(encoded.size(), sizeof(encoded_proto));
EXPECT_EQ(std::memcmp(encoded.data(), encoded_proto, encoded.size()), 0);
@@ -291,7 +291,7 @@
0x0a, 0x07, 0x00, 0x32, 0x64, 0x96, 0x01, 0xc8, 0x01};
// key size v[0] v[1] v[2] v[3] v[4]
- span<const std::byte> encoded;
+ std::span<const std::byte> encoded;
EXPECT_EQ(encoder.Encode(&encoded), Status::OK);
EXPECT_EQ(encoded.size(), sizeof(encoded_proto));
EXPECT_EQ(std::memcmp(encoded.data(), encoded_proto, encoded.size()), 0);
@@ -304,7 +304,7 @@
constexpr uint32_t values[] = {0, 50, 100, 150, 200};
encoder.WritePackedUint32(1, values);
- span<const std::byte> encoded;
+ std::span<const std::byte> encoded;
EXPECT_EQ(encoder.Encode(&encoded), Status::RESOURCE_EXHAUSTED);
EXPECT_EQ(encoded.size(), 0u);
}
@@ -326,7 +326,7 @@
0x00, 0x00, 0x00, 0x96, 0x00, 0x00, 0x00, 0xc8, 0x00, 0x00, 0x00,
0x12, 0x08, 0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01};
- span<const std::byte> encoded;
+ std::span<const std::byte> encoded;
EXPECT_EQ(encoder.Encode(&encoded), Status::OK);
EXPECT_EQ(encoded.size(), sizeof(encoded_proto));
EXPECT_EQ(std::memcmp(encoded.data(), encoded_proto, encoded.size()), 0);
@@ -343,7 +343,7 @@
constexpr uint8_t encoded_proto[] = {
0x0a, 0x09, 0xc7, 0x01, 0x31, 0x01, 0x00, 0x02, 0x32, 0xc8, 0x01};
- span<const std::byte> encoded;
+ std::span<const std::byte> encoded;
EXPECT_EQ(encoder.Encode(&encoded), Status::OK);
EXPECT_EQ(encoded.size(), sizeof(encoded_proto));
EXPECT_EQ(std::memcmp(encoded.data(), encoded_proto, encoded.size()), 0);
diff --git a/pw_protobuf/find.cc b/pw_protobuf/find.cc
index 70daabb..923097a 100644
--- a/pw_protobuf/find.cc
+++ b/pw_protobuf/find.cc
@@ -28,7 +28,7 @@
return Status::CANCELLED;
}
- span<const std::byte> submessage;
+ std::span<const std::byte> submessage;
if (Status status = decoder.ReadBytes(&submessage); !status.ok()) {
return status;
}
diff --git a/pw_protobuf/find_test.cc b/pw_protobuf/find_test.cc
index 2a7edd6..1dd4789 100644
--- a/pw_protobuf/find_test.cc
+++ b/pw_protobuf/find_test.cc
@@ -45,7 +45,7 @@
FindDecodeHandler finder(3);
decoder.set_handler(&finder);
- decoder.Decode(as_bytes(span(encoded_proto)));
+ decoder.Decode(std::as_bytes(std::span(encoded_proto)));
EXPECT_TRUE(finder.found());
EXPECT_TRUE(decoder.cancelled());
@@ -56,7 +56,7 @@
FindDecodeHandler finder(8);
decoder.set_handler(&finder);
- decoder.Decode(as_bytes(span(encoded_proto)));
+ decoder.Decode(std::as_bytes(std::span(encoded_proto)));
EXPECT_FALSE(finder.found());
EXPECT_FALSE(decoder.cancelled());
@@ -68,7 +68,7 @@
FindDecodeHandler finder(7, &nested_finder);
decoder.set_handler(&finder);
- decoder.Decode(as_bytes(span(encoded_proto)));
+ decoder.Decode(std::as_bytes(std::span(encoded_proto)));
EXPECT_TRUE(finder.found());
EXPECT_TRUE(nested_finder.found());
@@ -81,7 +81,7 @@
FindDecodeHandler finder(7, &nested_finder);
decoder.set_handler(&finder);
- decoder.Decode(as_bytes(span(encoded_proto)));
+ decoder.Decode(std::as_bytes(std::span(encoded_proto)));
EXPECT_TRUE(finder.found());
EXPECT_FALSE(nested_finder.found());
diff --git a/pw_protobuf/public/pw_protobuf/decoder.h b/pw_protobuf/public/pw_protobuf/decoder.h
index 184c38f..595bc9a 100644
--- a/pw_protobuf/public/pw_protobuf/decoder.h
+++ b/pw_protobuf/public/pw_protobuf/decoder.h
@@ -13,10 +13,10 @@
// the License.
#pragma once
+#include <span>
#include <string_view>
#include "pw_protobuf/wire_format.h"
-#include "pw_span/span.h"
#include "pw_status/status.h"
#include "pw_varint/varint.h"
@@ -44,7 +44,7 @@
class Decoder {
public:
- constexpr Decoder(span<const std::byte> proto)
+ constexpr Decoder(std::span<const std::byte> proto)
: proto_(proto), previous_field_consumed_(true) {}
Decoder(const Decoder& other) = delete;
@@ -127,12 +127,14 @@
Status ReadString(std::string_view* out);
// Reads a proto bytes value from the current cursor and returns a view of it
- // in `out`. The raw protobuf data must outlive the `out` span. If the bytes
- // field is invalid, `out` is not modified.
- Status ReadBytes(span<const std::byte>* out) { return ReadDelimited(out); }
+ // in `out`. The raw protobuf data must outlive the `out` std::span. If the
+ // bytes field is invalid, `out` is not modified.
+ Status ReadBytes(std::span<const std::byte>* out) {
+ return ReadDelimited(out);
+ }
// Resets the decoder to start reading a new proto message.
- void Reset(span<const std::byte> proto) {
+ void Reset(std::span<const std::byte> proto) {
proto_ = proto;
previous_field_consumed_ = true;
}
@@ -160,9 +162,9 @@
return ReadFixed(reinterpret_cast<std::byte*>(out), sizeof(T));
}
- Status ReadDelimited(span<const std::byte>* out);
+ Status ReadDelimited(std::span<const std::byte>* out);
- span<const std::byte> proto_;
+ std::span<const std::byte> proto_;
bool previous_field_consumed_;
};
@@ -197,7 +199,7 @@
// unsigned int baz;
// };
//
-// void DecodeFooProto(span<std::byte> raw_proto) {
+// void DecodeFooProto(std::span<std::byte> raw_proto) {
// Decoder decoder;
// FooProtoHandler handler;
//
@@ -222,7 +224,7 @@
// Decodes the specified protobuf data. The registered handler's ProcessField
// function is called on each field found in the data.
- Status Decode(span<const std::byte> proto);
+ Status Decode(std::span<const std::byte> proto);
// Reads a proto int32 value from the current cursor.
Status ReadInt32(int32_t* out) { return decoder_.ReadInt32(out); }
@@ -269,9 +271,9 @@
Status ReadString(std::string_view* out) { return decoder_.ReadString(out); }
// Reads a proto bytes value from the current cursor and returns a view of it
- // in `out`. The raw protobuf data must outlive the `out` span. If the bytes
- // field is invalid, `out` is not modified.
- Status ReadBytes(span<const std::byte>* out) {
+ // in `out`. The raw protobuf data must outlive the `out` std::span. If the
+ // bytes field is invalid, `out` is not modified.
+ Status ReadBytes(std::span<const std::byte>* out) {
return decoder_.ReadBytes(out);
}
diff --git a/pw_protobuf/public/pw_protobuf/encoder.h b/pw_protobuf/public/pw_protobuf/encoder.h
index 84e8ee1..3e86368 100644
--- a/pw_protobuf/public/pw_protobuf/encoder.h
+++ b/pw_protobuf/public/pw_protobuf/encoder.h
@@ -15,9 +15,9 @@
#include <cstddef>
#include <cstring>
+#include <span>
#include "pw_protobuf/wire_format.h"
-#include "pw_span/span.h"
#include "pw_status/status.h"
#include "pw_varint/varint.h"
@@ -31,9 +31,9 @@
// message. This can be templated to minimize the overhead.
using SizeType = size_t;
- constexpr Encoder(span<std::byte> buffer,
- span<SizeType*> locations,
- span<SizeType*> stack)
+ constexpr Encoder(std::span<std::byte> buffer,
+ std::span<SizeType*> locations,
+ std::span<SizeType*> stack)
: buffer_(buffer),
cursor_(buffer.data()),
blob_locations_(locations),
@@ -59,7 +59,8 @@
}
// Writes a repeated uint32 using packed encoding.
- Status WritePackedUint32(uint32_t field_number, span<const uint32_t> values) {
+ Status WritePackedUint32(uint32_t field_number,
+ std::span<const uint32_t> values) {
return WritePackedVarints(field_number, values, /*zigzag=*/false);
}
@@ -67,7 +68,8 @@
Status WriteUint64(uint32_t field_number, uint64_t value);
// Writes a repeated uint64 using packed encoding.
- Status WritePackedUint64(uint64_t field_number, span<const uint64_t> values) {
+ Status WritePackedUint64(uint64_t field_number,
+ std::span<const uint64_t> values) {
return WritePackedVarints(field_number, values, /*zigzag=*/false);
}
@@ -77,10 +79,12 @@
}
// Writes a repeated int32 using packed encoding.
- Status WritePackedInt32(uint32_t field_number, span<const int32_t> values) {
+ Status WritePackedInt32(uint32_t field_number,
+ std::span<const int32_t> values) {
return WritePackedVarints(
field_number,
- span(reinterpret_cast<const uint32_t*>(values.data()), values.size()),
+ std::span(reinterpret_cast<const uint32_t*>(values.data()),
+ values.size()),
/*zigzag=*/false);
}
@@ -90,10 +94,12 @@
}
// Writes a repeated int64 using packed encoding.
- Status WritePackedInt64(uint32_t field_number, span<const int64_t> values) {
+ Status WritePackedInt64(uint32_t field_number,
+ std::span<const int64_t> values) {
return WritePackedVarints(
field_number,
- span(reinterpret_cast<const uint64_t*>(values.data()), values.size()),
+ std::span(reinterpret_cast<const uint64_t*>(values.data()),
+ values.size()),
/*zigzag=*/false);
}
@@ -103,10 +109,12 @@
}
// Writes a repeated sint32 using packed encoding.
- Status WritePackedSint32(uint32_t field_number, span<const int32_t> values) {
+ Status WritePackedSint32(uint32_t field_number,
+ std::span<const int32_t> values) {
return WritePackedVarints(
field_number,
- span(reinterpret_cast<const uint32_t*>(values.data()), values.size()),
+ std::span(reinterpret_cast<const uint32_t*>(values.data()),
+ values.size()),
/*zigzag=*/true);
}
@@ -116,10 +124,12 @@
}
// Writes a repeated sint64 using packed encoding.
- Status WritePackedSint64(uint32_t field_number, span<const int64_t> values) {
+ Status WritePackedSint64(uint32_t field_number,
+ std::span<const int64_t> values) {
return WritePackedVarints(
field_number,
- span(reinterpret_cast<const uint64_t*>(values.data()), values.size()),
+ std::span(reinterpret_cast<const uint64_t*>(values.data()),
+ values.size()),
/*zigzag=*/true);
}
@@ -139,8 +149,8 @@
// Writes a repeated fixed32 field using packed encoding.
Status WritePackedFixed32(uint32_t field_number,
- span<const uint32_t> values) {
- return WriteBytes(field_number, as_bytes(values));
+ std::span<const uint32_t> values) {
+ return WriteBytes(field_number, std::as_bytes(values));
}
// Writes a proto fixed64 key-value pair.
@@ -154,8 +164,8 @@
// Writes a repeated fixed64 field using packed encoding.
Status WritePackedFixed64(uint32_t field_number,
- span<const uint64_t> values) {
- return WriteBytes(field_number, as_bytes(values));
+ std::span<const uint64_t> values) {
+ return WriteBytes(field_number, std::as_bytes(values));
}
// Writes a proto sfixed32 key-value pair.
@@ -165,8 +175,8 @@
// Writes a repeated sfixed32 field using packed encoding.
Status WritePackedSfixed32(uint32_t field_number,
- span<const int32_t> values) {
- return WriteBytes(field_number, as_bytes(values));
+ std::span<const int32_t> values) {
+ return WriteBytes(field_number, std::as_bytes(values));
}
// Writes a proto sfixed64 key-value pair.
@@ -176,8 +186,8 @@
// Writes a repeated sfixed64 field using packed encoding.
Status WritePackedSfixed64(uint32_t field_number,
- span<const int64_t> values) {
- return WriteBytes(field_number, as_bytes(values));
+ std::span<const int64_t> values) {
+ return WriteBytes(field_number, std::as_bytes(values));
}
// Writes a proto float key-value pair.
@@ -192,8 +202,9 @@
}
// Writes a repeated float field using packed encoding.
- Status WritePackedFloat(uint32_t field_number, span<const float> values) {
- return WriteBytes(field_number, as_bytes(values));
+ Status WritePackedFloat(uint32_t field_number,
+ std::span<const float> values) {
+ return WriteBytes(field_number, std::as_bytes(values));
}
// Writes a proto double key-value pair.
@@ -208,12 +219,13 @@
}
// Writes a repeated double field using packed encoding.
- Status WritePackedDouble(uint32_t field_number, span<const double> values) {
- return WriteBytes(field_number, as_bytes(values));
+ Status WritePackedDouble(uint32_t field_number,
+ std::span<const double> values) {
+ return WriteBytes(field_number, std::as_bytes(values));
}
// Writes a proto bytes key-value pair.
- Status WriteBytes(uint32_t field_number, span<const std::byte> value) {
+ Status WriteBytes(uint32_t field_number, std::span<const std::byte> value) {
std::byte* original_cursor = cursor_;
WriteFieldKey(field_number, WireType::kDelimited);
WriteVarint(value.size_bytes());
@@ -224,7 +236,7 @@
// Writes a proto string key-value pair.
Status WriteString(uint32_t field_number, const char* value, size_t size) {
- return WriteBytes(field_number, as_bytes(span(value, size)));
+ return WriteBytes(field_number, std::as_bytes(std::span(value, size)));
}
Status WriteString(uint32_t field_number, const char* value) {
@@ -254,7 +266,7 @@
// Runs a final encoding pass over the intermediary data and returns the
// encoded protobuf message.
- Status Encode(span<const std::byte>* out);
+ Status Encode(std::span<const std::byte>* out);
private:
constexpr bool ValidFieldNumber(uint32_t field_number) const {
@@ -291,7 +303,7 @@
// If zigzag is true, zig-zag encodes each of the varints.
template <typename T>
Status WritePackedVarints(uint32_t field_number,
- span<T> values,
+ std::span<T> values,
bool zigzag) {
if (Status status = Push(field_number); !status.ok()) {
return status;
@@ -328,16 +340,16 @@
}
// The buffer into which the proto is encoded.
- span<std::byte> buffer_;
+ std::span<std::byte> buffer_;
std::byte* cursor_;
// List of pointers to sub-messages' delimiting size fields.
- span<SizeType*> blob_locations_;
+ std::span<SizeType*> blob_locations_;
size_t blob_count_;
// Stack of current nested message size locations. Push() operations add a new
// entry to this stack and Pop() operations remove one.
- span<SizeType*> blob_stack_;
+ std::span<SizeType*> blob_stack_;
size_t depth_;
Status encode_status_;
@@ -347,7 +359,8 @@
template <size_t kMaxNestedDepth = 1, size_t kMaxBlobs = 1>
class NestedEncoder : public Encoder {
public:
- NestedEncoder(span<std::byte> buffer) : Encoder(buffer, blobs_, stack_) {}
+ NestedEncoder(std::span<std::byte> buffer)
+ : Encoder(buffer, blobs_, stack_) {}
// Disallow copy/assign to avoid confusion about who owns the buffer.
NestedEncoder(const NestedEncoder& other) = delete;
diff --git a/pw_protobuf/size_report/decoder_full.cc b/pw_protobuf/size_report/decoder_full.cc
index 561335e..075981e 100644
--- a/pw_protobuf/size_report/decoder_full.cc
+++ b/pw_protobuf/size_report/decoder_full.cc
@@ -38,7 +38,7 @@
float f;
double d;
- pw::protobuf::Decoder decoder(pw::as_bytes(pw::span(encoded_proto)));
+ pw::protobuf::Decoder decoder(std::as_bytes(std::span(encoded_proto)));
while (decoder.Next().ok()) {
switch (decoder.FieldNumber()) {
case 1:
diff --git a/pw_protobuf/size_report/decoder_incremental.cc b/pw_protobuf/size_report/decoder_incremental.cc
index 064f579..9f4029f 100644
--- a/pw_protobuf/size_report/decoder_incremental.cc
+++ b/pw_protobuf/size_report/decoder_incremental.cc
@@ -39,7 +39,7 @@
double d;
uint32_t uint;
- pw::protobuf::Decoder decoder(pw::as_bytes(pw::span(encoded_proto)));
+ pw::protobuf::Decoder decoder(std::as_bytes(std::span(encoded_proto)));
while (decoder.Next().ok()) {
switch (decoder.FieldNumber()) {
case 1:
diff --git a/pw_ring_buffer/prefixed_entry_ring_buffer.cc b/pw_ring_buffer/prefixed_entry_ring_buffer.cc
index fac8e6e..31eb222 100644
--- a/pw_ring_buffer/prefixed_entry_ring_buffer.cc
+++ b/pw_ring_buffer/prefixed_entry_ring_buffer.cc
@@ -29,7 +29,7 @@
entry_count_ = 0;
}
-Status PrefixedEntryRingBuffer::SetBuffer(span<byte> buffer) {
+Status PrefixedEntryRingBuffer::SetBuffer(std::span<byte> buffer) {
if ((buffer.data() == nullptr) || //
(buffer.size_bytes() == 0) || //
(buffer.size_bytes() > kMaxBufferBytes)) {
@@ -43,7 +43,7 @@
return Status::OK;
}
-Status PrefixedEntryRingBuffer::InternalPushBack(span<const byte> data,
+Status PrefixedEntryRingBuffer::InternalPushBack(std::span<const byte> data,
byte user_preamble_data,
bool drop_elements_if_needed) {
if (buffer_ == nullptr) {
@@ -75,16 +75,16 @@
// Write the new entry into the ring buffer.
if (user_preamble_) {
- RawWrite(span(&user_preamble_data, sizeof(user_preamble_data)));
+ RawWrite(std::span(&user_preamble_data, sizeof(user_preamble_data)));
}
- RawWrite(span(varint_buf, varint_bytes));
+ RawWrite(std::span(varint_buf, varint_bytes));
RawWrite(data);
entry_count_++;
return Status::OK;
}
-auto GetOutput(span<byte> data_out, size_t* write_index) {
- return [data_out, write_index](span<const byte> src) -> Status {
+auto GetOutput(std::span<byte> data_out, size_t* write_index) {
+ return [data_out, write_index](std::span<const byte> src) -> Status {
size_t copy_size = std::min(data_out.size_bytes(), src.size_bytes());
memcpy(data_out.data() + *write_index, src.data(), copy_size);
@@ -95,7 +95,8 @@
};
}
-Status PrefixedEntryRingBuffer::PeekFront(span<byte> data, size_t* bytes_read) {
+Status PrefixedEntryRingBuffer::PeekFront(std::span<byte> data,
+ size_t* bytes_read) {
*bytes_read = 0;
return InternalRead(GetOutput(data, bytes_read), false);
}
@@ -104,7 +105,7 @@
return InternalRead(output, false);
}
-Status PrefixedEntryRingBuffer::PeekFrontWithPreamble(span<byte> data,
+Status PrefixedEntryRingBuffer::PeekFrontWithPreamble(std::span<byte> data,
size_t* bytes_read) {
*bytes_read = 0;
return InternalRead(GetOutput(data, bytes_read), true);
@@ -114,7 +115,7 @@
return InternalRead(output, true);
}
-// T should be similar to Status (*read_output)(span<const byte>)
+// T should be similar to Status (*read_output)(std::span<const byte>)
template <typename T>
Status PrefixedEntryRingBuffer::InternalRead(T read_output, bool get_preamble) {
if (buffer_ == nullptr) {
@@ -137,11 +138,12 @@
// Read bytes, stopping at the end of the buffer if this entry wraps.
size_t bytes_until_wrap = buffer_bytes_ - data_read_idx;
size_t bytes_to_copy = std::min(read_bytes, bytes_until_wrap);
- Status status = read_output(span(buffer_ + data_read_idx, bytes_to_copy));
+ Status status =
+ read_output(std::span(buffer_ + data_read_idx, bytes_to_copy));
// If the entry wrapped, read the remaining bytes.
if (status.ok() && (bytes_to_copy < read_bytes)) {
- status = read_output(span(buffer_, read_bytes - bytes_to_copy));
+ status = read_output(std::span(buffer_, read_bytes - bytes_to_copy));
}
return status;
}
@@ -171,7 +173,7 @@
return Status::OK;
}
- auto buffer_span = span(buffer_, buffer_bytes_);
+ auto buffer_span = std::span(buffer_, buffer_bytes_);
std::rotate(
buffer_span.begin(), buffer_span.begin() + read_idx_, buffer_span.end());
@@ -232,7 +234,7 @@
return entry_count_ ? 0 : buffer_bytes_;
}
-void PrefixedEntryRingBuffer::RawWrite(span<const std::byte> source) {
+void PrefixedEntryRingBuffer::RawWrite(std::span<const std::byte> source) {
// Write until the end of the source or the backing buffer.
size_t bytes_until_wrap = buffer_bytes_ - write_idx_;
size_t bytes_to_copy = std::min(source.size(), bytes_until_wrap);
diff --git a/pw_ring_buffer/prefixed_entry_ring_buffer_test.cc b/pw_ring_buffer/prefixed_entry_ring_buffer_test.cc
index 225eb13..271ce74 100644
--- a/pw_ring_buffer/prefixed_entry_ring_buffer_test.cc
+++ b/pw_ring_buffer/prefixed_entry_ring_buffer_test.cc
@@ -34,8 +34,9 @@
size_t count;
EXPECT_EQ(ring.EntryCount(), 0u);
- EXPECT_EQ(ring.SetBuffer(span<byte>(nullptr, 10u)), Status::INVALID_ARGUMENT);
- EXPECT_EQ(ring.SetBuffer(span(buf, 0u)), Status::INVALID_ARGUMENT);
+ EXPECT_EQ(ring.SetBuffer(std::span<byte>(nullptr, 10u)),
+ Status::INVALID_ARGUMENT);
+ EXPECT_EQ(ring.SetBuffer(std::span(buf, 0u)), Status::INVALID_ARGUMENT);
EXPECT_EQ(ring.FrontEntryDataSizeBytes(), 0u);
EXPECT_EQ(ring.PushBack(buf), Status::FAILED_PRECONDITION);
@@ -87,11 +88,12 @@
EXPECT_EQ(ring.EntryCount(), 0u);
EXPECT_EQ(ring.PopFront(), Status::OUT_OF_RANGE);
EXPECT_EQ(ring.EntryCount(), 0u);
- EXPECT_EQ(ring.PushBack(span(single_entry_data, 0u)),
+ EXPECT_EQ(ring.PushBack(std::span(single_entry_data, 0u)),
Status::INVALID_ARGUMENT);
EXPECT_EQ(ring.EntryCount(), 0u);
- EXPECT_EQ(ring.PushBack(span(single_entry_data, sizeof(test_buffer) + 5)),
- Status::OUT_OF_RANGE);
+ EXPECT_EQ(
+ ring.PushBack(std::span(single_entry_data, sizeof(test_buffer) + 5)),
+ Status::OUT_OF_RANGE);
EXPECT_EQ(ring.EntryCount(), 0u);
EXPECT_EQ(ring.PeekFront(read_buffer, &read_size), Status::OUT_OF_RANGE);
EXPECT_EQ(read_size, 0u);
@@ -112,7 +114,7 @@
ASSERT_EQ(ring.FrontEntryDataSizeBytes(), 0u);
ASSERT_EQ(ring.FrontEntryTotalSizeBytes(), 0u);
- ASSERT_EQ(ring.PushBack(span(single_entry_data, data_size), byte(i)),
+ ASSERT_EQ(ring.PushBack(std::span(single_entry_data, data_size), byte(i)),
Status::OK);
ASSERT_EQ(ring.FrontEntryDataSizeBytes(), data_size);
ASSERT_EQ(ring.FrontEntryTotalSizeBytes(), single_entry_total_size);
@@ -121,12 +123,12 @@
ASSERT_EQ(ring.PeekFront(read_buffer, &read_size), Status::OK);
ASSERT_EQ(read_size, data_size);
- // ASSERT_THAT(span(expect_buffer).last(data_size),
- // testing::ElementsAreArray(span(read_buffer, data_size)));
- ASSERT_EQ(
- memcmp(
- span(expect_buffer).last(data_size).data(), read_buffer, data_size),
- 0);
+ // ASSERT_THAT(std::span(expect_buffer).last(data_size),
+ // testing::ElementsAreArray(std::span(read_buffer, data_size)));
+ ASSERT_EQ(memcmp(std::span(expect_buffer).last(data_size).data(),
+ read_buffer,
+ data_size),
+ 0);
read_size = 500U;
ASSERT_EQ(ring.PeekFrontWithPreamble(read_buffer, &read_size), Status::OK);
@@ -137,8 +139,8 @@
expect_buffer[0] = byte(i);
}
- // ASSERT_THAT(span(expect_buffer),
- // testing::ElementsAreArray(span(read_buffer)));
+ // ASSERT_THAT(std::span(expect_buffer),
+ // testing::ElementsAreArray(std::span(read_buffer)));
ASSERT_EQ(memcmp(expect_buffer, read_buffer, single_entry_total_size), 0);
}
}
@@ -221,7 +223,7 @@
EXPECT_EQ(ring.SetBuffer(test_buffer), Status::OK);
- auto output = [](span<const byte> src) -> Status {
+ auto output = [](std::span<const byte> src) -> Status {
for (byte b : src) {
read_buffer.push_back(b);
}
@@ -240,7 +242,7 @@
ASSERT_EQ(ring.FrontEntryDataSizeBytes(), 0u);
ASSERT_EQ(ring.FrontEntryTotalSizeBytes(), 0u);
- ASSERT_EQ(ring.PushBack(span(single_entry_data, data_size), byte(i)),
+ ASSERT_EQ(ring.PushBack(std::span(single_entry_data, data_size), byte(i)),
Status::OK);
ASSERT_EQ(ring.FrontEntryDataSizeBytes(), data_size);
ASSERT_EQ(ring.FrontEntryTotalSizeBytes(), single_entry_total_size);
@@ -249,7 +251,7 @@
ASSERT_EQ(ring.PeekFront(output), Status::OK);
ASSERT_EQ(read_buffer.size(), data_size);
- ASSERT_EQ(memcmp(span(expect_buffer).last(data_size).data(),
+ ASSERT_EQ(memcmp(std::span(expect_buffer).last(data_size).data(),
read_buffer.data(),
data_size),
0);
@@ -294,7 +296,7 @@
// Entry data is entry size - preamble (single byte in this case).
byte single_entry_buffer[kEntrySizeBytes - 1u];
- auto entry_data = span(single_entry_buffer);
+ auto entry_data = std::span(single_entry_buffer);
size_t i;
// TODO(pwbug/196): Increase this to 500 once we have a way to detect targets
@@ -341,7 +343,7 @@
// Read out the entries of the ring buffer.
actual_result.clear();
- auto output = [](span<const byte> src) -> Status {
+ auto output = [](std::span<const byte> src) -> Status {
for (byte b : src) {
actual_result.push_back(b);
}
@@ -374,7 +376,7 @@
T item;
} aliased;
aliased.item = element;
- return ring.PushBack(span(aliased.buffer));
+ return ring.PushBack(aliased.buffer);
}
template <typename T>
@@ -384,7 +386,7 @@
T item;
} aliased;
aliased.item = element;
- return ring.TryPushBack(span(aliased.buffer));
+ return ring.TryPushBack(aliased.buffer);
}
template <typename T>
@@ -394,8 +396,7 @@
T item;
} aliased;
size_t bytes_read = 0;
- PW_CHECK_INT_EQ(ring.PeekFront(span(aliased.buffer), &bytes_read),
- Status::OK);
+ PW_CHECK_INT_EQ(ring.PeekFront(aliased.buffer, &bytes_read), Status::OK);
PW_CHECK_INT_EQ(bytes_read, sizeof(T));
return aliased.item;
}
diff --git a/pw_ring_buffer/public/pw_ring_buffer/prefixed_entry_ring_buffer.h b/pw_ring_buffer/public/pw_ring_buffer/prefixed_entry_ring_buffer.h
index f87c44f..e164834 100644
--- a/pw_ring_buffer/public/pw_ring_buffer/prefixed_entry_ring_buffer.h
+++ b/pw_ring_buffer/public/pw_ring_buffer/prefixed_entry_ring_buffer.h
@@ -14,8 +14,8 @@
#pragma once
#include <cstddef>
+#include <span>
-#include "pw_span/span.h"
#include "pw_status/status.h"
namespace pw {
@@ -32,7 +32,7 @@
// room. Entries are internally wrapped around as needed.
class PrefixedEntryRingBuffer {
public:
- typedef Status (*ReadOutput)(span<const std::byte>);
+ typedef Status (*ReadOutput)(std::span<const std::byte>);
PrefixedEntryRingBuffer(bool user_preamble = false)
: buffer_(nullptr),
@@ -47,7 +47,7 @@
// Return values:
// OK - successfully set the raw buffer.
// INVALID_ARGUMENT - Argument was nullptr, size zero, or too large.
- Status SetBuffer(span<std::byte> buffer);
+ Status SetBuffer(std::span<std::byte> buffer);
// Removes all data from the ring buffer.
void Clear();
@@ -65,7 +65,7 @@
// INVALID_ARGUMENT - Size of data to write is zero bytes
// FAILED_PRECONDITION - Buffer not initialized.
// OUT_OF_RANGE - Size of data is greater than buffer size.
- Status PushBack(span<const std::byte> data,
+ Status PushBack(std::span<const std::byte> data,
std::byte user_preamble_data = std::byte(0)) {
return InternalPushBack(data, user_preamble_data, true);
}
@@ -83,29 +83,29 @@
// OUT_OF_RANGE - Size of data is greater than buffer size.
// RESOURCE_EXHAUSTED - The ring buffer doesn't have space for the data
// without popping off existing elements.
- Status TryPushBack(span<const std::byte> data,
+ Status TryPushBack(std::span<const std::byte> data,
std::byte user_preamble_data = std::byte(0)) {
return InternalPushBack(data, user_preamble_data, false);
}
// Read the oldest stored data chunk of data from the ring buffer to
- // the provided destination span. The number of bytes read is written to
+ // the provided destination std::span. The number of bytes read is written to
// bytes_read
//
// Return values:
// OK - Data successfully read from the ring buffer.
// FAILED_PRECONDITION - Buffer not initialized.
// OUT_OF_RANGE - No entries in ring buffer to read.
- // RESOURCE_EXHAUSTED - Destination data span was smaller number of bytes than
- // the data size of the data chunk being read. Available destination bytes
- // were filled, remaining bytes of the data chunk were ignored.
- Status PeekFront(span<std::byte> data, size_t* bytes_read);
+ // RESOURCE_EXHAUSTED - Destination data std::span was smaller number of bytes
+ // than the data size of the data chunk being read. Available destination
+ // bytes were filled, remaining bytes of the data chunk were ignored.
+ Status PeekFront(std::span<std::byte> data, size_t* bytes_read);
Status PeekFront(ReadOutput output);
// Same as Read but includes the entry's preamble of optional user value and
// the varint of the data size
- Status PeekFrontWithPreamble(span<std::byte> data, size_t* bytes_read);
+ Status PeekFrontWithPreamble(std::span<std::byte> data, size_t* bytes_read);
Status PeekFrontWithPreamble(ReadOutput output);
@@ -157,7 +157,7 @@
// Push back implementation, which optionally discards front elements to fit
// the incoming element.
- Status InternalPushBack(span<const std::byte> data,
+ Status InternalPushBack(std::span<const std::byte> data,
std::byte user_preamble_data,
bool pop_front_if_needed);
@@ -173,7 +173,7 @@
// Do the basic write of the specified number of bytes starting at the last
// write index of the ring buffer to the destination, handing any wrap-around
// of the ring buffer. This is basic, raw operation with no safety checks.
- void RawWrite(span<const std::byte> source);
+ void RawWrite(std::span<const std::byte> source);
// Do the basic read of the specified number of bytes starting at the given
// index of the ring buffer to the destination, handing any wrap-around of
diff --git a/pw_rpc/base_server_writer.cc b/pw_rpc/base_server_writer.cc
index 4fa1f1f..1e23fc8 100644
--- a/pw_rpc/base_server_writer.cc
+++ b/pw_rpc/base_server_writer.cc
@@ -47,7 +47,7 @@
state_ = kClosed;
}
-span<std::byte> BaseServerWriter::AcquirePayloadBuffer() {
+std::span<std::byte> BaseServerWriter::AcquirePayloadBuffer() {
if (!open()) {
return {};
}
@@ -56,14 +56,15 @@
return response_.payload(packet());
}
-Status BaseServerWriter::ReleasePayloadBuffer(span<const std::byte> payload) {
+Status BaseServerWriter::ReleasePayloadBuffer(
+ std::span<const std::byte> payload) {
if (!open()) {
return Status::FAILED_PRECONDITION;
}
return call_.channel().Send(response_, packet(payload));
}
-Packet BaseServerWriter::packet(span<const std::byte> payload) const {
+Packet BaseServerWriter::packet(std::span<const std::byte> payload) const {
return Packet(PacketType::RPC,
call_.channel().id(),
call_.service().id(),
diff --git a/pw_rpc/base_server_writer_test.cc b/pw_rpc/base_server_writer_test.cc
index 8c1b914..b10620e 100644
--- a/pw_rpc/base_server_writer_test.cc
+++ b/pw_rpc/base_server_writer_test.cc
@@ -28,7 +28,7 @@
class TestService : public internal::Service {
public:
constexpr TestService(uint32_t id)
- : Service(id, span(&method, 1)), method(8) {}
+ : Service(id, std::span(&method, 1)), method(8) {}
internal::Method method;
};
@@ -62,8 +62,8 @@
constexpr FakeServerWriter() = default;
- Status Write(span<const byte> response) {
- span buffer = AcquirePayloadBuffer();
+ Status Write(std::span<const byte> response) {
+ std::span buffer = AcquirePayloadBuffer();
std::memcpy(buffer.data(),
response.data(),
std::min(buffer.size(), response.size()));
diff --git a/pw_rpc/channel.cc b/pw_rpc/channel.cc
index 5747577..b34ebf2 100644
--- a/pw_rpc/channel.cc
+++ b/pw_rpc/channel.cc
@@ -21,10 +21,10 @@
using std::byte;
-span<byte> Channel::OutputBuffer::payload(const Packet& packet) const {
+std::span<byte> Channel::OutputBuffer::payload(const Packet& packet) const {
const size_t reserved_size = packet.MinEncodedSizeBytes();
return reserved_size <= buffer_.size() ? buffer_.subspan(reserved_size)
- : span<byte>();
+ : std::span<byte>();
}
Status Channel::Send(OutputBuffer& buffer, const internal::Packet& packet) {
diff --git a/pw_rpc/channel_test.cc b/pw_rpc/channel_test.cc
index 5f195af..b63535b 100644
--- a/pw_rpc/channel_test.cc
+++ b/pw_rpc/channel_test.cc
@@ -27,7 +27,7 @@
class NameTester : public ChannelOutput {
public:
NameTester(const char* name) : ChannelOutput(name) {}
- span<std::byte> AcquireBuffer() override { return {}; }
+ std::span<std::byte> AcquireBuffer() override { return {}; }
void SendAndReleaseBuffer(size_t) override {}
};
@@ -67,7 +67,7 @@
internal::Channel channel(100, &output);
Channel::OutputBuffer output_buffer(channel.AcquireBuffer());
- const span payload = output_buffer.payload(kTestPacket);
+ const std::span payload = output_buffer.payload(kTestPacket);
EXPECT_EQ(payload.size(), output.buffer().size() - kReservedSize);
EXPECT_EQ(output.buffer().data() + kReservedSize, payload.data());
@@ -93,7 +93,7 @@
internal::Channel channel(100, &output);
Channel::OutputBuffer output_buffer = channel.AcquireBuffer();
- const span payload = output_buffer.payload(kTestPacket);
+ const std::span payload = output_buffer.payload(kTestPacket);
EXPECT_EQ(payload.size(), output.buffer().size() - kReservedSize);
EXPECT_EQ(output.buffer().data() + kReservedSize, payload.data());
diff --git a/pw_rpc/nanopb/method.cc b/pw_rpc/nanopb/method.cc
index 7ed0522..3d91070 100644
--- a/pw_rpc/nanopb/method.cc
+++ b/pw_rpc/nanopb/method.cc
@@ -37,7 +37,7 @@
using std::byte;
-Status Method::DecodeRequest(span<const byte> buffer,
+Status Method::DecodeRequest(std::span<const byte> buffer,
void* proto_struct) const {
auto input = pb_istream_from_buffer(
reinterpret_cast<const pb_byte_t*>(buffer.data()), buffer.size());
@@ -47,7 +47,7 @@
}
StatusWithSize Method::EncodeResponse(const void* proto_struct,
- span<byte> buffer) const {
+ std::span<byte> buffer) const {
auto output = pb_ostream_from_buffer(
reinterpret_cast<pb_byte_t*>(buffer.data()), buffer.size());
if (pb_encode(&output, static_cast<Fields>(response_fields_), proto_struct)) {
@@ -57,8 +57,8 @@
}
StatusWithSize Method::CallUnary(ServerCall& call,
- span<const byte> request_buffer,
- span<byte> response_buffer,
+ std::span<const byte> request_buffer,
+ std::span<byte> response_buffer,
void* request_struct,
void* response_struct) const {
Status status = DecodeRequest(request_buffer, request_struct);
@@ -76,7 +76,7 @@
}
StatusWithSize Method::CallServerStreaming(ServerCall& call,
- span<const byte> request_buffer,
+ std::span<const byte> request_buffer,
void* request_struct) const {
Status status = DecodeRequest(request_buffer, request_struct);
if (!status.ok()) {
diff --git a/pw_rpc/nanopb/method_test.cc b/pw_rpc/nanopb/method_test.cc
index 6d82f2a..80fd216 100644
--- a/pw_rpc/nanopb/method_test.cc
+++ b/pw_rpc/nanopb/method_test.cc
@@ -36,14 +36,15 @@
#define _ENCODE_PB_IMPL(proto, init, result, unique) \
std::array<pb_byte_t, 2 * sizeof(proto)> _pb_buffer_##unique{}; \
- const span result = \
+ const std::span result = \
EncodeProtobuf<proto, proto##_fields>(proto init, _pb_buffer_##unique)
template <typename T, auto fields>
-span<const byte> EncodeProtobuf(const T& protobuf, span<pb_byte_t> buffer) {
+std::span<const byte> EncodeProtobuf(const T& protobuf,
+ std::span<pb_byte_t> buffer) {
auto output = pb_ostream_from_buffer(buffer.data(), buffer.size());
EXPECT_TRUE(pb_encode(&output, fields, &protobuf));
- return as_bytes(buffer.first(output.bytes_written));
+ return std::as_bytes(buffer.first(output.bytes_written));
}
class FakeGeneratedService : public Service {
diff --git a/pw_rpc/nanopb/public_overrides/pw_rpc/internal/method.h b/pw_rpc/nanopb/public_overrides/pw_rpc/internal/method.h
index f50a997..19f1497 100644
--- a/pw_rpc/nanopb/public_overrides/pw_rpc/internal/method.h
+++ b/pw_rpc/nanopb/public_overrides/pw_rpc/internal/method.h
@@ -16,11 +16,11 @@
#include <algorithm>
#include <cstddef>
#include <cstdint>
+#include <span>
#include "pw_rpc/internal/base_method.h"
#include "pw_rpc/internal/base_server_writer.h"
#include "pw_rpc/server_context.h"
-#include "pw_span/span.h"
#include "pw_status/status.h"
#include "pw_status/status_with_size.h"
@@ -137,17 +137,18 @@
// calls the invoker function, which encodes and decodes the request and
// response (if any) and calls the user-defined RPC function.
StatusWithSize Invoke(ServerCall& call,
- span<const std::byte> request,
- span<std::byte> payload_buffer) const {
+ std::span<const std::byte> request,
+ std::span<std::byte> payload_buffer) const {
return invoker_(*this, call, request, payload_buffer);
}
// Decodes a request protobuf with Nanopb to the provided buffer.
- Status DecodeRequest(span<const std::byte> buffer, void* proto_struct) const;
+ Status DecodeRequest(std::span<const std::byte> buffer,
+ void* proto_struct) const;
// Encodes a response protobuf with Nanopb to the provided buffer.
StatusWithSize EncodeResponse(const void* proto_struct,
- span<std::byte> buffer) const;
+ std::span<std::byte> buffer) const;
private:
// Generic version of the unary RPC function signature:
@@ -187,8 +188,8 @@
// returns the number of bytes written to the response buffer, if any.
using Invoker = StatusWithSize (&)(const Method&,
ServerCall&,
- span<const std::byte>,
- span<std::byte>);
+ std::span<const std::byte>,
+ std::span<std::byte>);
constexpr Method(Function function,
Invoker invoker,
@@ -202,13 +203,13 @@
response_fields_(response) {}
StatusWithSize CallUnary(ServerCall& call,
- span<const std::byte> request_buffer,
- span<std::byte> response_buffer,
+ std::span<const std::byte> request_buffer,
+ std::span<std::byte> response_buffer,
void* request_struct,
void* response_struct) const;
StatusWithSize CallServerStreaming(ServerCall& call,
- span<const std::byte> request_buffer,
+ std::span<const std::byte> request_buffer,
void* request_struct) const;
// TODO(hepler): Add CallClientStreaming and CallBidiStreaming
@@ -219,8 +220,8 @@
template <size_t request_size, size_t response_size>
static StatusWithSize UnaryInvoker(const Method& method,
ServerCall& call,
- span<const std::byte> request_buffer,
- span<std::byte> response_buffer) {
+ std::span<const std::byte> request_buffer,
+ std::span<std::byte> response_buffer) {
std::aligned_storage_t<request_size, alignof(std::max_align_t)>
request_struct{};
std::aligned_storage_t<response_size, alignof(std::max_align_t)>
@@ -240,8 +241,8 @@
static StatusWithSize ServerStreamingInvoker(
const Method& method,
ServerCall& call,
- span<const std::byte> request_buffer,
- span<std::byte> /* payload not used */) {
+ std::span<const std::byte> request_buffer,
+ std::span<std::byte> /* payload not used */) {
std::aligned_storage_t<request_size, alignof(std::max_align_t)>
request_struct{};
@@ -264,7 +265,7 @@
template <typename T>
Status ServerWriter<T>::Write(const T& response) {
- span<std::byte> buffer = AcquirePayloadBuffer();
+ std::span<std::byte> buffer = AcquirePayloadBuffer();
if (auto result = method().EncodeResponse(&response, buffer); result.ok()) {
return ReleasePayloadBuffer(buffer.first(result.size()));
diff --git a/pw_rpc/packet.cc b/pw_rpc/packet.cc
index b6e6701..9a7e34f 100644
--- a/pw_rpc/packet.cc
+++ b/pw_rpc/packet.cc
@@ -20,12 +20,12 @@
using std::byte;
-Packet Packet::FromBuffer(span<const byte> data) {
+Packet Packet::FromBuffer(std::span<const byte> data) {
PacketType type = PacketType::RPC;
uint32_t channel_id = 0;
uint32_t service_id = 0;
uint32_t method_id = 0;
- span<const byte> payload;
+ std::span<const byte> payload;
Status status;
uint32_t value;
@@ -68,7 +68,7 @@
return Packet(type, channel_id, service_id, method_id, payload, status);
}
-StatusWithSize Packet::Encode(span<byte> buffer) const {
+StatusWithSize Packet::Encode(std::span<byte> buffer) const {
pw::protobuf::NestedEncoder encoder(buffer);
RpcPacket::Encoder rpc_packet(&encoder);
@@ -81,7 +81,7 @@
rpc_packet.WriteMethodId(method_id_);
rpc_packet.WriteStatus(status_);
- span<const byte> proto;
+ std::span<const byte> proto;
if (Status status = encoder.Encode(&proto); !status.ok()) {
return StatusWithSize(status, 0);
}
diff --git a/pw_rpc/packet_test.cc b/pw_rpc/packet_test.cc
index a8d96a7..87d5c83 100644
--- a/pw_rpc/packet_test.cc
+++ b/pw_rpc/packet_test.cc
@@ -91,7 +91,7 @@
StatusWithSize sws = packet.Encode(buffer);
ASSERT_EQ(sws.status(), Status::OK);
- span<byte> packet_data(buffer, sws.size());
+ std::span<byte> packet_data(buffer, sws.size());
Packet decoded = Packet::FromBuffer(packet_data);
EXPECT_EQ(decoded.type(), packet.type());
diff --git a/pw_rpc/public/pw_rpc/channel.h b/pw_rpc/public/pw_rpc/channel.h
index 2602bbe..ecae939 100644
--- a/pw_rpc/public/pw_rpc/channel.h
+++ b/pw_rpc/public/pw_rpc/channel.h
@@ -14,9 +14,9 @@
#pragma once
#include <cstdint>
+#include <span>
#include "pw_assert/assert.h"
-#include "pw_span/span.h"
#include "pw_status/status.h"
namespace pw::rpc {
@@ -37,7 +37,7 @@
constexpr const char* name() const { return name_; }
// Acquire a buffer into which to write an outgoing RPC packet.
- virtual span<std::byte> AcquireBuffer() = 0;
+ virtual std::span<std::byte> AcquireBuffer() = 0;
// Sends the contents of the buffer from AcquireBuffer().
virtual void SendAndReleaseBuffer(size_t size) = 0;
diff --git a/pw_rpc/public/pw_rpc/internal/base_method.h b/pw_rpc/public/pw_rpc/internal/base_method.h
index 07db616..4b3fdae 100644
--- a/pw_rpc/public/pw_rpc/internal/base_method.h
+++ b/pw_rpc/public/pw_rpc/internal/base_method.h
@@ -27,8 +27,8 @@
// Implementations must provide the Invoke method, which the Server calls:
//
// StatusWithSize Invoke(ServerCall& call,
- // span<const std::byte> request,
- // span<std::byte> payload_buffer) const;
+ // std::span<const std::byte> request,
+ // std::span<std::byte> payload_buffer) const;
protected:
constexpr BaseMethod(uint32_t id) : id_(id) {}
diff --git a/pw_rpc/public/pw_rpc/internal/base_server_writer.h b/pw_rpc/public/pw_rpc/internal/base_server_writer.h
index 413293c..47c6858 100644
--- a/pw_rpc/public/pw_rpc/internal/base_server_writer.h
+++ b/pw_rpc/public/pw_rpc/internal/base_server_writer.h
@@ -14,12 +14,12 @@
#pragma once
#include <cstddef>
+#include <span>
#include <utility>
#include "pw_containers/intrusive_list.h"
#include "pw_rpc/internal/call.h"
#include "pw_rpc/internal/channel.h"
-#include "pw_span/span.h"
namespace pw::rpc::internal {
@@ -54,12 +54,12 @@
const Method& method() const { return call_.method(); }
- span<std::byte> AcquirePayloadBuffer();
+ std::span<std::byte> AcquirePayloadBuffer();
- Status ReleasePayloadBuffer(span<const std::byte> payload);
+ Status ReleasePayloadBuffer(std::span<const std::byte> payload);
private:
- Packet packet(span<const std::byte> payload = {}) const;
+ Packet packet(std::span<const std::byte> payload = {}) const;
ServerCall call_;
Channel::OutputBuffer response_;
diff --git a/pw_rpc/public/pw_rpc/internal/channel.h b/pw_rpc/public/pw_rpc/internal/channel.h
index b3f01f7..b42c8a0 100644
--- a/pw_rpc/public/pw_rpc/internal/channel.h
+++ b/pw_rpc/public/pw_rpc/internal/channel.h
@@ -13,8 +13,9 @@
// the License.
#pragma once
+#include <span>
+
#include "pw_rpc/channel.h"
-#include "pw_span/span.h"
#include "pw_status/status.h"
namespace pw::rpc::internal {
@@ -48,14 +49,15 @@
}
// Returns a portion of this OutputBuffer to use as the packet payload.
- span<std::byte> payload(const Packet& packet) const;
+ std::span<std::byte> payload(const Packet& packet) const;
private:
friend class Channel;
- explicit constexpr OutputBuffer(span<std::byte> buffer) : buffer_(buffer) {}
+ explicit constexpr OutputBuffer(std::span<std::byte> buffer)
+ : buffer_(buffer) {}
- span<std::byte> buffer_;
+ std::span<std::byte> buffer_;
};
// Acquires a buffer for the packet.
diff --git a/pw_rpc/public/pw_rpc/internal/packet.h b/pw_rpc/public/pw_rpc/internal/packet.h
index 3f5e87d..79b18f6 100644
--- a/pw_rpc/public/pw_rpc/internal/packet.h
+++ b/pw_rpc/public/pw_rpc/internal/packet.h
@@ -15,9 +15,9 @@
#include <cstddef>
#include <cstdint>
+#include <span>
#include "pw_rpc_protos/packet.pwpb.h"
-#include "pw_span/span.h"
#include "pw_status/status_with_size.h"
namespace pw::rpc::internal {
@@ -28,13 +28,13 @@
// Parses a packet from a protobuf message. Missing or malformed fields take
// their default values.
- static Packet FromBuffer(span<const std::byte> data);
+ static Packet FromBuffer(std::span<const std::byte> data);
constexpr Packet(PacketType type,
uint32_t channel_id = kUnassignedId,
uint32_t service_id = kUnassignedId,
uint32_t method_id = kUnassignedId,
- span<const std::byte> payload = {},
+ std::span<const std::byte> payload = {},
Status status = Status::OK)
: type_(type),
channel_id_(channel_id),
@@ -44,7 +44,7 @@
status_(status) {}
// Encodes the packet into its wire format. Returns the encoded size.
- StatusWithSize Encode(span<std::byte> buffer) const;
+ StatusWithSize Encode(std::span<std::byte> buffer) const;
// Determines the space required to encode the packet proto fields for a
// response. This may be used to split the buffer into reserved space and
@@ -58,14 +58,14 @@
uint32_t channel_id() const { return channel_id_; }
uint32_t service_id() const { return service_id_; }
uint32_t method_id() const { return method_id_; }
- const span<const std::byte>& payload() const { return payload_; }
+ const std::span<const std::byte>& payload() const { return payload_; }
Status status() const { return status_; }
void set_type(PacketType type) { type_ = type; }
void set_channel_id(uint32_t channel_id) { channel_id_ = channel_id; }
void set_service_id(uint32_t service_id) { service_id_ = service_id; }
void set_method_id(uint32_t method_id) { method_id_ = method_id; }
- void set_payload(span<const std::byte> payload) { payload_ = payload; }
+ void set_payload(std::span<const std::byte> payload) { payload_ = payload; }
void set_status(Status status) { status_ = status; }
private:
@@ -73,7 +73,7 @@
uint32_t channel_id_;
uint32_t service_id_;
uint32_t method_id_;
- span<const std::byte> payload_;
+ std::span<const std::byte> payload_;
Status status_;
};
diff --git a/pw_rpc/public/pw_rpc/internal/service.h b/pw_rpc/public/pw_rpc/internal/service.h
index 7e5a96f..9a82b57 100644
--- a/pw_rpc/public/pw_rpc/internal/service.h
+++ b/pw_rpc/public/pw_rpc/internal/service.h
@@ -14,11 +14,11 @@
#pragma once
#include <cstdint>
+#include <span>
#include <utility>
#include "pw_containers/intrusive_list.h"
#include "pw_rpc/internal/method.h"
-#include "pw_span/span.h"
namespace pw::rpc::internal {
@@ -40,7 +40,7 @@
friend class ServiceRegistry;
uint32_t id_;
- span<const Method> methods_;
+ std::span<const Method> methods_;
};
} // namespace pw::rpc::internal
diff --git a/pw_rpc/public/pw_rpc/server.h b/pw_rpc/public/pw_rpc/server.h
index 1232a75..c8b0476 100644
--- a/pw_rpc/public/pw_rpc/server.h
+++ b/pw_rpc/public/pw_rpc/server.h
@@ -14,6 +14,7 @@
#pragma once
#include <cstddef>
+#include <span>
#include "pw_containers/intrusive_list.h"
#include "pw_rpc/channel.h"
@@ -25,7 +26,7 @@
class Server {
public:
- constexpr Server(span<Channel> channels)
+ constexpr Server(std::span<Channel> channels)
: channels_(static_cast<internal::Channel*>(channels.data()),
channels.size()) {}
@@ -36,7 +37,8 @@
services_.push_front(service);
}
- void ProcessPacket(span<const std::byte> packet, ChannelOutput& interface);
+ void ProcessPacket(std::span<const std::byte> packet,
+ ChannelOutput& interface);
constexpr size_t channel_count() const { return channels_.size(); }
@@ -47,12 +49,12 @@
void InvokeMethod(const internal::Packet& request,
Channel& channel,
internal::Packet& response,
- span<std::byte> buffer);
+ std::span<std::byte> buffer);
internal::Channel* FindChannel(uint32_t id) const;
internal::Channel* AssignChannel(uint32_t id, ChannelOutput& interface);
- span<internal::Channel> channels_;
+ std::span<internal::Channel> channels_;
IntrusiveList<internal::Service> services_;
IntrusiveList<internal::BaseServerWriter> writers_;
};
diff --git a/pw_rpc/pw_rpc_private/test_utils.h b/pw_rpc/pw_rpc_private/test_utils.h
index 6dcd8a6..8ad045b 100644
--- a/pw_rpc/pw_rpc_private/test_utils.h
+++ b/pw_rpc/pw_rpc_private/test_utils.h
@@ -16,12 +16,12 @@
#include <array>
#include <cstddef>
#include <cstdint>
+#include <span>
#include "pw_rpc/internal/channel.h"
#include "pw_rpc/internal/method.h"
#include "pw_rpc/internal/packet.h"
#include "pw_rpc/internal/server.h"
-#include "pw_span/span.h"
namespace pw::rpc {
@@ -31,19 +31,19 @@
constexpr TestOutput(const char* name = "TestOutput")
: ChannelOutput(name), sent_packet_{} {}
- span<std::byte> AcquireBuffer() override { return buffer_; }
+ std::span<std::byte> AcquireBuffer() override { return buffer_; }
void SendAndReleaseBuffer(size_t size) override {
- sent_packet_ = span(buffer_.data(), size);
+ sent_packet_ = std::span(buffer_.data(), size);
}
- span<const std::byte> buffer() const { return buffer_; }
+ std::span<const std::byte> buffer() const { return buffer_; }
- const span<const std::byte>& sent_packet() const { return sent_packet_; }
+ const std::span<const std::byte>& sent_packet() const { return sent_packet_; }
private:
std::array<std::byte, buffer_size> buffer_;
- span<const std::byte> sent_packet_;
+ std::span<const std::byte> sent_packet_;
};
// Version of the internal::Server with extra methods exposed for testing.
@@ -63,7 +63,7 @@
ServerContextForTest(const internal::Method& method)
: channel_(Channel::Create<kChannelId>(&output_)),
- server_(span(&channel_, 1)),
+ server_(std::span(&channel_, 1)),
service_(kServiceId),
context_(static_cast<internal::Server&>(server_),
static_cast<internal::Channel&>(channel_),
@@ -75,7 +75,7 @@
ServerContextForTest() : ServerContextForTest(service_.method) {}
// Creates a packet for this context's channel, service, and method.
- internal::Packet packet(span<const std::byte> payload) const {
+ internal::Packet packet(std::span<const std::byte> payload) const {
return internal::Packet(internal::PacketType::RPC,
kChannelId,
kServiceId,
diff --git a/pw_rpc/server.cc b/pw_rpc/server.cc
index 11857c1..7f20a36 100644
--- a/pw_rpc/server.cc
+++ b/pw_rpc/server.cc
@@ -29,7 +29,8 @@
using internal::Packet;
using internal::PacketType;
-void Server::ProcessPacket(span<const byte> data, ChannelOutput& interface) {
+void Server::ProcessPacket(std::span<const byte> data,
+ ChannelOutput& interface) {
Packet packet = Packet::FromBuffer(data);
if (packet.is_control()) {
// TODO(frolv): Handle control packets.
@@ -73,7 +74,7 @@
void Server::InvokeMethod(const Packet& request,
Channel& channel,
internal::Packet& response,
- span<std::byte> payload_buffer) {
+ std::span<std::byte> payload_buffer) {
auto service = std::find_if(services_.begin(), services_.end(), [&](auto& s) {
return s.id() == request.service_id();
});
diff --git a/pw_rpc/server_test.cc b/pw_rpc/server_test.cc
index 6b5905d1..7082772 100644
--- a/pw_rpc/server_test.cc
+++ b/pw_rpc/server_test.cc
@@ -76,15 +76,16 @@
Server server_;
TestService service_;
- span<const byte> EncodeRequest(PacketType type,
- uint32_t channel_id,
- uint32_t service_id,
- uint32_t method_id,
- span<const byte> payload = kDefaultPayload) {
+ std::span<const byte> EncodeRequest(
+ PacketType type,
+ uint32_t channel_id,
+ uint32_t service_id,
+ uint32_t method_id,
+ std::span<const byte> payload = kDefaultPayload) {
auto sws = Packet(type, channel_id, service_id, method_id, payload)
.Encode(request_buffer_);
EXPECT_EQ(Status::OK, sws.status());
- return span(request_buffer_, sws.size());
+ return std::span(request_buffer_, sws.size());
}
private:
diff --git a/pw_rpc/test_impl/public_overrides/pw_rpc/internal/method.h b/pw_rpc/test_impl/public_overrides/pw_rpc/internal/method.h
index 6c3beeb..297f14e 100644
--- a/pw_rpc/test_impl/public_overrides/pw_rpc/internal/method.h
+++ b/pw_rpc/test_impl/public_overrides/pw_rpc/internal/method.h
@@ -15,10 +15,10 @@
#include <cstdint>
#include <cstring>
+#include <span>
#include "pw_rpc/internal/base_method.h"
#include "pw_rpc/server_context.h"
-#include "pw_span/span.h"
#include "pw_status/status_with_size.h"
namespace pw::rpc::internal {
@@ -30,8 +30,8 @@
constexpr Method(uint32_t id) : BaseMethod(id), last_channel_id_(0) {}
StatusWithSize Invoke(ServerCall& call,
- span<const std::byte> request,
- span<std::byte> payload_buffer) const {
+ std::span<const std::byte> request,
+ std::span<std::byte> payload_buffer) const {
last_channel_id_ = call.channel().id();
last_request_ = request;
last_payload_buffer_ = payload_buffer;
@@ -43,10 +43,12 @@
}
uint32_t last_channel_id() const { return last_channel_id_; }
- span<const std::byte> last_request() const { return last_request_; }
- span<std::byte> last_payload_buffer() const { return last_payload_buffer_; }
+ std::span<const std::byte> last_request() const { return last_request_; }
+ std::span<std::byte> last_payload_buffer() const {
+ return last_payload_buffer_;
+ }
- void set_response(span<const std::byte> payload) { response_ = payload; }
+ void set_response(std::span<const std::byte> payload) { response_ = payload; }
void set_status(Status status) { response_status_ = status; }
private:
@@ -54,10 +56,10 @@
// The Method class is used exclusively in tests. Having these members mutable
// allows tests to verify that the Method is invoked correctly.
mutable uint32_t last_channel_id_;
- mutable span<const std::byte> last_request_;
- mutable span<std::byte> last_payload_buffer_;
+ mutable std::span<const std::byte> last_request_;
+ mutable std::span<std::byte> last_payload_buffer_;
- span<const std::byte> response_;
+ std::span<const std::byte> response_;
Status response_status_;
};
diff --git a/pw_stream/memory_stream.cc b/pw_stream/memory_stream.cc
index efe2c97..ca7e276 100644
--- a/pw_stream/memory_stream.cc
+++ b/pw_stream/memory_stream.cc
@@ -21,7 +21,7 @@
namespace pw::stream {
-Status MemoryWriter::DoWrite(span<const std::byte> data) {
+Status MemoryWriter::DoWrite(std::span<const std::byte> data) {
size_t bytes_to_write =
std::min(data.size_bytes(), dest_.size_bytes() - bytes_written_);
std::memcpy(dest_.data() + bytes_written_, data.data(), bytes_to_write);
diff --git a/pw_stream/memory_stream_test.cc b/pw_stream/memory_stream_test.cc
index ada85ab..9e37bf3 100644
--- a/pw_stream/memory_stream_test.cc
+++ b/pw_stream/memory_stream_test.cc
@@ -47,7 +47,7 @@
EXPECT_TRUE(
memory_writer.Write(&kExpectedStruct, sizeof(kExpectedStruct)).ok());
- span<const std::byte> written_data = memory_writer.WrittenData();
+ std::span<const std::byte> written_data = memory_writer.WrittenData();
EXPECT_EQ(written_data.size_bytes(), sizeof(kExpectedStruct));
TestStruct temp;
std::memcpy(&temp, written_data.data(), written_data.size_bytes());
@@ -65,7 +65,8 @@
for (size_t i = 0; i < sizeof(buffer); ++i) {
buffer[i] = std::byte(counter++);
}
- } while (memory_writer.Write(span(buffer)) != Status::RESOURCE_EXHAUSTED);
+ } while (memory_writer.Write(std::span(buffer)) !=
+ Status::RESOURCE_EXHAUSTED);
// Ensure that we counted up to at least the sink buffer size. This can be
// more since we write to the sink via in intermediate buffer.
diff --git a/pw_stream/public/pw_stream/memory_stream.h b/pw_stream/public/pw_stream/memory_stream.h
index ad9d30d..2dec4a2 100644
--- a/pw_stream/public/pw_stream/memory_stream.h
+++ b/pw_stream/public/pw_stream/memory_stream.h
@@ -15,19 +15,19 @@
#include <array>
#include <cstddef>
+#include <span>
-#include "pw_span/span.h"
#include "pw_stream/stream.h"
namespace pw::stream {
class MemoryWriter : public Writer {
public:
- MemoryWriter(span<std::byte> dest) : dest_(dest) {}
+ MemoryWriter(std::span<std::byte> dest) : dest_(dest) {}
size_t bytes_written() const { return bytes_written_; }
- span<const std::byte> WrittenData() const {
+ std::span<const std::byte> WrittenData() const {
return dest_.first(bytes_written_);
}
@@ -38,9 +38,9 @@
//
// If the in-memory buffer is exhausted in the middle of a write, this will
// perform a partial write and Status::RESOURCE_EXHAUSTED will be returned.
- Status DoWrite(span<const std::byte> data) override;
+ Status DoWrite(std::span<const std::byte> data) override;
- span<std::byte> dest_;
+ std::span<std::byte> dest_;
size_t bytes_written_ = 0;
};
diff --git a/pw_stream/public/pw_stream/stream.h b/pw_stream/public/pw_stream/stream.h
index 6d51191..13e30e9 100644
--- a/pw_stream/public/pw_stream/stream.h
+++ b/pw_stream/public/pw_stream/stream.h
@@ -15,9 +15,9 @@
#include <array>
#include <cstddef>
+#include <span>
#include "pw_assert/assert.h"
-#include "pw_span/span.h"
#include "pw_status/status.h"
namespace pw::stream {
@@ -36,12 +36,12 @@
//
// Derived classes should NOT try to override these public write methods.
// Instead, provide an implementation by overriding DoWrite().
- Status Write(span<const std::byte> data) {
+ Status Write(std::span<const std::byte> data) {
PW_DCHECK(data.empty() || data.data() != nullptr);
return DoWrite(data);
}
Status Write(const void* data, size_t size_bytes) {
- return Write(span(static_cast<const std::byte*>(data), size_bytes));
+ return Write(std::span(static_cast<const std::byte*>(data), size_bytes));
}
// Flush any buffered data, finalizing all writes.
@@ -52,7 +52,7 @@
virtual Status Flush() { return Status::OK; }
private:
- virtual Status DoWrite(span<const std::byte> data) = 0;
+ virtual Status DoWrite(std::span<const std::byte> data) = 0;
};
} // namespace pw::stream
diff --git a/pw_sys_io/public/pw_sys_io/sys_io.h b/pw_sys_io/public/pw_sys_io/sys_io.h
index 3010de1..5f545b3 100644
--- a/pw_sys_io/public/pw_sys_io/sys_io.h
+++ b/pw_sys_io/public/pw_sys_io/sys_io.h
@@ -37,9 +37,9 @@
#include <cstddef>
#include <cstring>
+#include <span>
#include <string_view>
-#include "pw_span/span.h"
#include "pw_status/status.h"
#include "pw_status/status_with_size.h"
@@ -75,7 +75,7 @@
// are returned as part of the StatusWithSize.
StatusWithSize WriteLine(const std::string_view& s);
-// Fill a byte span from the sys io backend using ReadByte().
+// Fill a byte std::span from the sys io backend using ReadByte().
// Implemented by: Facade
//
// This function is implemented by this facade and simply uses ReadByte() to
@@ -87,9 +87,9 @@
// Return status is Status::OK if the destination span was successfully filled.
// In all cases, the number of bytes successuflly read to the destination span
// are returned as part of the StatusWithSize.
-StatusWithSize ReadBytes(span<std::byte> dest);
+StatusWithSize ReadBytes(std::span<std::byte> dest);
-// Write span of bytes out the sys io backend using WriteByte().
+// Write std::span of bytes out the sys io backend using WriteByte().
// Implemented by: Facade
//
// This function is implemented by this facade and simply writes the source
@@ -101,6 +101,6 @@
// Return status is Status::OK if all the bytes from the source span were
// successfully written. In all cases, the number of bytes successfully written
// are returned as part of the StatusWithSize.
-StatusWithSize WriteBytes(span<const std::byte> src);
+StatusWithSize WriteBytes(std::span<const std::byte> src);
} // namespace pw::sys_io
diff --git a/pw_sys_io/sys_io.cc b/pw_sys_io/sys_io.cc
index ed0ab5c..8e013c3 100644
--- a/pw_sys_io/sys_io.cc
+++ b/pw_sys_io/sys_io.cc
@@ -16,7 +16,7 @@
namespace pw::sys_io {
-StatusWithSize ReadBytes(span<std::byte> dest) {
+StatusWithSize ReadBytes(std::span<std::byte> dest) {
for (size_t i = 0; i < dest.size_bytes(); ++i) {
Status result = ReadByte(&dest[i]);
if (!result.ok()) {
@@ -26,7 +26,7 @@
return StatusWithSize(dest.size_bytes());
}
-StatusWithSize WriteBytes(span<const std::byte> src) {
+StatusWithSize WriteBytes(std::span<const std::byte> src) {
for (size_t i = 0; i < src.size_bytes(); ++i) {
Status result = WriteByte(src[i]);
if (!result.ok()) {
diff --git a/pw_sys_io_baremetal_lm3s6965evb/sys_io_baremetal.cc b/pw_sys_io_baremetal_lm3s6965evb/sys_io_baremetal.cc
index 7930439..29fed33 100644
--- a/pw_sys_io_baremetal_lm3s6965evb/sys_io_baremetal.cc
+++ b/pw_sys_io_baremetal_lm3s6965evb/sys_io_baremetal.cc
@@ -169,14 +169,14 @@
// Writes a string using pw::sys_io, and add newline characters at the end.
StatusWithSize WriteLine(const std::string_view& s) {
size_t chars_written = 0;
- StatusWithSize result = WriteBytes(as_bytes(span(s)));
+ StatusWithSize result = WriteBytes(std::as_bytes(std::span(s)));
if (!result.ok()) {
return result;
}
chars_written += result.size();
// Write trailing newline ("\n\r").
- result = WriteBytes(as_bytes(span("\n\r", 2)));
+ result = WriteBytes(std::as_bytes(std::span("\n\r", 2)));
chars_written += result.size();
return StatusWithSize(result.status(), chars_written);
diff --git a/pw_sys_io_baremetal_stm32f429/sys_io_baremetal.cc b/pw_sys_io_baremetal_stm32f429/sys_io_baremetal.cc
index c5f5526..9145931 100644
--- a/pw_sys_io_baremetal_stm32f429/sys_io_baremetal.cc
+++ b/pw_sys_io_baremetal_stm32f429/sys_io_baremetal.cc
@@ -234,14 +234,14 @@
// Writes a string using pw::sys_io, and add newline characters at the end.
StatusWithSize WriteLine(const std::string_view& s) {
size_t chars_written = 0;
- StatusWithSize result = WriteBytes(as_bytes(span(s)));
+ StatusWithSize result = WriteBytes(std::as_bytes(std::span(s)));
if (!result.ok()) {
return result;
}
chars_written += result.size();
// Write trailing newline ("\n\r").
- result = WriteBytes(as_bytes(span("\n\r", 2)));
+ result = WriteBytes(std::as_bytes(std::span("\n\r", 2)));
chars_written += result.size();
return StatusWithSize(result.status(), chars_written);
diff --git a/pw_sys_io_stdio/sys_io.cc b/pw_sys_io_stdio/sys_io.cc
index 72e4df6..65d1a89 100644
--- a/pw_sys_io_stdio/sys_io.cc
+++ b/pw_sys_io_stdio/sys_io.cc
@@ -40,7 +40,7 @@
StatusWithSize WriteLine(const std::string_view& s) {
size_t chars_written = 0;
- StatusWithSize size_result = WriteBytes(as_bytes(span(s)));
+ StatusWithSize size_result = WriteBytes(std::as_bytes(std::span(s)));
if (!size_result.ok()) {
return size_result;
}
diff --git a/pw_tokenizer/base64.cc b/pw_tokenizer/base64.cc
index e05390e..6ce4a4c 100644
--- a/pw_tokenizer/base64.cc
+++ b/pw_tokenizer/base64.cc
@@ -14,8 +14,9 @@
#include "pw_tokenizer/base64.h"
+#include <span>
+
#include "pw_base64/base64.h"
-#include "pw_span/span.h"
namespace pw::tokenizer {
@@ -33,9 +34,9 @@
char* output = static_cast<char*>(output_buffer);
output[0] = kBase64Prefix;
- base64::Encode(
- span(static_cast<const std::byte*>(binary_message), binary_size_bytes),
- &output[1]);
+ base64::Encode(std::span(static_cast<const std::byte*>(binary_message),
+ binary_size_bytes),
+ &output[1]);
return encoded_size;
}
@@ -52,7 +53,7 @@
return base64::Decode(
std::string_view(&base64[1], base64_size_bytes - 1),
- span(static_cast<std::byte*>(output_buffer), output_buffer_size));
+ std::span(static_cast<std::byte*>(output_buffer), output_buffer_size));
}
} // namespace pw::tokenizer
diff --git a/pw_tokenizer/base64_test.cc b/pw_tokenizer/base64_test.cc
index 8a6f8b6..59f3a05 100644
--- a/pw_tokenizer/base64_test.cc
+++ b/pw_tokenizer/base64_test.cc
@@ -15,10 +15,10 @@
#include "pw_tokenizer/base64.h"
#include <cstring>
+#include <span>
#include <string_view>
#include "gtest/gtest.h"
-#include "pw_span/span.h"
namespace pw::tokenizer {
namespace {
@@ -34,9 +34,10 @@
const struct TestData {
template <size_t kSize>
TestData(const char (&binary_data)[kSize], const char* base64_data)
- : binary{as_bytes(span(binary_data, kSize - 1))}, base64(base64_data) {}
+ : binary{std::as_bytes(std::span(binary_data, kSize - 1))},
+ base64(base64_data) {}
- span<const std::byte> binary;
+ std::span<const std::byte> binary;
std::string_view base64;
} kTestData[] = {
{"", "$"},
@@ -68,7 +69,8 @@
}
TEST_F(PrefixedBase64, Encode_EmptyOutput_WritesNothing) {
- EXPECT_EQ(0u, PrefixedBase64Encode(kTestData[5].binary, span(base64_, 0)));
+ EXPECT_EQ(0u,
+ PrefixedBase64Encode(kTestData[5].binary, std::span(base64_, 0)));
EXPECT_EQ('\0', base64_[0]);
}
@@ -90,15 +92,16 @@
}
TEST_F(PrefixedBase64, Decode_EmptyOutput_WritesNothing) {
- EXPECT_EQ(0u, PrefixedBase64Decode(kTestData[5].base64, span(binary_, 0)));
+ EXPECT_EQ(0u,
+ PrefixedBase64Decode(kTestData[5].base64, std::span(binary_, 0)));
EXPECT_EQ(std::byte{0}, binary_[0]);
}
TEST_F(PrefixedBase64, Decode_OutputTooSmall_WritesNothing) {
auto& item = kTestData[5];
- EXPECT_EQ(
- 0u,
- PrefixedBase64Decode(item.base64, span(binary_, item.binary.size() - 1)));
+ EXPECT_EQ(0u,
+ PrefixedBase64Decode(item.base64,
+ std::span(binary_, item.binary.size() - 1)));
EXPECT_EQ(std::byte{0}, binary_[0]);
}
@@ -109,7 +112,7 @@
std::memcpy(buffer, base64.data(), base64.size());
EXPECT_EQ(binary.size(),
- PrefixedBase64DecodeInPlace(span(buffer, base64.size())));
+ PrefixedBase64DecodeInPlace(std::span(buffer, base64.size())));
ASSERT_EQ(0, std::memcmp(binary.data(), buffer, binary.size()));
}
}
diff --git a/pw_tokenizer/decode.cc b/pw_tokenizer/decode.cc
index 22ce61a..cccaa08 100644
--- a/pw_tokenizer/decode.cc
+++ b/pw_tokenizer/decode.cc
@@ -172,7 +172,7 @@
}
DecodedArg StringSegment::DecodeString(
- const span<const uint8_t>& arguments) const {
+ const std::span<const uint8_t>& arguments) const {
if (arguments.empty()) {
return DecodedArg(ArgStatus::kMissing, text_);
}
@@ -201,13 +201,13 @@
}
DecodedArg StringSegment::DecodeInteger(
- const span<const uint8_t>& arguments) const {
+ const std::span<const uint8_t>& arguments) const {
if (arguments.empty()) {
return DecodedArg(ArgStatus::kMissing, text_);
}
int64_t value;
- const size_t bytes = varint::Decode(pw::as_bytes(arguments), &value);
+ const size_t bytes = varint::Decode(std::as_bytes(arguments), &value);
if (bytes == 0u) {
return DecodedArg(ArgStatus::kDecodeError,
@@ -228,7 +228,7 @@
}
DecodedArg StringSegment::DecodeFloatingPoint(
- const span<const uint8_t>& arguments) const {
+ const std::span<const uint8_t>& arguments) const {
static_assert(sizeof(float) == 4u);
if (arguments.size() < sizeof(float)) {
return DecodedArg(ArgStatus::kMissing, text_);
@@ -239,7 +239,8 @@
return DecodedArg::FromValue(text_.c_str(), value, sizeof(value));
}
-DecodedArg StringSegment::Decode(const span<const uint8_t>& arguments) const {
+DecodedArg StringSegment::Decode(
+ const std::span<const uint8_t>& arguments) const {
switch (type_) {
case kLiteral:
return DecodedArg(text_);
@@ -329,7 +330,8 @@
}
}
-DecodedFormatString FormatString::Format(span<const uint8_t> arguments) const {
+DecodedFormatString FormatString::Format(
+ std::span<const uint8_t> arguments) const {
std::vector<DecodedArg> results;
bool skip = false;
diff --git a/pw_tokenizer/detokenize.cc b/pw_tokenizer/detokenize.cc
index ef46269..ad7bb78 100644
--- a/pw_tokenizer/detokenize.cc
+++ b/pw_tokenizer/detokenize.cc
@@ -69,8 +69,8 @@
DetokenizedString::DetokenizedString(
uint32_t token,
- const span<const TokenizedStringEntry>& entries,
- const span<const uint8_t>& arguments)
+ const std::span<const TokenizedStringEntry>& entries,
+ const std::span<const uint8_t>& arguments)
: token_(token), has_token_(true) {
std::vector<DecodingResult> results;
@@ -104,7 +104,7 @@
}
DetokenizedString Detokenizer::Detokenize(
- const span<const uint8_t>& encoded) const {
+ const std::span<const uint8_t>& encoded) const {
// The token is missing from the encoded data; there is nothing to do.
if (encoded.size() < sizeof(uint32_t)) {
return DetokenizedString();
@@ -117,8 +117,8 @@
return DetokenizedString(token,
result == database_.end()
- ? span<TokenizedStringEntry>()
- : span(result->second),
+ ? std::span<TokenizedStringEntry>()
+ : std::span(result->second),
encoded.subspan(sizeof(token)));
}
diff --git a/pw_tokenizer/detokenize_fuzzer.cc b/pw_tokenizer/detokenize_fuzzer.cc
index 76e3a7f..cf55717 100644
--- a/pw_tokenizer/detokenize_fuzzer.cc
+++ b/pw_tokenizer/detokenize_fuzzer.cc
@@ -76,7 +76,7 @@
std::vector<uint8_t> buffer =
provider.ConsumeBytes<uint8_t>(consumed_size);
auto detokenized_string =
- detokenizer.Detokenize(pw::span(&buffer[0], buffer.size()));
+ detokenizer.Detokenize(std::span(&buffer[0], buffer.size()));
PW_UNUSED(detokenized_string);
break;
}
diff --git a/pw_tokenizer/encode_args.cc b/pw_tokenizer/encode_args.cc
index 27fa7f2..b53cc22 100644
--- a/pw_tokenizer/encode_args.cc
+++ b/pw_tokenizer/encode_args.cc
@@ -73,15 +73,15 @@
static_assert(0b10u == static_cast<uint8_t>(ArgType::kDouble));
static_assert(0b11u == static_cast<uint8_t>(ArgType::kString));
-size_t EncodeInt(int value, const span<uint8_t>& output) {
- return varint::Encode(value, pw::as_writable_bytes(output));
+size_t EncodeInt(int value, const std::span<uint8_t>& output) {
+ return varint::Encode(value, std::as_writable_bytes(output));
}
-size_t EncodeInt64(int64_t value, const span<uint8_t>& output) {
- return varint::Encode(value, pw::as_writable_bytes(output));
+size_t EncodeInt64(int64_t value, const std::span<uint8_t>& output) {
+ return varint::Encode(value, std::as_writable_bytes(output));
}
-size_t EncodeFloat(float value, const span<uint8_t>& output) {
+size_t EncodeFloat(float value, const std::span<uint8_t>& output) {
if (output.size() < sizeof(value)) {
return 0;
}
@@ -89,7 +89,7 @@
return sizeof(value);
}
-size_t EncodeString(const char* string, const span<uint8_t>& output) {
+size_t EncodeString(const char* string, const std::span<uint8_t>& output) {
// The top bit of the status byte indicates if the string was truncated.
static constexpr size_t kMaxStringLength = 0x7Fu;
@@ -126,7 +126,7 @@
size_t EncodeArgs(pw_TokenizerArgTypes types,
va_list args,
- span<uint8_t> output) {
+ std::span<uint8_t> output) {
size_t arg_count = types & PW_TOKENIZER_TYPE_COUNT_MASK;
types >>= PW_TOKENIZER_TYPE_COUNT_SIZE_BITS;
diff --git a/pw_tokenizer/generate_decoding_test_data.cc b/pw_tokenizer/generate_decoding_test_data.cc
index b43cb9c..9adfdfe 100644
--- a/pw_tokenizer/generate_decoding_test_data.cc
+++ b/pw_tokenizer/generate_decoding_test_data.cc
@@ -25,8 +25,8 @@
#include <cstdint>
#include <cstdio>
#include <random>
+#include <span>
-#include "pw_span/span.h"
#include "pw_tokenizer/internal/decode.h"
#include "pw_tokenizer/tokenize.h"
#include "pw_varint/varint.h"
@@ -168,7 +168,7 @@
// Writes a decoding test case to the file.
void TestCase(TestDataFile* file,
- pw::span<const uint8_t> buffer,
+ std::span<const uint8_t> buffer,
const char* format,
const char* formatted) {
file->printf(R"(TestCase("%s", "%s", %s)",
@@ -189,7 +189,7 @@
const char (&buffer)[kSize],
const char* formatted) {
TestCase(file,
- pw::span(reinterpret_cast<const uint8_t*>(buffer), kSize - 1),
+ std::span(reinterpret_cast<const uint8_t*>(buffer), kSize - 1),
format,
formatted);
}
@@ -204,7 +204,7 @@
std::array<char, 128> formatted = {}; \
std::snprintf(formatted.data(), formatted.size(), format, ##__VA_ARGS__); \
TestCase(file, \
- pw::span(buffer).first(size).subspan(4), /* skip the token */ \
+ std::span(buffer).first(size).subspan(4), /* skip the token */ \
format, \
formatted.data()); \
} while (0)
@@ -382,7 +382,8 @@
std::array<uint8_t, 10> buffer;
// All integers are encoded as signed for tokenization.
- size_t size = pw::varint::Encode(i, pw::as_writable_bytes(pw::span(buffer)));
+ size_t size =
+ pw::varint::Encode(i, std::as_writable_bytes(std::span(buffer)));
for (size_t i = 0; i < size; ++i) {
file->printf("\\x%02x", buffer[i]);
diff --git a/pw_tokenizer/java/dev/pigweed/tokenizer/detokenizer.cc b/pw_tokenizer/java/dev/pigweed/tokenizer/detokenizer.cc
index b2c8f33..06a5003 100644
--- a/pw_tokenizer/java/dev/pigweed/tokenizer/detokenizer.cc
+++ b/pw_tokenizer/java/dev/pigweed/tokenizer/detokenizer.cc
@@ -19,9 +19,9 @@
#include <jni.h>
#include <cstring>
+#include <span>
#include "pw_preprocessor/concat.h"
-#include "pw_span/span.h"
#include "pw_tokenizer/detokenize.h"
#include "pw_tokenizer/token_database.h"
@@ -57,7 +57,7 @@
jbyte* const data = env->GetByteArrayElements(array, nullptr);
const jsize size = env->GetArrayLength(array);
- TokenDatabase tokens = TokenDatabase::Create(pw::span(data, size));
+ TokenDatabase tokens = TokenDatabase::Create(std::span(data, size));
const jlong handle =
PointerToHandle(new Detokenizer(tokens.ok() ? tokens : TokenDatabase()));
diff --git a/pw_tokenizer/public/pw_tokenizer/base64.h b/pw_tokenizer/public/pw_tokenizer/base64.h
index 45bc029..679b805 100644
--- a/pw_tokenizer/public/pw_tokenizer/base64.h
+++ b/pw_tokenizer/public/pw_tokenizer/base64.h
@@ -63,10 +63,9 @@
#ifdef __cplusplus
+#include <span>
#include <string_view>
-#include "pw_span/span.h"
-
namespace pw::tokenizer {
inline constexpr char kBase64Prefix = PW_TOKENIZER_BASE64_PREFIX;
@@ -74,8 +73,8 @@
// Encodes a binary tokenized message as prefixed Base64. Returns the size of
// the number of characters written to output_buffer. Returns 0 if the buffer is
// too small.
-inline size_t PrefixedBase64Encode(span<const std::byte> binary_message,
- span<char> output_buffer) {
+inline size_t PrefixedBase64Encode(std::span<const std::byte> binary_message,
+ std::span<char> output_buffer) {
return pw_TokenizerPrefixedBase64Encode(binary_message.data(),
binary_message.size(),
output_buffer.data(),
@@ -86,7 +85,7 @@
// the decoded binary data. The resulting data is ready to be passed to
// pw::tokenizer::Detokenizer::Detokenize.
inline size_t PrefixedBase64Decode(std::string_view base64_message,
- span<std::byte> output_buffer) {
+ std::span<std::byte> output_buffer) {
return pw_TokenizerPrefixedBase64Decode(base64_message.data(),
base64_message.size(),
output_buffer.data(),
@@ -95,7 +94,7 @@
// Decodes a prefixed Base64 tokenized message to binary in place. Returns the
// size of the decoded binary data.
-inline size_t PrefixedBase64DecodeInPlace(span<std::byte> buffer) {
+inline size_t PrefixedBase64DecodeInPlace(std::span<std::byte> buffer) {
return pw_TokenizerPrefixedBase64Decode(
buffer.data(), buffer.size(), buffer.data(), buffer.size());
}
diff --git a/pw_tokenizer/public/pw_tokenizer/detokenize.h b/pw_tokenizer/public/pw_tokenizer/detokenize.h
index 7450249..7c658cf 100644
--- a/pw_tokenizer/public/pw_tokenizer/detokenize.h
+++ b/pw_tokenizer/public/pw_tokenizer/detokenize.h
@@ -26,12 +26,12 @@
#include <cstddef>
#include <cstdint>
+#include <span>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
-#include "pw_span/span.h"
#include "pw_tokenizer/internal/decode.h"
#include "pw_tokenizer/token_database.h"
@@ -44,8 +44,8 @@
class DetokenizedString {
public:
DetokenizedString(uint32_t token,
- const span<const TokenizedStringEntry>& entries,
- const span<const uint8_t>& arguments);
+ const std::span<const TokenizedStringEntry>& entries,
+ const std::span<const uint8_t>& arguments);
DetokenizedString() : has_token_(false) {}
@@ -80,14 +80,15 @@
// Decodes and detokenizes the encoded message. Returns a DetokenizedString
// that stores all possible detokenized string results.
- DetokenizedString Detokenize(const span<const uint8_t>& encoded) const;
+ DetokenizedString Detokenize(const std::span<const uint8_t>& encoded) const;
DetokenizedString Detokenize(const std::string_view& encoded) const {
return Detokenize(encoded.data(), encoded.size());
}
DetokenizedString Detokenize(const void* encoded, size_t size_bytes) const {
- return Detokenize(span(static_cast<const uint8_t*>(encoded), size_bytes));
+ return Detokenize(
+ std::span(static_cast<const uint8_t*>(encoded), size_bytes));
}
private:
diff --git a/pw_tokenizer/public/pw_tokenizer/internal/decode.h b/pw_tokenizer/public/pw_tokenizer/internal/decode.h
index 8cdf690..913838f 100644
--- a/pw_tokenizer/public/pw_tokenizer/internal/decode.h
+++ b/pw_tokenizer/public/pw_tokenizer/internal/decode.h
@@ -20,13 +20,12 @@
#include <cstddef>
#include <cstdint>
#include <cstdio>
+#include <span>
#include <string>
#include <string_view>
#include <utility>
#include <vector>
-#include "pw_span/span.h"
-
// Decoding errors are marked with prefix and suffix so that they stand out from
// the rest of the decoded strings. These macros are used to build decoding
// error strings.
@@ -132,7 +131,7 @@
// Returns the DecodedArg with this StringSegment decoded according to the
// provided arguments.
- DecodedArg Decode(const span<const uint8_t>& arguments) const;
+ DecodedArg Decode(const std::span<const uint8_t>& arguments) const;
// Skips decoding this StringSegment. Literals and %% are expanded as normal.
DecodedArg Skip() const;
@@ -170,11 +169,12 @@
StringSegment(const std::string_view& text, Type type, ArgSize local_size)
: text_(text), type_(type), local_size_(local_size) {}
- DecodedArg DecodeString(const span<const uint8_t>& arguments) const;
+ DecodedArg DecodeString(const std::span<const uint8_t>& arguments) const;
- DecodedArg DecodeInteger(const span<const uint8_t>& arguments) const;
+ DecodedArg DecodeInteger(const std::span<const uint8_t>& arguments) const;
- DecodedArg DecodeFloatingPoint(const span<const uint8_t>& arguments) const;
+ DecodedArg DecodeFloatingPoint(
+ const std::span<const uint8_t>& arguments) const;
std::string text_;
Type type_;
@@ -229,11 +229,11 @@
// Formats this format string according to the provided encoded arguments and
// returns a string.
- DecodedFormatString Format(span<const uint8_t> arguments) const;
+ DecodedFormatString Format(std::span<const uint8_t> arguments) const;
DecodedFormatString Format(const std::string_view& arguments) const {
- return Format(span(reinterpret_cast<const uint8_t*>(arguments.data()),
- arguments.size()));
+ return Format(std::span(reinterpret_cast<const uint8_t*>(arguments.data()),
+ arguments.size()));
}
private:
diff --git a/pw_tokenizer/pw_tokenizer_private/encode_args.h b/pw_tokenizer/pw_tokenizer_private/encode_args.h
index b1360a8..2f39949 100644
--- a/pw_tokenizer/pw_tokenizer_private/encode_args.h
+++ b/pw_tokenizer/pw_tokenizer_private/encode_args.h
@@ -16,8 +16,8 @@
#include <array>
#include <cstdarg>
#include <cstddef>
+#include <span>
-#include "pw_span/span.h"
#include "pw_tokenizer/config.h"
#include "pw_tokenizer/internal/argument_types.h"
#include "pw_tokenizer/internal/tokenize_string.h"
@@ -38,7 +38,7 @@
// parameter specifies the argument types, in place of a format string.
size_t EncodeArgs(pw_TokenizerArgTypes types,
va_list args,
- span<uint8_t> output);
+ std::span<uint8_t> output);
} // namespace tokenizer
} // namespace pw
diff --git a/pw_tokenizer/token_database_fuzzer.cc b/pw_tokenizer/token_database_fuzzer.cc
index 0fb5d57..3e243c8 100644
--- a/pw_tokenizer/token_database_fuzzer.cc
+++ b/pw_tokenizer/token_database_fuzzer.cc
@@ -18,11 +18,11 @@
// operations on this database.
#include <cstring>
+#include <span>
#include "pw_fuzzer/asan_interface.h"
#include "pw_fuzzer/fuzzed_data_provider.h"
#include "pw_preprocessor/util.h"
-#include "pw_span/span.h"
#include "pw_tokenizer/token_database.h"
namespace pw::tokenizer {
@@ -115,12 +115,12 @@
ASAN_POISON_MEMORY_REGION(poisoned, poisoned_length);
- // We create a database from a span of the buffer since the string
+ // We create a database from a std::span of the buffer since the string
// entries might not be null terminated, and the creation of a database
// from a raw buffer has an explicit null terminated string requirement
// specified in the API.
- span<uint8_t> data_span(buffer, data_size);
- auto token_database = TokenDatabase::Create<span<uint8_t>>(data_span);
+ std::span<uint8_t> data_span(buffer, data_size);
+ auto token_database = TokenDatabase::Create<std::span<uint8_t>>(data_span);
volatile auto match = token_database.Find(random_token);
PW_UNUSED(match);
diff --git a/pw_tokenizer/tokenize.cc b/pw_tokenizer/tokenize.cc
index 4f29876..c7e3699 100644
--- a/pw_tokenizer/tokenize.cc
+++ b/pw_tokenizer/tokenize.cc
@@ -40,11 +40,11 @@
va_list args;
va_start(args, types);
- const size_t encoded_bytes =
- EncodeArgs(types,
- args,
- span<uint8_t>(static_cast<uint8_t*>(buffer) + sizeof(token),
- *buffer_size_bytes - sizeof(token)));
+ const size_t encoded_bytes = EncodeArgs(
+ types,
+ args,
+ std::span<uint8_t>(static_cast<uint8_t*>(buffer) + sizeof(token),
+ *buffer_size_bytes - sizeof(token)));
va_end(args);
*buffer_size_bytes = sizeof(token) + encoded_bytes;
diff --git a/pw_unit_test/simple_printing_main.cc b/pw_unit_test/simple_printing_main.cc
index 859f5f8..5aeab45 100644
--- a/pw_unit_test/simple_printing_main.cc
+++ b/pw_unit_test/simple_printing_main.cc
@@ -12,9 +12,9 @@
// License for the specific language governing permissions and limitations under
// the License.
+#include <span>
#include <string_view>
-#include "pw_span/span.h"
#include "pw_sys_io/sys_io.h"
#include "pw_unit_test/framework.h"
#include "pw_unit_test/simple_printing_event_handler.h"
@@ -25,7 +25,7 @@
if (append_newline) {
pw::sys_io::WriteLine(s);
} else {
- pw::sys_io::WriteBytes(pw::as_bytes(pw::span(s)));
+ pw::sys_io::WriteBytes(std::as_bytes(std::span(s)));
}
});
diff --git a/pw_varint/public/pw_varint/varint.h b/pw_varint/public/pw_varint/varint.h
index b128bc0..b9f6e59 100644
--- a/pw_varint/public/pw_varint/varint.h
+++ b/pw_varint/public/pw_varint/varint.h
@@ -40,10 +40,10 @@
} // extern "C"
+#include <span>
#include <type_traits>
#include "pw_polyfill/language_features.h"
-#include "pw_span/span.h"
namespace pw {
namespace varint {
@@ -82,7 +82,7 @@
// Encodes a uint64_t with Little-Endian Base 128 (LEB128) encoding.
inline size_t EncodeLittleEndianBase128(uint64_t integer,
- const span<std::byte>& output) {
+ const std::span<std::byte>& output) {
return pw_VarintEncode(integer, output.data(), output.size());
}
@@ -97,7 +97,7 @@
// Returns the number of bytes written or 0 if the result didn't fit in the
// encoding buffer.
template <typename T>
-size_t Encode(T integer, const span<std::byte>& output) {
+size_t Encode(T integer, const std::span<std::byte>& output) {
if (std::is_signed<T>()) {
return pw_VarintZigZagEncode(integer, output.data(), output.size());
} else {
@@ -125,11 +125,11 @@
// data = data.subspan(bytes)
// }
//
-inline size_t Decode(const span<const std::byte>& input, int64_t* value) {
+inline size_t Decode(const std::span<const std::byte>& input, int64_t* value) {
return pw_VarintZigZagDecode(input.data(), input.size(), value);
}
-inline size_t Decode(const span<const std::byte>& input, uint64_t* value) {
+inline size_t Decode(const std::span<const std::byte>& input, uint64_t* value) {
return pw_VarintDecode(input.data(), input.size(), value);
}
