pw_varint: Rename varint functions
This change removes "Varint" from the names of the Encode and Decode
functions in the pw_varint module, as they are already namespaced by
pw::varint.
Change-Id: I8f1383e390624b677d161a2ac2a1327c5e7ba5b1
diff --git a/pw_varint/public/pw_varint/varint.h b/pw_varint/public/pw_varint/varint.h
index dd4e34e..8d1995f 100644
--- a/pw_varint/public/pw_varint/varint.h
+++ b/pw_varint/public/pw_varint/varint.h
@@ -57,7 +57,7 @@
// Returns the number of bytes written or 0 if the result didn't fit in the
// encoding buffer.
template <typename T>
-size_t EncodeVarint(T integer, const span<std::byte>& output) {
+size_t Encode(T integer, const span<std::byte>& output) {
if constexpr (std::is_signed<T>()) {
return EncodeLittleEndianBase128(ZigZagEncode(integer), output);
} else {
@@ -76,7 +76,7 @@
//
// while (!data.empty()) {
// int64_t value;
-// size_t bytes = DecodeVarint(data, &value);
+// size_t bytes = Decode(data, &value);
//
// if (bytes == 0u) {
// return Status::DATA_LOSS;
@@ -85,7 +85,7 @@
// data = data.subspan(bytes)
// }
//
-size_t DecodeVarint(const span<const std::byte>& input, int64_t* value);
-size_t DecodeVarint(const span<const std::byte>& input, uint64_t* value);
+size_t Decode(const span<const std::byte>& input, int64_t* value);
+size_t Decode(const span<const std::byte>& input, uint64_t* value);
} // namespace pw::varint
diff --git a/pw_varint/varint.cc b/pw_varint/varint.cc
index 1c9084c..849d053 100644
--- a/pw_varint/varint.cc
+++ b/pw_varint/varint.cc
@@ -42,13 +42,13 @@
return written;
}
-size_t DecodeVarint(const span<const std::byte>& input, int64_t* value) {
- const size_t bytes = DecodeVarint(input, reinterpret_cast<uint64_t*>(value));
+size_t Decode(const span<const std::byte>& input, int64_t* value) {
+ const size_t bytes = Decode(input, reinterpret_cast<uint64_t*>(value));
*value = ZigZagDecode64(*value);
return bytes;
}
-size_t DecodeVarint(const span<const std::byte>& input, uint64_t* value) {
+size_t Decode(const span<const std::byte>& input, uint64_t* value) {
uint64_t decoded_value = 0;
uint_fast8_t count = 0;
diff --git a/pw_varint/varint_test.cc b/pw_varint/varint_test.cc
index b3818ae..54a0966 100644
--- a/pw_varint/varint_test.cc
+++ b/pw_varint/varint_test.cc
@@ -41,166 +41,161 @@
};
TEST_F(Varint, EncodeSizeUnsigned32_SmallSingleByte) {
- ASSERT_EQ(1u, EncodeVarint(UINT32_C(0), buffer_));
+ ASSERT_EQ(1u, Encode(UINT32_C(0), buffer_));
EXPECT_EQ(std::byte{0}, buffer_[0]);
- ASSERT_EQ(1u, EncodeVarint(UINT32_C(1), buffer_));
+ ASSERT_EQ(1u, Encode(UINT32_C(1), buffer_));
EXPECT_EQ(std::byte{1}, buffer_[0]);
- ASSERT_EQ(1u, EncodeVarint(UINT32_C(2), buffer_));
+ ASSERT_EQ(1u, Encode(UINT32_C(2), buffer_));
EXPECT_EQ(std::byte{2}, buffer_[0]);
}
TEST_F(Varint, EncodeSizeUnsigned32_LargeSingleByte) {
- ASSERT_EQ(1u, EncodeVarint(UINT32_C(63), buffer_));
+ ASSERT_EQ(1u, Encode(UINT32_C(63), buffer_));
EXPECT_EQ(std::byte{63}, buffer_[0]);
- ASSERT_EQ(1u, EncodeVarint(UINT32_C(64), buffer_));
+ ASSERT_EQ(1u, Encode(UINT32_C(64), buffer_));
EXPECT_EQ(std::byte{64}, buffer_[0]);
- ASSERT_EQ(1u, EncodeVarint(UINT32_C(126), buffer_));
+ ASSERT_EQ(1u, Encode(UINT32_C(126), buffer_));
EXPECT_EQ(std::byte{126}, buffer_[0]);
- ASSERT_EQ(1u, EncodeVarint(UINT32_C(127), buffer_));
+ ASSERT_EQ(1u, Encode(UINT32_C(127), buffer_));
EXPECT_EQ(std::byte{127}, buffer_[0]);
}
TEST_F(Varint, EncodeSizeUnsigned32_MultiByte) {
- ASSERT_EQ(2u, EncodeVarint(UINT32_C(128), buffer_));
+ ASSERT_EQ(2u, Encode(UINT32_C(128), buffer_));
EXPECT_EQ(std::memcmp("\x80\x01", buffer_, 2), 0);
- ASSERT_EQ(2u, EncodeVarint(UINT32_C(129), buffer_));
+ ASSERT_EQ(2u, Encode(UINT32_C(129), buffer_));
EXPECT_EQ(std::memcmp("\x81\x01", buffer_, 2), 0);
- ASSERT_EQ(5u,
- EncodeVarint(std::numeric_limits<uint32_t>::max() - 1, buffer_));
+ ASSERT_EQ(5u, Encode(std::numeric_limits<uint32_t>::max() - 1, buffer_));
EXPECT_EQ(std::memcmp("\xfe\xff\xff\xff\x0f", buffer_, 5), 0);
- ASSERT_EQ(5u, EncodeVarint(std::numeric_limits<uint32_t>::max(), buffer_));
+ ASSERT_EQ(5u, Encode(std::numeric_limits<uint32_t>::max(), buffer_));
EXPECT_EQ(std::memcmp("\xff\xff\xff\xff\x0f", buffer_, 5), 0);
}
TEST_F(Varint, EncodeSizeSigned32_SmallSingleByte) {
- ASSERT_EQ(1u, EncodeVarint(INT32_C(0), buffer_));
+ ASSERT_EQ(1u, Encode(INT32_C(0), buffer_));
EXPECT_EQ(std::byte{0}, buffer_[0]);
- ASSERT_EQ(1u, EncodeVarint(INT32_C(-1), buffer_));
+ ASSERT_EQ(1u, Encode(INT32_C(-1), buffer_));
EXPECT_EQ(std::byte{1}, buffer_[0]);
- ASSERT_EQ(1u, EncodeVarint(INT32_C(1), buffer_));
+ ASSERT_EQ(1u, Encode(INT32_C(1), buffer_));
EXPECT_EQ(std::byte{2}, buffer_[0]);
- ASSERT_EQ(1u, EncodeVarint(INT32_C(-2), buffer_));
+ ASSERT_EQ(1u, Encode(INT32_C(-2), buffer_));
EXPECT_EQ(std::byte{3}, buffer_[0]);
- ASSERT_EQ(1u, EncodeVarint(INT32_C(2), buffer_));
+ ASSERT_EQ(1u, Encode(INT32_C(2), buffer_));
EXPECT_EQ(std::byte{4}, buffer_[0]);
}
TEST_F(Varint, EncodeSizeSigned32_LargeSingleByte) {
- ASSERT_EQ(1u, EncodeVarint(INT32_C(-63), buffer_));
+ ASSERT_EQ(1u, Encode(INT32_C(-63), buffer_));
EXPECT_EQ(std::byte{125}, buffer_[0]);
- ASSERT_EQ(1u, EncodeVarint(INT32_C(63), buffer_));
+ ASSERT_EQ(1u, Encode(INT32_C(63), buffer_));
EXPECT_EQ(std::byte{126}, buffer_[0]);
- ASSERT_EQ(1u, EncodeVarint(INT32_C(-64), buffer_));
+ ASSERT_EQ(1u, Encode(INT32_C(-64), buffer_));
EXPECT_EQ(std::byte{127}, buffer_[0]);
}
TEST_F(Varint, EncodeSizeSigned32_MultiByte) {
- ASSERT_EQ(2u, EncodeVarint(INT32_C(64), buffer_));
+ ASSERT_EQ(2u, Encode(INT32_C(64), buffer_));
EXPECT_EQ(std::memcmp("\x80\x01", buffer_, 2), 0);
- ASSERT_EQ(2u, EncodeVarint(INT32_C(-65), buffer_));
+ ASSERT_EQ(2u, Encode(INT32_C(-65), buffer_));
EXPECT_EQ(std::memcmp("\x81\x01", buffer_, 2), 0);
- ASSERT_EQ(2u, EncodeVarint(INT32_C(65), buffer_));
+ ASSERT_EQ(2u, Encode(INT32_C(65), buffer_));
EXPECT_EQ(std::memcmp("\x82\x01", buffer_, 2), 0);
- ASSERT_EQ(5u, EncodeVarint(std::numeric_limits<int32_t>::min(), buffer_));
+ ASSERT_EQ(5u, Encode(std::numeric_limits<int32_t>::min(), buffer_));
EXPECT_EQ(std::memcmp("\xff\xff\xff\xff\x0f", buffer_, 5), 0);
- ASSERT_EQ(5u, EncodeVarint(std::numeric_limits<int32_t>::max(), buffer_));
+ ASSERT_EQ(5u, Encode(std::numeric_limits<int32_t>::max(), buffer_));
EXPECT_EQ(std::memcmp("\xfe\xff\xff\xff\x0f", buffer_, 5), 0);
}
TEST_F(Varint, EncodeSizeUnsigned64_SmallSingleByte) {
- ASSERT_EQ(1u, EncodeVarint(UINT64_C(0), buffer_));
+ ASSERT_EQ(1u, Encode(UINT64_C(0), buffer_));
EXPECT_EQ(std::byte{0}, buffer_[0]);
- ASSERT_EQ(1u, EncodeVarint(UINT64_C(1), buffer_));
+ ASSERT_EQ(1u, Encode(UINT64_C(1), buffer_));
EXPECT_EQ(std::byte{1}, buffer_[0]);
- ASSERT_EQ(1u, EncodeVarint(UINT64_C(2), buffer_));
+ ASSERT_EQ(1u, Encode(UINT64_C(2), buffer_));
EXPECT_EQ(std::byte{2}, buffer_[0]);
}
TEST_F(Varint, EncodeSizeUnsigned64_LargeSingleByte) {
- ASSERT_EQ(1u, EncodeVarint(UINT64_C(63), buffer_));
+ ASSERT_EQ(1u, Encode(UINT64_C(63), buffer_));
EXPECT_EQ(std::byte{63}, buffer_[0]);
- ASSERT_EQ(1u, EncodeVarint(UINT64_C(64), buffer_));
+ ASSERT_EQ(1u, Encode(UINT64_C(64), buffer_));
EXPECT_EQ(std::byte{64}, buffer_[0]);
- ASSERT_EQ(1u, EncodeVarint(UINT64_C(126), buffer_));
+ ASSERT_EQ(1u, Encode(UINT64_C(126), buffer_));
EXPECT_EQ(std::byte{126}, buffer_[0]);
- ASSERT_EQ(1u, EncodeVarint(UINT64_C(127), buffer_));
+ ASSERT_EQ(1u, Encode(UINT64_C(127), buffer_));
EXPECT_EQ(std::byte{127}, buffer_[0]);
}
TEST_F(Varint, EncodeSizeUnsigned64_MultiByte) {
- ASSERT_EQ(2u, EncodeVarint(UINT64_C(128), buffer_));
+ ASSERT_EQ(2u, Encode(UINT64_C(128), buffer_));
EXPECT_EQ(std::memcmp("\x80\x01", buffer_, 2), 0);
- ASSERT_EQ(2u, EncodeVarint(UINT64_C(129), buffer_));
+ ASSERT_EQ(2u, Encode(UINT64_C(129), buffer_));
EXPECT_EQ(std::memcmp("\x81\x01", buffer_, 2), 0);
- ASSERT_EQ(5u,
- EncodeVarint(std::numeric_limits<uint32_t>::max() - 1, buffer_));
+ ASSERT_EQ(5u, Encode(std::numeric_limits<uint32_t>::max() - 1, buffer_));
EXPECT_EQ(std::memcmp("\xfe\xff\xff\xff\x0f", buffer_, 5), 0);
- ASSERT_EQ(5u, EncodeVarint(std::numeric_limits<uint32_t>::max(), buffer_));
+ ASSERT_EQ(5u, Encode(std::numeric_limits<uint32_t>::max(), buffer_));
EXPECT_EQ(std::memcmp("\xff\xff\xff\xff\x0f", buffer_, 5), 0);
- ASSERT_EQ(10u,
- EncodeVarint(std::numeric_limits<uint64_t>::max() - 1, buffer_));
+ ASSERT_EQ(10u, Encode(std::numeric_limits<uint64_t>::max() - 1, buffer_));
EXPECT_EQ(
std::memcmp("\xfe\xff\xff\xff\xff\xff\xff\xff\xff\x01", buffer_, 10), 0);
- ASSERT_EQ(10u, EncodeVarint(std::numeric_limits<uint64_t>::max(), buffer_));
+ ASSERT_EQ(10u, Encode(std::numeric_limits<uint64_t>::max(), buffer_));
EXPECT_EQ(
std::memcmp("\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01", buffer_, 10), 0);
}
TEST_F(Varint, EncodeSizeSigned64_SmallSingleByte) {
- ASSERT_EQ(1u, EncodeVarint(INT64_C(0), buffer_));
+ ASSERT_EQ(1u, Encode(INT64_C(0), buffer_));
EXPECT_EQ(std::byte{0}, buffer_[0]);
- ASSERT_EQ(1u, EncodeVarint(INT64_C(-1), buffer_));
+ ASSERT_EQ(1u, Encode(INT64_C(-1), buffer_));
EXPECT_EQ(std::byte{1}, buffer_[0]);
- ASSERT_EQ(1u, EncodeVarint(INT64_C(1), buffer_));
+ ASSERT_EQ(1u, Encode(INT64_C(1), buffer_));
EXPECT_EQ(std::byte{2}, buffer_[0]);
- ASSERT_EQ(1u, EncodeVarint(INT64_C(-2), buffer_));
+ ASSERT_EQ(1u, Encode(INT64_C(-2), buffer_));
EXPECT_EQ(std::byte{3}, buffer_[0]);
- ASSERT_EQ(1u, EncodeVarint(INT64_C(2), buffer_));
+ ASSERT_EQ(1u, Encode(INT64_C(2), buffer_));
EXPECT_EQ(std::byte{4}, buffer_[0]);
}
TEST_F(Varint, EncodeSizeSigned64_LargeSingleByte) {
- ASSERT_EQ(1u, EncodeVarint(INT64_C(-63), buffer_));
+ ASSERT_EQ(1u, Encode(INT64_C(-63), buffer_));
EXPECT_EQ(std::byte{125}, buffer_[0]);
- ASSERT_EQ(1u, EncodeVarint(INT64_C(63), buffer_));
+ ASSERT_EQ(1u, Encode(INT64_C(63), buffer_));
EXPECT_EQ(std::byte{126}, buffer_[0]);
- ASSERT_EQ(1u, EncodeVarint(INT64_C(-64), buffer_));
+ ASSERT_EQ(1u, Encode(INT64_C(-64), buffer_));
EXPECT_EQ(std::byte{127}, buffer_[0]);
}
TEST_F(Varint, EncodeSizeSigned64_MultiByte) {
- ASSERT_EQ(2u, EncodeVarint(INT64_C(64), buffer_));
+ ASSERT_EQ(2u, Encode(INT64_C(64), buffer_));
EXPECT_EQ(std::memcmp("\x80\x01", buffer_, 2), 0);
- ASSERT_EQ(2u, EncodeVarint(INT64_C(-65), buffer_));
+ ASSERT_EQ(2u, Encode(INT64_C(-65), buffer_));
EXPECT_EQ(std::memcmp("\x81\x01", buffer_, 2), 0);
- ASSERT_EQ(2u, EncodeVarint(INT64_C(65), buffer_));
+ ASSERT_EQ(2u, Encode(INT64_C(65), buffer_));
EXPECT_EQ(std::memcmp("\x82\x01", buffer_, 2), 0);
- ASSERT_EQ(
- 5u,
- EncodeVarint(static_cast<int64_t>(std::numeric_limits<int32_t>::min()),
+ ASSERT_EQ(5u,
+ Encode(static_cast<int64_t>(std::numeric_limits<int32_t>::min()),
buffer_));
EXPECT_EQ(std::memcmp("\xff\xff\xff\xff\x0f", buffer_, 5), 0);
- ASSERT_EQ(
- 5u,
- EncodeVarint(static_cast<int64_t>(std::numeric_limits<int32_t>::max()),
+ ASSERT_EQ(5u,
+ Encode(static_cast<int64_t>(std::numeric_limits<int32_t>::max()),
buffer_));
EXPECT_EQ(std::memcmp("\xfe\xff\xff\xff\x0f", buffer_, 5), 0);
- ASSERT_EQ(10u, EncodeVarint(std::numeric_limits<int64_t>::min(), buffer_));
+ ASSERT_EQ(10u, Encode(std::numeric_limits<int64_t>::min(), buffer_));
EXPECT_EQ(
std::memcmp("\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01", buffer_, 10), 0);
- ASSERT_EQ(10u, EncodeVarint(std::numeric_limits<int64_t>::max(), buffer_));
+ ASSERT_EQ(10u, Encode(std::numeric_limits<int64_t>::max(), buffer_));
EXPECT_EQ(
std::memcmp("\xfe\xff\xff\xff\xff\xff\xff\xff\xff\x01", buffer_, 10), 0);
}
@@ -211,10 +206,10 @@
int32_t i = std::numeric_limits<int32_t>::min();
while (true) {
- size_t encoded = EncodeVarint(i, buffer_);
+ size_t encoded = Encode(i, buffer_);
int64_t result;
- size_t decoded = DecodeVarint(buffer_, &result);
+ size_t decoded = Decode(buffer_, &result);
EXPECT_EQ(encoded, decoded);
ASSERT_EQ(i, result);
@@ -233,10 +228,10 @@
uint32_t i = 0;
while (true) {
- size_t encoded = EncodeVarint(i, buffer_);
+ size_t encoded = Encode(i, buffer_);
uint64_t result;
- size_t decoded = DecodeVarint(buffer_, &result);
+ size_t decoded = Decode(buffer_, &result);
EXPECT_EQ(encoded, decoded);
ASSERT_EQ(i, result);
@@ -262,51 +257,51 @@
TEST(VarintDecode, DecodeSigned64_SingleByte) {
int64_t value = -1234;
- EXPECT_EQ(DecodeVarint(MakeBuffer("\x00"), &value), 1u);
+ EXPECT_EQ(Decode(MakeBuffer("\x00"), &value), 1u);
EXPECT_EQ(value, 0);
- EXPECT_EQ(DecodeVarint(MakeBuffer("\x01"), &value), 1u);
+ EXPECT_EQ(Decode(MakeBuffer("\x01"), &value), 1u);
EXPECT_EQ(value, -1);
- EXPECT_EQ(DecodeVarint(MakeBuffer("\x02"), &value), 1u);
+ EXPECT_EQ(Decode(MakeBuffer("\x02"), &value), 1u);
EXPECT_EQ(value, 1);
- EXPECT_EQ(DecodeVarint(MakeBuffer("\x03"), &value), 1u);
+ EXPECT_EQ(Decode(MakeBuffer("\x03"), &value), 1u);
EXPECT_EQ(value, -2);
- EXPECT_EQ(DecodeVarint(MakeBuffer("\x04"), &value), 1u);
+ EXPECT_EQ(Decode(MakeBuffer("\x04"), &value), 1u);
EXPECT_EQ(value, 2);
- EXPECT_EQ(DecodeVarint(MakeBuffer("\x04"), &value), 1u);
+ EXPECT_EQ(Decode(MakeBuffer("\x04"), &value), 1u);
EXPECT_EQ(value, 2);
}
TEST(VarintDecode, DecodeSigned64_MultiByte) {
int64_t value = -1234;
- EXPECT_EQ(DecodeVarint(MakeBuffer("\x80\x01"), &value), 2u);
+ EXPECT_EQ(Decode(MakeBuffer("\x80\x01"), &value), 2u);
EXPECT_EQ(value, 64);
- EXPECT_EQ(DecodeVarint(MakeBuffer("\x81\x01"), &value), 2u);
+ EXPECT_EQ(Decode(MakeBuffer("\x81\x01"), &value), 2u);
EXPECT_EQ(value, -65);
- EXPECT_EQ(DecodeVarint(MakeBuffer("\x82\x01"), &value), 2u);
+ EXPECT_EQ(Decode(MakeBuffer("\x82\x01"), &value), 2u);
EXPECT_EQ(value, 65);
- EXPECT_EQ(DecodeVarint(MakeBuffer("\xff\xff\xff\xff\x0f"), &value), 5u);
+ EXPECT_EQ(Decode(MakeBuffer("\xff\xff\xff\xff\x0f"), &value), 5u);
EXPECT_EQ(value, std::numeric_limits<int32_t>::min());
- EXPECT_EQ(DecodeVarint(MakeBuffer("\xfe\xff\xff\xff\x0f"), &value), 5u);
+ EXPECT_EQ(Decode(MakeBuffer("\xfe\xff\xff\xff\x0f"), &value), 5u);
EXPECT_EQ(value, std::numeric_limits<int32_t>::max());
- EXPECT_EQ(DecodeVarint(MakeBuffer("\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01"),
- &value),
- 10u);
+ EXPECT_EQ(
+ Decode(MakeBuffer("\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01"), &value),
+ 10u);
EXPECT_EQ(value, std::numeric_limits<int64_t>::min());
- EXPECT_EQ(DecodeVarint(MakeBuffer("\xfe\xff\xff\xff\xff\xff\xff\xff\xff\x01"),
- &value),
- 10u);
+ EXPECT_EQ(
+ Decode(MakeBuffer("\xfe\xff\xff\xff\xff\xff\xff\xff\xff\x01"), &value),
+ 10u);
EXPECT_EQ(value, std::numeric_limits<int64_t>::max());
}