Kurt Sassenrath
1c7047e314
msgpack::map_view can be used to iterate, pair-wise, over a range of msgpack::token. It will immediately return if the first token is not a map, and will skip over nested map/arrays. Note for the future: It will be handy to be able to get the subspan corresponding to the nested map/array. Will think about how to solve that later. Begin incorporating map_view into the server. Add formatters for std::byte, dynamic theme for bool, and spans thereof. Maybe switch to range?
99 lines
3.0 KiB
C++
99 lines
3.0 KiB
C++
#ifndef msgpack_test_utils_4573e6627d8efe78
|
|
#define msgpack_test_utils_4573e6627d8efe78
|
|
|
|
#include <boost/ut.hpp>
|
|
#include <fmt/format.h>
|
|
#include <magic_enum.hpp>
|
|
|
|
template <typename T>
|
|
constexpr bool operator==(std::span<T const> a, std::span<T const> b) noexcept {
|
|
return std::equal(a.begin(), a.end(), b.begin(), b.end());
|
|
}
|
|
|
|
template <typename T>
|
|
constexpr std::array<std::byte, sizeof(T)> as_bytes(T&& t) {
|
|
return std::bit_cast<std::array<std::byte, sizeof(T)>>(std::forward<T>(t));
|
|
}
|
|
|
|
template <typename... Bytes>
|
|
constexpr std::array<std::byte, sizeof...(Bytes)> make_bytes(Bytes &&...bytes) {
|
|
return {std::byte(std::forward<Bytes>(bytes))...};
|
|
}
|
|
|
|
template <typename T, std::size_t C = 1024 * 1024> struct oversized_array {
|
|
std::array<T, C> data;
|
|
std::size_t size;
|
|
};
|
|
|
|
constexpr auto to_bytes_array_oversized(auto const &container) {
|
|
using value_type = std::decay_t<decltype(container[0])>;
|
|
oversized_array<value_type> arr;
|
|
std::copy(std::begin(container), std::end(container), std::begin(arr.data));
|
|
arr.size = std::distance(std::begin(container), std::end(container));
|
|
return arr;
|
|
}
|
|
|
|
consteval auto generate_bytes(auto callable) {
|
|
constexpr auto oversized = to_bytes_array_oversized(callable());
|
|
using value_type = std::decay_t<decltype(oversized.data[0])>;
|
|
std::array<value_type, oversized.size> out;
|
|
std::copy(std::begin(oversized.data),
|
|
std::next(std::begin(oversized.data), oversized.size),
|
|
std::begin(out));
|
|
return out;
|
|
}
|
|
|
|
consteval auto build_string(auto callable) {
|
|
constexpr auto string_array = generate_bytes(callable);
|
|
return string_array;
|
|
}
|
|
|
|
template <std::size_t ... Sizes>
|
|
constexpr auto cat(std::array<std::byte, Sizes>const&... a) noexcept {
|
|
std::array<std::byte, (Sizes + ...)> out;
|
|
std::size_t index{};
|
|
((std::copy_n(a.begin(), Sizes, out.begin() + index), index += Sizes), ...);
|
|
return out;
|
|
}
|
|
|
|
constexpr auto repeat(std::span<std::byte const> sv, std::size_t count) {
|
|
std::vector<std::byte> range;
|
|
range.reserve(sv.size() * count);
|
|
for (decltype(count) i = 0; i < count; ++i) {
|
|
std::copy_n(sv.begin(), sv.size(), std::back_inserter(range));
|
|
}
|
|
return range;
|
|
}
|
|
|
|
constexpr auto repeat(std::string_view sv, std::size_t count) {
|
|
std::vector<char> range;
|
|
range.reserve(sv.size() * count);
|
|
for (decltype(count) i = 0; i < count; ++i) {
|
|
std::copy_n(sv.begin(), sv.size(), std::back_inserter(range));
|
|
}
|
|
return range;
|
|
}
|
|
|
|
constexpr auto from_string_view(std::string_view sv) {
|
|
std::vector<std::byte> range;
|
|
range.resize(sv.size());
|
|
auto itr = range.begin();
|
|
for (auto c : sv) {
|
|
*itr = std::byte(c);
|
|
++itr;
|
|
}
|
|
return range;
|
|
}
|
|
|
|
template <typename T, typename E>
|
|
std::ostream &operator<<(std::ostream &os, tl::expected<T, E> const &exp) {
|
|
if (exp.has_value()) {
|
|
os << "Value: '" << *exp << "'";
|
|
} else {
|
|
os << "Error";
|
|
}
|
|
return os;
|
|
}
|
|
|
|
#endif // msgpack_test_utils_4573e6627d8efe78
|