numeric/str: Add constexpr int encode
This makes it possible to quickly convert numbers to strings in
constexpr contexts.
Change-Id: I5a460feacf97c80761d02a3b07f5b22080401b45
Signed-off-by: William A. Kennington III <wak@google.com>
diff --git a/include/meson.build b/include/meson.build
index 979478e..56f9c8e 100644
--- a/include/meson.build
+++ b/include/meson.build
@@ -13,6 +13,7 @@
'stdplus/net/addr/ip.hpp',
'stdplus/net/addr/subnet.hpp',
'stdplus/numeric/endian.hpp',
+ 'stdplus/numeric/str.hpp',
'stdplus/pinned.hpp',
'stdplus/raw.hpp',
'stdplus/signal.hpp',
diff --git a/include/stdplus/numeric/str.hpp b/include/stdplus/numeric/str.hpp
new file mode 100644
index 0000000..ee80905
--- /dev/null
+++ b/include/stdplus/numeric/str.hpp
@@ -0,0 +1,111 @@
+#pragma once
+#include <stdplus/str/conv.hpp>
+
+#include <algorithm>
+#include <array>
+#include <bit>
+#include <concepts>
+#include <cstdint>
+#include <limits>
+#include <string>
+#include <type_traits>
+
+namespace stdplus
+{
+
+namespace detail
+{
+
+inline constexpr auto maxBase = 36;
+
+inline constexpr auto singleIntTable = []() {
+ std::array<char, maxBase> ret;
+ for (int8_t i = 0; i < 10; ++i)
+ {
+ ret[i] = i + '0';
+ }
+ for (int8_t i = 0; i < 26; ++i)
+ {
+ ret[i + 10] = i + 'a';
+ }
+ static_assert(maxBase == 36);
+ return ret;
+}();
+
+template <uint8_t base, typename T, typename CharT>
+constexpr CharT* uintToStr(CharT* buf, T v, uint8_t min_width) noexcept
+{
+ static_assert(std::is_unsigned_v<T>);
+ uint8_t i = 0;
+ do
+ {
+ if constexpr (std::popcount(base) == 1)
+ {
+ constexpr auto shift = std::countr_zero(base);
+ constexpr auto mask = (1 << shift) - 1;
+ buf[i] = detail::singleIntTable[v & mask];
+ v >>= shift;
+ }
+ else
+ {
+ buf[i] = detail::singleIntTable[v % base];
+ v /= base;
+ }
+ i += 1;
+ } while (v > 0);
+ auto end = buf + std::max(i, min_width);
+ std::fill(buf + i, end, '0');
+ std::reverse(buf, end);
+ return end;
+}
+
+template <uint8_t base, std::integral T, typename CharT>
+constexpr CharT* intToStr(CharT* buf, T v, uint8_t min_width) noexcept
+{
+ if constexpr (std::is_signed_v<T>)
+ {
+ if (v < 0)
+ {
+ *(buf++) = '-';
+ v = -v;
+ }
+ }
+ return uintToStr<base>(buf, std::make_unsigned_t<T>(v), min_width);
+}
+
+} // namespace detail
+
+template <uint8_t base, std::integral T>
+struct IntToStr
+{
+ static_assert(base > 1 && base <= detail::maxBase);
+
+ static inline constexpr size_t buf_size = []() {
+ T v = std::numeric_limits<T>::max();
+ uint8_t i = 0;
+ for (; v != 0; ++i)
+ {
+ v /= base;
+ }
+ return i + std::is_signed_v<T>;
+ }();
+
+ template <typename CharT>
+ constexpr CharT* operator()(CharT* buf, T v,
+ uint8_t min_width = 0) const noexcept
+ {
+ using ptr_t =
+ std::conditional_t<std::is_signed_v<T>, intptr_t, uintptr_t>;
+ return detail::intToStr<
+ base, std::conditional_t<sizeof(T) <= sizeof(ptr_t), ptr_t, T>>(
+ buf, v, min_width);
+ }
+};
+
+template <std::integral T>
+struct ToStr<T> : IntToStr<10, T>
+{
+ using type = T;
+};
+
+} // namespace stdplus
diff --git a/src/meson.build b/src/meson.build
index 93d68f3..6d17d3d 100644
--- a/src/meson.build
+++ b/src/meson.build
@@ -54,6 +54,7 @@
'net/addr/ip.cpp',
'net/addr/subnet.cpp',
'numeric/endian.cpp',
+ 'numeric/str.cpp',
'pinned.cpp',
'raw.cpp',
'signal.cpp',
diff --git a/src/numeric/str.cpp b/src/numeric/str.cpp
new file mode 100644
index 0000000..7c3ac13
--- /dev/null
+++ b/src/numeric/str.cpp
@@ -0,0 +1,7 @@
+#include <stdplus/numeric/str.hpp>
+
+namespace stdplus::detail
+{
+template char* uintToStr<16>(char*, uintptr_t, uint8_t) noexcept;
+template char* uintToStr<10>(char*, uintptr_t, uint8_t) noexcept;
+} // namespace stdplus::detail
diff --git a/test/meson.build b/test/meson.build
index 1239296..fd62657 100644
--- a/test/meson.build
+++ b/test/meson.build
@@ -10,6 +10,7 @@
'net/addr/ip': [stdplus_dep, gtest_main_dep],
'net/addr/subnet': [stdplus_dep, gtest_main_dep],
'numeric/endian': [stdplus_dep, gtest_main_dep],
+ 'numeric/str': [stdplus_dep, gtest_main_dep],
'pinned': [stdplus_dep, gtest_main_dep],
'raw': [stdplus_dep, gmock_dep, gtest_main_dep],
'signal': [stdplus_dep, gtest_main_dep],
diff --git a/test/numeric/str.cpp b/test/numeric/str.cpp
new file mode 100644
index 0000000..5646045
--- /dev/null
+++ b/test/numeric/str.cpp
@@ -0,0 +1,103 @@
+#include <stdplus/numeric/str.hpp>
+
+#include <string_view>
+
+#include <gtest/gtest.h>
+
+namespace stdplus
+{
+
+TEST(IntToStr, Uint8_10)
+{
+ IntToStr<10, uint8_t> enc;
+ static_assert(enc.buf_size == 3);
+ char buf[enc.buf_size];
+ EXPECT_EQ("0", std::string_view(buf, enc(buf, 0)));
+ EXPECT_EQ("42", std::string_view(buf, enc(buf, 42)));
+ EXPECT_EQ("255", std::string_view(buf, enc(buf, 255)));
+ EXPECT_EQ("000", std::string_view(buf, enc(buf, 0, 3)));
+ EXPECT_EQ("255", std::string_view(buf, enc(buf, 255, 3)));
+}
+
+TEST(IntToStr, Int8_10)
+{
+ IntToStr<10, int8_t> enc;
+ static_assert(enc.buf_size == 4);
+ char buf[enc.buf_size];
+ EXPECT_EQ("42", std::string_view(buf, enc(buf, 42)));
+ EXPECT_EQ("-127", std::string_view(buf, enc(buf, -127)));
+}
+
+TEST(IntToStr, Uint16_10)
+{
+ IntToStr<10, uint16_t> enc;
+ static_assert(enc.buf_size == 5);
+ char buf[enc.buf_size];
+ EXPECT_EQ("55255", std::string_view(buf, enc(buf, 55255, 3)));
+}
+
+TEST(IntToStr, Uint32_10)
+{
+ IntToStr<10, uint32_t> enc;
+ static_assert(enc.buf_size == 10);
+ char buf[enc.buf_size];
+ EXPECT_EQ("55255", std::string_view(buf, enc(buf, 55255, 3)));
+ EXPECT_EQ("055255", std::string_view(buf, enc(buf, 55255, 6)));
+ EXPECT_EQ("255255", std::string_view(buf, enc(buf, 255255, 3)));
+}
+
+TEST(IntToStr, Uint8_16)
+{
+ IntToStr<16, uint8_t> enc;
+ static_assert(enc.buf_size == 2);
+ char buf[enc.buf_size];
+ EXPECT_EQ("0", std::string_view(buf, enc(buf, 0)));
+ EXPECT_EQ("2a", std::string_view(buf, enc(buf, 42)));
+ EXPECT_EQ("ff", std::string_view(buf, enc(buf, 255)));
+ EXPECT_EQ("00", std::string_view(buf, enc(buf, 0, 2)));
+ EXPECT_EQ("02", std::string_view(buf, enc(buf, 2, 2)));
+ EXPECT_EQ("ff", std::string_view(buf, enc(buf, 255, 2)));
+}
+
+TEST(IntToStr, Uint8_8)
+{
+ IntToStr<8, uint8_t> enc;
+ static_assert(enc.buf_size == 3);
+ char buf[enc.buf_size];
+ EXPECT_EQ("0", std::string_view(buf, enc(buf, 0)));
+ EXPECT_EQ("7", std::string_view(buf, enc(buf, 7)));
+ EXPECT_EQ("10", std::string_view(buf, enc(buf, 8)));
+ EXPECT_EQ("377", std::string_view(buf, enc(buf, 255)));
+}
+
+TEST(IntToStr, Uint8_11)
+{
+ IntToStr<11, uint8_t> enc;
+ static_assert(enc.buf_size == 3);
+ char buf[enc.buf_size];
+ EXPECT_EQ("0", std::string_view(buf, enc(buf, 0)));
+ EXPECT_EQ("39", std::string_view(buf, enc(buf, 42)));
+ EXPECT_EQ("212", std::string_view(buf, enc(buf, 255)));
+}
+
+TEST(ToString, Int)
+{
+ EXPECT_EQ("10", stdplus::toStr(size_t{10}));
+ EXPECT_EQ(L"10", stdplus::toBasicStr<wchar_t>(size_t{10}));
+ EXPECT_EQ("-10", stdplus::toStr(ssize_t{-10}));
+ EXPECT_EQ(L"-10", stdplus::toBasicStr<wchar_t>(ssize_t{-10}));
+}
+
+TEST(ToString, perf)
+{
+ GTEST_SKIP();
+ IntToStr<16, size_t> enc;
+ char buf[enc.buf_size];
+ for (size_t i = 0; i < 100000000; ++i)
+ {
+ enc(buf, i);
+ }
+ EXPECT_TRUE(false);
+}
+
+} // namespace stdplus