C++17 changes; replace mapbox with std::variant

Various small C++17 code improvements.

Replace mapbox::variant with std::variant.

Remove the bt_u64 type wrapper; instead we know have `bt_value` which
wraps a variant holding both int64_t and uint64_t, and has contructors
to send signed/unsigned integer types into the appropriate one.
lokimq::get_int checks both as appropriate during extraction.

As a side effect this means we no longer do the uint64_t -> int64_t
conversion on the wire, ever, without needing the wrapper; although this
can break older versions sending large positive integers (i.e. larger
than int64_t max) those weren't actually working completely reliably
with mapbox variant anyway, and the one place using such a value in loki
core (in a checksum) is already fully upgraded across the network
(currently using bt_u64, but always sending a positive value on the
wire).
This commit is contained in:
Jason Rhinelander 2020-05-14 20:08:34 -03:00
parent 1479a030d7
commit 68c1899cda
9 changed files with 122 additions and 174 deletions

3
.gitmodules vendored
View File

@ -1,6 +1,3 @@
[submodule "mapbox-variant"]
path = mapbox-variant
url = https://github.com/mapbox/variant.git
[submodule "cppzmq"] [submodule "cppzmq"]
path = cppzmq path = cppzmq
url = https://github.com/zeromq/cppzmq.git url = https://github.com/zeromq/cppzmq.git

View File

@ -78,7 +78,6 @@ target_include_directories(lokimq
$<INSTALL_INTERFACE:> $<INSTALL_INTERFACE:>
$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}> $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>
$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/cppzmq> $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/cppzmq>
$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/mapbox-variant/include>
) )
target_compile_options(lokimq PRIVATE -Wall -Wextra -Werror) target_compile_options(lokimq PRIVATE -Wall -Wextra -Werror)
@ -149,17 +148,6 @@ install(
${CMAKE_CURRENT_BINARY_DIR}/lokimq/version.h ${CMAKE_CURRENT_BINARY_DIR}/lokimq/version.h
DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/lokimq DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/lokimq
) )
option(LOKIMQ_INSTALL_MAPBOX_VARIANT "Install mapbox-variant headers with lokimq/ headers" ON)
if(LOKIMQ_INSTALL_MAPBOX_VARIANT)
install(
FILES mapbox-variant/include/mapbox/variant.hpp
mapbox-variant/include/mapbox/variant_cast.hpp
mapbox-variant/include/mapbox/variant_io.hpp
mapbox-variant/include/mapbox/variant_visitor.hpp
mapbox-variant/include/mapbox/recursive_wrapper.hpp
DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/lokimq/mapbox
)
endif()
option(LOKIMQ_INSTALL_CPPZMQ "Install cppzmq header with lokimq/ headers" ON) option(LOKIMQ_INSTALL_CPPZMQ "Install cppzmq header with lokimq/ headers" ON)
if(LOKIMQ_INSTALL_CPPZMQ) if(LOKIMQ_INSTALL_CPPZMQ)

View File

@ -3,6 +3,7 @@
#include "base32z.h" #include "base32z.h"
#include "base64.h" #include "base64.h"
#include <tuple> #include <tuple>
#include <limits>
namespace lokimq { namespace lokimq {

View File

@ -72,30 +72,26 @@ static_assert(std::numeric_limits<int64_t>::min() + std::numeric_limits<int64_t>
static_cast<uint64_t>(std::numeric_limits<int64_t>::max()) + uint64_t{1} == (uint64_t{1} << 63), static_cast<uint64_t>(std::numeric_limits<int64_t>::max()) + uint64_t{1} == (uint64_t{1} << 63),
"Non 2s-complement architecture not supported!"); "Non 2s-complement architecture not supported!");
std::pair<maybe_signed_int64_t, bool> bt_deserialize_integer(std::string_view& s) { std::pair<uint64_t, bool> bt_deserialize_integer(std::string_view& s) {
// Smallest possible encoded integer is 3 chars: "i0e" // Smallest possible encoded integer is 3 chars: "i0e"
if (s.size() < 3) throw bt_deserialize_invalid("Deserialization failed: end of string found where integer expected"); if (s.size() < 3) throw bt_deserialize_invalid("Deserialization failed: end of string found where integer expected");
if (s[0] != 'i') throw bt_deserialize_invalid_type("Deserialization failed: expected 'i', found '"s + s[0] + '\''); if (s[0] != 'i') throw bt_deserialize_invalid_type("Deserialization failed: expected 'i', found '"s + s[0] + '\'');
s.remove_prefix(1); s.remove_prefix(1);
std::pair<maybe_signed_int64_t, bool> result; std::pair<uint64_t, bool> result;
if (s[0] == '-') { if (s[0] == '-') {
result.second = true; result.second = true;
s.remove_prefix(1); s.remove_prefix(1);
} }
uint64_t uval = extract_unsigned(s); result.first = extract_unsigned(s);
if (s.empty()) if (s.empty())
throw bt_deserialize_invalid("Integer deserialization failed: encountered end of string before integer was finished"); throw bt_deserialize_invalid("Integer deserialization failed: encountered end of string before integer was finished");
if (s[0] != 'e') if (s[0] != 'e')
throw bt_deserialize_invalid("Integer deserialization failed: expected digit or 'e', found '"s + s[0] + '\''); throw bt_deserialize_invalid("Integer deserialization failed: expected digit or 'e', found '"s + s[0] + '\'');
s.remove_prefix(1); s.remove_prefix(1);
if (result.second) { // negative if (result.second /*negative*/ && result.first > (uint64_t{1} << 63))
if (uval > (uint64_t{1} << 63)) throw bt_deserialize_invalid("Deserialization of integer failed: negative integer value is too large for a 64-bit signed int");
throw bt_deserialize_invalid("Deserialization of integer failed: negative integer value is too large for a 64-bit signed int");
result.first.i64 = -uval;
} else {
result.first.u64 = uval;
}
return result; return result;
} }
@ -119,8 +115,9 @@ void bt_deserialize<bt_value, void>::operator()(std::string_view& s, bt_value& v
break; break;
} }
case 'i': { case 'i': {
auto read = bt_deserialize_integer(s); auto [magnitude, negative] = bt_deserialize_integer(s);
val = read.first.i64; // We only store an i64, but can get a u64 out of it via get<uint64_t>(val) if (negative) val = -static_cast<int64_t>(magnitude);
else val = magnitude;
break; break;
} }
case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': { case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': {

View File

@ -26,22 +26,18 @@
// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF // STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. // THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include <iostream>
#pragma once #pragma once
#include <vector> #include <vector>
#include <list>
#include <unordered_map>
#include <algorithm> #include <algorithm>
#include <functional> #include <functional>
#include <cstring> #include <cstring>
#include <ostream> #include <ostream>
#include <sstream> #include <sstream>
#include <string_view> #include <string_view>
#include "mapbox/variant.hpp"
#include <variant> #include <variant>
#include "bt_value.h"
namespace lokimq { namespace lokimq {
@ -55,16 +51,17 @@ using namespace std::literals;
* *
* On the C++ side, on input we allow strings, integral types, STL-like containers of these types, * On the C++ side, on input we allow strings, integral types, STL-like containers of these types,
* and STL-like containers of pairs with a string first value and any of these types as second * and STL-like containers of pairs with a string first value and any of these types as second
* value. We also accept std::variants (if compiled with std::variant support, i.e. in C++17 mode) * value. We also accept std::variants of these.
* that contain any of these, and mapbox::util::variants (the internal type used for its recursive
* support).
* *
* One minor deviation from BEP-0003 is that we don't support serializing values that don't fit in a * One minor deviation from BEP-0003 is that we don't support serializing values that don't fit in a
* 64-bit integer (BEP-0003 specifies arbitrary precision integers). * 64-bit integer (BEP-0003 specifies arbitrary precision integers).
* *
* On deserialization we can either deserialize into a mapbox::util::variant that supports everything, or * On deserialization we can either deserialize into a special bt_value type supports everything
* we can fill a container of your given type (though this fails if the container isn't compatible * (with arbitrary nesting), or we can fill a container of your given type (though this fails if the
* with the deserialized data). * container isn't compatible with the deserialized data).
*
* There is also a stream deserialization that allows you to deserialize without needing heap
* allocations (as long as you know the precise data structure layout).
*/ */
/// Exception throw if deserialization fails /// Exception throw if deserialization fails
@ -81,36 +78,6 @@ class bt_deserialize_invalid_type : public bt_deserialize_invalid {
using bt_deserialize_invalid::bt_deserialize_invalid; using bt_deserialize_invalid::bt_deserialize_invalid;
}; };
class bt_list;
class bt_dict;
/// Special type wrapper for storing a uint64_t value that may need to be larger than an int64_t.
/// You *can* shove a uint64_t directly into a bt_value, but it will end up on the wire as its
/// 2s-complement int64_t value; using this wrapper instead allows you to force a 64-bit positive
/// integer onto the wire.
struct bt_u64 { uint64_t val; explicit bt_u64(uint64_t val) : val{val} {} };
/// Recursive generic type that can fully represent everything valid for a BT serialization.
using bt_value = mapbox::util::variant<
std::string,
std::string_view,
int64_t,
bt_u64,
mapbox::util::recursive_wrapper<bt_list>,
mapbox::util::recursive_wrapper<bt_dict>
>;
/// Very thin wrapper around a std::list<bt_value> that holds a list of generic values (though *any*
/// compatible data type can be used).
class bt_list : public std::list<bt_value> {
using std::list<bt_value>::list;
};
/// Very thin wrapper around a std::unordered_map<bt_value> that holds a list of string -> generic
/// value pairs (though *any* compatible data type can be used).
class bt_dict : public std::unordered_map<std::string, bt_value> {
using std::unordered_map<std::string, bt_value>::unordered_map;
};
namespace detail { namespace detail {
/// Reads digits into an unsigned 64-bit int. /// Reads digits into an unsigned 64-bit int.
@ -121,10 +88,10 @@ inline uint64_t extract_unsigned(std::string_view&& s) { return extract_unsigned
// Fallback base case; we only get here if none of the partial specializations below work // Fallback base case; we only get here if none of the partial specializations below work
template <typename T, typename SFINAE = void> template <typename T, typename SFINAE = void>
struct bt_serialize { static_assert(!std::is_same<T, T>::value, "Cannot serialize T: unsupported type for bt serialization"); }; struct bt_serialize { static_assert(!std::is_same_v<T, T>, "Cannot serialize T: unsupported type for bt serialization"); };
template <typename T, typename SFINAE = void> template <typename T, typename SFINAE = void>
struct bt_deserialize { static_assert(!std::is_same<T, T>::value, "Cannot deserialize T: unsupported type for bt deserialization"); }; struct bt_deserialize { static_assert(!std::is_same_v<T, T>, "Cannot deserialize T: unsupported type for bt deserialization"); };
/// Checks that we aren't at the end of a string view and throws if we are. /// Checks that we aren't at the end of a string view and throws if we are.
inline void bt_need_more(const std::string_view &s) { inline void bt_need_more(const std::string_view &s) {
@ -132,50 +99,48 @@ inline void bt_need_more(const std::string_view &s) {
throw bt_deserialize_invalid{"Unexpected end of string while deserializing"}; throw bt_deserialize_invalid{"Unexpected end of string while deserializing"};
} }
union maybe_signed_int64_t { int64_t i64; uint64_t u64; };
/// Deserializes a signed or unsigned 64-bit integer from a string. Sets the second bool to true /// Deserializes a signed or unsigned 64-bit integer from a string. Sets the second bool to true
/// iff the value is int64_t because a negative value was read. Throws an exception if the read /// iff the value read was negative, false if positive; in either case the unsigned value is return
/// value doesn't fit in a int64_t (if negative) or a uint64_t (if positive). Removes consumed /// in .first. Throws an exception if the read value doesn't fit in a int64_t (if negative) or a
/// characters from the string_view. /// uint64_t (if positive). Removes consumed characters from the string_view.
std::pair<maybe_signed_int64_t, bool> bt_deserialize_integer(std::string_view& s); std::pair<uint64_t, bool> bt_deserialize_integer(std::string_view& s);
/// Integer specializations /// Integer specializations
template <typename T> template <typename T>
struct bt_serialize<T, std::enable_if_t<std::is_integral<T>::value>> { struct bt_serialize<T, std::enable_if_t<std::is_integral_v<T>>> {
static_assert(sizeof(T) <= sizeof(uint64_t), "Serialization of integers larger than uint64_t is not supported"); static_assert(sizeof(T) <= sizeof(uint64_t), "Serialization of integers larger than uint64_t is not supported");
void operator()(std::ostream &os, const T &val) { void operator()(std::ostream &os, const T &val) {
// Cast 1-byte types to a larger type to avoid iostream interpreting them as single characters // Cast 1-byte types to a larger type to avoid iostream interpreting them as single characters
using output_type = std::conditional_t<(sizeof(T) > 1), T, std::conditional_t<std::is_signed<T>::value, int, unsigned>>; using output_type = std::conditional_t<(sizeof(T) > 1), T, std::conditional_t<std::is_signed_v<T>, int, unsigned>>;
os << 'i' << static_cast<output_type>(val) << 'e'; os << 'i' << static_cast<output_type>(val) << 'e';
} }
}; };
template <typename T> template <typename T>
struct bt_deserialize<T, std::enable_if_t<std::is_integral<T>::value>> { struct bt_deserialize<T, std::enable_if_t<std::is_integral_v<T>>> {
void operator()(std::string_view& s, T &val) { void operator()(std::string_view& s, T &val) {
constexpr uint64_t umax = static_cast<uint64_t>(std::numeric_limits<T>::max()); constexpr uint64_t umax = static_cast<uint64_t>(std::numeric_limits<T>::max());
constexpr int64_t smin = static_cast<int64_t>(std::numeric_limits<T>::min()), constexpr int64_t smin = static_cast<int64_t>(std::numeric_limits<T>::min());
smax = static_cast<int64_t>(std::numeric_limits<T>::max());
auto read = bt_deserialize_integer(s); auto [magnitude, negative] = bt_deserialize_integer(s);
if (std::is_signed<T>::value) {
if (!read.second) { // read a positive value if (std::is_signed_v<T>) {
if (read.first.u64 > umax) if (!negative) {
throw bt_deserialize_invalid("Integer deserialization failed: found too-large value " + std::to_string(read.first.u64) + " > " + std::to_string(umax)); if (magnitude > umax)
val = static_cast<T>(read.first.u64); throw bt_deserialize_invalid("Integer deserialization failed: found too-large value " + std::to_string(magnitude) + " > " + std::to_string(umax));
val = static_cast<T>(magnitude);
} else { } else {
bool oob = read.first.i64 < smin || read.first.i64 > smax; auto sval = -static_cast<int64_t>(magnitude);
if (sizeof(T) < sizeof(int64_t) && oob) if (!std::is_same_v<T, int64_t> && sval < smin)
throw bt_deserialize_invalid("Integer deserialization failed: found out-of-range value " + std::to_string(read.first.i64) + " not in [" + std::to_string(smin) + "," + std::to_string(smax) + "]"); throw bt_deserialize_invalid("Integer deserialization failed: found too-low value " + std::to_string(sval) + " < " + std::to_string(smin));
val = static_cast<T>(read.first.i64); val = static_cast<T>(sval);
} }
} else { } else {
if (read.second) if (negative)
throw bt_deserialize_invalid("Integer deserialization failed: found negative value " + std::to_string(read.first.i64) + " but type is unsigned"); throw bt_deserialize_invalid("Integer deserialization failed: found negative value -" + std::to_string(magnitude) + " but type is unsigned");
if (sizeof(T) < sizeof(uint64_t) && read.first.u64 > umax) if (!std::is_same_v<T, uint64_t> && magnitude > umax)
throw bt_deserialize_invalid("Integer deserialization failed: found too-large value " + std::to_string(read.first.u64) + " > " + std::to_string(umax)); throw bt_deserialize_invalid("Integer deserialization failed: found too-large value " + std::to_string(magnitude) + " > " + std::to_string(umax));
val = static_cast<T>(read.first.u64); val = static_cast<T>(magnitude);
} }
} }
}; };
@ -183,11 +148,6 @@ struct bt_deserialize<T, std::enable_if_t<std::is_integral<T>::value>> {
extern template struct bt_deserialize<int64_t>; extern template struct bt_deserialize<int64_t>;
extern template struct bt_deserialize<uint64_t>; extern template struct bt_deserialize<uint64_t>;
template<>
struct bt_serialize<bt_u64> { void operator()(std::ostream& os, bt_u64 val) { bt_serialize<uint64_t>{}(os, val.val); } };
template<>
struct bt_deserialize<bt_u64> { void operator()(std::string_view& s, bt_u64& val) { bt_deserialize<uint64_t>{}(s, val.val); } };
template <> template <>
struct bt_serialize<std::string_view> { struct bt_serialize<std::string_view> {
void operator()(std::ostream &os, const std::string_view &val) { os << val.size(); os.put(':'); os.write(val.data(), val.size()); } void operator()(std::ostream &os, const std::string_view &val) { os << val.size(); os.put(':'); os.write(val.data(), val.size()); }
@ -219,37 +179,47 @@ struct bt_serialize<char[N]> {
/// Partial dict validity; we don't check the second type for serializability, that will be handled /// Partial dict validity; we don't check the second type for serializability, that will be handled
/// via the base case static_assert if invalid. /// via the base case static_assert if invalid.
template <typename T, typename = void> struct is_bt_input_dict_container : std::false_type {}; template <typename T, typename = void> struct is_bt_input_dict_container_impl : std::false_type {};
template <typename T> template <typename T>
struct is_bt_input_dict_container<T, std::enable_if_t< struct is_bt_input_dict_container_impl<T, std::enable_if_t<
std::is_same<std::string, std::remove_cv_t<typename T::value_type::first_type>>::value, std::is_same_v<std::string, std::remove_cv_t<typename T::value_type::first_type>> ||
std::is_same_v<std::string_view, std::remove_cv_t<typename T::value_type::first_type>>,
std::void_t<typename T::const_iterator /* is const iterable */, std::void_t<typename T::const_iterator /* is const iterable */,
typename T::value_type::second_type /* has a second type */>>> typename T::value_type::second_type /* has a second type */>>>
: std::true_type {}; : std::true_type {};
/// Determines whether the type looks like something we can insert into (using `v.insert(v.end(), x)`) /// Determines whether the type looks like something we can insert into (using `v.insert(v.end(), x)`)
template <typename T, typename = void> struct is_bt_insertable : std::false_type {}; template <typename T, typename = void> struct is_bt_insertable_impl : std::false_type {};
template <typename T> template <typename T>
struct is_bt_insertable<T, struct is_bt_insertable_impl<T,
std::void_t<decltype(std::declval<T>().insert(std::declval<T>().end(), std::declval<typename T::value_type>()))>> std::void_t<decltype(std::declval<T>().insert(std::declval<T>().end(), std::declval<typename T::value_type>()))>>
: std::true_type {}; : std::true_type {};
template <typename T>
constexpr bool is_bt_insertable = is_bt_insertable_impl<T>::value;
/// Determines whether the given type looks like a compatible map (i.e. has std::string keys) that /// Determines whether the given type looks like a compatible map (i.e. has std::string keys) that
/// we can insert into. /// we can insert into.
template <typename T, typename = void> struct is_bt_output_dict_container : std::false_type {}; template <typename T, typename = void> struct is_bt_output_dict_container_impl : std::false_type {};
template <typename T> template <typename T>
struct is_bt_output_dict_container<T, std::enable_if_t< struct is_bt_output_dict_container_impl<T, std::enable_if_t<
std::is_same<std::string, std::remove_cv_t<typename T::key_type>>::value && std::is_same_v<std::string, std::remove_cv_t<typename T::value_type::first_type>> && is_bt_insertable<T>,
is_bt_insertable<T>::value,
std::void_t<typename T::value_type::second_type /* has a second type */>>> std::void_t<typename T::value_type::second_type /* has a second type */>>>
: std::true_type {}; : std::true_type {};
template <typename T>
constexpr bool is_bt_output_dict_container = is_bt_output_dict_container_impl<T>::value;
template <typename T>
constexpr bool is_bt_input_dict_container = is_bt_output_dict_container_impl<T>::value;
// Sanity checks:
static_assert(is_bt_input_dict_container<bt_dict>);
static_assert(is_bt_output_dict_container<bt_dict>);
/// Specialization for a dict-like container (such as an unordered_map). We accept anything for a /// Specialization for a dict-like container (such as an unordered_map). We accept anything for a
/// dict that is const iterable over something that looks like a pair with std::string for first /// dict that is const iterable over something that looks like a pair with std::string for first
/// value type. The value (i.e. second element of the pair) also must be serializable. /// value type. The value (i.e. second element of the pair) also must be serializable.
template <typename T> template <typename T>
struct bt_serialize<T, std::enable_if_t<is_bt_input_dict_container<T>::value>> { struct bt_serialize<T, std::enable_if_t<is_bt_input_dict_container<T>>> {
using second_type = typename T::value_type::second_type; using second_type = typename T::value_type::second_type;
using ref_pair = std::reference_wrapper<const typename T::value_type>; using ref_pair = std::reference_wrapper<const typename T::value_type>;
void operator()(std::ostream &os, const T &dict) { void operator()(std::ostream &os, const T &dict) {
@ -268,7 +238,7 @@ struct bt_serialize<T, std::enable_if_t<is_bt_input_dict_container<T>::value>> {
}; };
template <typename T> template <typename T>
struct bt_deserialize<T, std::enable_if_t<is_bt_output_dict_container<T>::value>> { struct bt_deserialize<T, std::enable_if_t<is_bt_output_dict_container<T>>> {
using second_type = typename T::value_type::second_type; using second_type = typename T::value_type::second_type;
void operator()(std::string_view& s, T& dict) { void operator()(std::string_view& s, T& dict) {
// Smallest dict is 2 bytes "de", for an empty dict. // Smallest dict is 2 bytes "de", for an empty dict.
@ -295,26 +265,31 @@ struct bt_deserialize<T, std::enable_if_t<is_bt_output_dict_container<T>::value>
/// Accept anything that looks iterable; value serialization validity isn't checked here (it fails /// Accept anything that looks iterable; value serialization validity isn't checked here (it fails
/// via the base case static assert). /// via the base case static assert).
template <typename T, typename = void> struct is_bt_input_list_container : std::false_type {}; template <typename T, typename = void> struct is_bt_input_list_container_impl : std::false_type {};
template <typename T> template <typename T>
struct is_bt_input_list_container<T, std::enable_if_t< struct is_bt_input_list_container_impl<T, std::enable_if_t<
!std::is_same<T, std::string>::value && !std::is_same_v<T, std::string> && !std::is_same_v<T, std::string_view> && !is_bt_input_dict_container<T>,
!is_bt_input_dict_container<T>::value,
std::void_t<typename T::const_iterator, typename T::value_type>>> std::void_t<typename T::const_iterator, typename T::value_type>>>
: std::true_type {}; : std::true_type {};
template <typename T, typename = void> struct is_bt_output_list_container : std::false_type {}; template <typename T, typename = void> struct is_bt_output_list_container_impl : std::false_type {};
template <typename T> template <typename T>
struct is_bt_output_list_container<T, std::enable_if_t< struct is_bt_output_list_container_impl<T, std::enable_if_t<
!std::is_same<T, std::string>::value && !std::is_same_v<T, std::string> && !is_bt_output_dict_container<T> && is_bt_insertable<T>>>
!is_bt_output_dict_container<T>::value &&
is_bt_insertable<T>::value>>
: std::true_type {}; : std::true_type {};
template <typename T>
constexpr bool is_bt_output_list_container = is_bt_output_list_container_impl<T>::value;
template <typename T>
constexpr bool is_bt_input_list_container = is_bt_input_list_container_impl<T>::value;
// Sanity checks:
static_assert(is_bt_input_list_container<bt_list>);
static_assert(is_bt_output_list_container<bt_list>);
/// List specialization /// List specialization
template <typename T> template <typename T>
struct bt_serialize<T, std::enable_if_t<is_bt_input_list_container<T>::value>> { struct bt_serialize<T, std::enable_if_t<is_bt_input_list_container<T>>> {
void operator()(std::ostream& os, const T& list) { void operator()(std::ostream& os, const T& list) {
os << 'l'; os << 'l';
for (const auto &v : list) for (const auto &v : list)
@ -323,7 +298,7 @@ struct bt_serialize<T, std::enable_if_t<is_bt_input_list_container<T>::value>> {
} }
}; };
template <typename T> template <typename T>
struct bt_deserialize<T, std::enable_if_t<is_bt_output_list_container<T>::value>> { struct bt_deserialize<T, std::enable_if_t<is_bt_output_list_container<T>>> {
using value_type = typename T::value_type; using value_type = typename T::value_type;
void operator()(std::string_view& s, T& list) { void operator()(std::string_view& s, T& list) {
// Smallest list is 2 bytes "le", for an empty list. // Smallest list is 2 bytes "le", for an empty list.
@ -355,9 +330,8 @@ public:
}; };
template <typename T> template <typename T>
using is_bt_deserializable = std::integral_constant<bool, constexpr bool is_bt_deserializable = std::is_same_v<T, std::string> || std::is_integral_v<T> ||
std::is_same<T, std::string>::value || std::is_integral<T>::value || is_bt_output_dict_container<T> || is_bt_output_list_container<T>;
is_bt_output_dict_container<T>::value || is_bt_output_list_container<T>::value>;
// General template and base case; this base will only actually be invoked when Ts... is empty, // General template and base case; this base will only actually be invoked when Ts... is empty,
// which means we reached the end without finding any variant type capable of holding the value. // which means we reached the end without finding any variant type capable of holding the value.
@ -375,12 +349,12 @@ void bt_deserialize_try_variant(std::string_view& s, Variant& variant) {
template <typename Variant, typename T, typename... Ts> template <typename Variant, typename T, typename... Ts>
struct bt_deserialize_try_variant_impl<std::enable_if_t<is_bt_deserializable<T>::value>, Variant, T, Ts...> { struct bt_deserialize_try_variant_impl<std::enable_if_t<is_bt_deserializable<T>>, Variant, T, Ts...> {
void operator()(std::string_view& s, Variant& variant) { void operator()(std::string_view& s, Variant& variant) {
if ( is_bt_output_list_container<T>::value ? s[0] == 'l' : if ( is_bt_output_list_container<T> ? s[0] == 'l' :
is_bt_output_dict_container<T>::value ? s[0] == 'd' : is_bt_output_dict_container<T> ? s[0] == 'd' :
std::is_integral<T>::value ? s[0] == 'i' : std::is_integral_v<T> ? s[0] == 'i' :
std::is_same<T, std::string>::value ? s[0] >= '0' && s[0] <= '9' : std::is_same_v<T, std::string> ? s[0] >= '0' && s[0] <= '9' :
false) { false) {
T val; T val;
bt_deserialize<T>{}(s, val); bt_deserialize<T>{}(s, val);
@ -392,48 +366,37 @@ struct bt_deserialize_try_variant_impl<std::enable_if_t<is_bt_deserializable<T>:
}; };
template <typename Variant, typename T, typename... Ts> template <typename Variant, typename T, typename... Ts>
struct bt_deserialize_try_variant_impl<std::enable_if_t<!is_bt_deserializable<T>::value>, Variant, T, Ts...> { struct bt_deserialize_try_variant_impl<std::enable_if_t<!is_bt_deserializable<T>>, Variant, T, Ts...> {
void operator()(std::string_view& s, Variant& variant) { void operator()(std::string_view& s, Variant& variant) {
// Unsupported deserialization type, skip it // Unsupported deserialization type, skip it
bt_deserialize_try_variant<Ts...>(s, variant); bt_deserialize_try_variant<Ts...>(s, variant);
} }
}; };
template <> // Serialization of a variant; all variant types must be bt-serializable.
struct bt_deserialize<bt_value, void> {
void operator()(std::string_view& s, bt_value& val);
};
template <typename... Ts> template <typename... Ts>
struct bt_serialize<mapbox::util::variant<Ts...>> { struct bt_serialize<std::variant<Ts...>, std::void_t<bt_serialize<Ts>...>> {
void operator()(std::ostream& os, const mapbox::util::variant<Ts...>& val) {
mapbox::util::apply_visitor(bt_serialize_visitor{os}, val);
}
};
template <typename... Ts>
struct bt_deserialize<mapbox::util::variant<Ts...>> {
void operator()(std::string_view& s, mapbox::util::variant<Ts...>& val) {
bt_deserialize_try_variant<Ts...>(s, val);
}
};
/// C++17 std::variant support
template <typename... Ts>
struct bt_serialize<std::variant<Ts...>> {
void operator()(std::ostream &os, const std::variant<Ts...>& val) { void operator()(std::ostream &os, const std::variant<Ts...>& val) {
mapbox::util::apply_visitor(bt_serialize_visitor{os}, val); std::visit(bt_serialize_visitor{os}, val);
} }
}; };
// Deserialization to a variant; at least one variant type must be bt-deserializble.
template <typename... Ts> template <typename... Ts>
struct bt_deserialize<std::variant<Ts...>> { struct bt_deserialize<std::variant<Ts...>, std::enable_if_t<(is_bt_deserializable<Ts> || ...)>> {
void operator()(std::string_view& s, std::variant<Ts...>& val) { void operator()(std::string_view& s, std::variant<Ts...>& val) {
bt_deserialize_try_variant<Ts...>(s, val); bt_deserialize_try_variant<Ts...>(s, val);
} }
}; };
template <>
struct bt_serialize<bt_value> : bt_serialize<bt_variant> {};
template <>
struct bt_deserialize<bt_value> {
void operator()(std::string_view& s, bt_value& val);
};
template <typename T> template <typename T>
struct bt_stream_serializer { struct bt_stream_serializer {
const T &val; const T &val;
@ -493,7 +456,7 @@ std::string bt_serialize(const T &val) { return bt_serializer(val); }
/// int value; /// int value;
/// bt_deserialize(encoded, value); // Sets value to 42 /// bt_deserialize(encoded, value); // Sets value to 42
/// ///
template <typename T, std::enable_if_t<!std::is_const<T>::value, int> = 0> template <typename T, std::enable_if_t<!std::is_const_v<T>, int> = 0>
void bt_deserialize(std::string_view s, T& val) { void bt_deserialize(std::string_view s, T& val) {
return detail::bt_deserialize<T>{}(s, val); return detail::bt_deserialize<T>{}(s, val);
} }
@ -511,8 +474,8 @@ T bt_deserialize(std::string_view s) {
return val; return val;
} }
/// Deserializes the given value into a generic `bt_value` type (mapbox::util::variant) which is capable /// Deserializes the given value into a generic `bt_value` type (wrapped std::variant) which is
/// of holding all possible BT-encoded values (including recursion). /// capable of holding all possible BT-encoded values (including recursion).
/// ///
/// Example: /// Example:
/// ///
@ -525,28 +488,30 @@ inline bt_value bt_get(std::string_view s) {
return bt_deserialize<bt_value>(s); return bt_deserialize<bt_value>(s);
} }
/// Helper functions to extract a value of some integral type from a bt_value which contains an /// Helper functions to extract a value of some integral type from a bt_value which contains either
/// integer. Does range checking, throwing std::overflow_error if the stored value is outside the /// a int64_t or uint64_t. Does range checking, throwing std::overflow_error if the stored value is
/// range of the target type. /// outside the range of the target type.
/// ///
/// Example: /// Example:
/// ///
/// std::string encoded = "i123456789e"; /// std::string encoded = "i123456789e";
/// auto val = bt_get(encoded); /// auto val = bt_get(encoded);
/// auto v = get_int<uint32_t>(val); // throws if the decoded value doesn't fit in a uint32_t /// auto v = get_int<uint32_t>(val); // throws if the decoded value doesn't fit in a uint32_t
template <typename IntType, std::enable_if_t<std::is_integral<IntType>::value, int> = 0> template <typename IntType, std::enable_if_t<std::is_integral_v<IntType>, int> = 0>
IntType get_int(const bt_value &v) { IntType get_int(const bt_value &v) {
// It's highly unlikely that this code ever runs on a non-2s-complement architecture, but check if (std::holds_alternative<uint64_t>(v)) {
// at compile time if converting to a uint64_t (because while int64_t -> uint64_t is uint64_t value = std::get<uint64_t>(v);
// well-defined, uint64_t -> int64_t only does the right thing under 2's complement). if constexpr (!std::is_same_v<IntType, uint64_t>)
static_assert(!std::is_unsigned<IntType>::value || sizeof(IntType) != sizeof(int64_t) || -1 == ~0, if (value > static_cast<uint64_t>(std::numeric_limits<IntType>::max()))
"Non 2s-complement architecture not supported!"); throw std::overflow_error("Unable to extract integer value: stored value is too large for the requested type");
int64_t value = mapbox::util::get<int64_t>(v); return static_cast<IntType>(value);
if (sizeof(IntType) < sizeof(int64_t)) { }
int64_t value = std::get<int64_t>(v);
if constexpr (!std::is_same_v<IntType, int64_t>)
if (value > static_cast<int64_t>(std::numeric_limits<IntType>::max()) if (value > static_cast<int64_t>(std::numeric_limits<IntType>::max())
|| value < static_cast<int64_t>(std::numeric_limits<IntType>::min())) || value < static_cast<int64_t>(std::numeric_limits<IntType>::min()))
throw std::overflow_error("Unable to extract integer value: stored value is outside the range of the requested type"); throw std::overflow_error("Unable to extract integer value: stored value is outside the range of the requested type");
}
return static_cast<IntType>(value); return static_cast<IntType>(value);
} }

View File

@ -1,10 +1,10 @@
#pragma once #pragma once
#include "auth.h" #include "auth.h"
#include "bt_value.h"
#include <string_view> #include <string_view>
namespace lokimq { namespace lokimq {
class bt_dict;
struct ConnectionID; struct ConnectionID;
namespace detail { namespace detail {

View File

@ -59,7 +59,7 @@ void LokiMQ::worker_thread(unsigned int index) {
catch (const bt_deserialize_invalid& e) { catch (const bt_deserialize_invalid& e) {
LMQ_LOG(warn, worker_id, " deserialization failed: ", e.what(), "; ignoring request"); LMQ_LOG(warn, worker_id, " deserialization failed: ", e.what(), "; ignoring request");
} }
catch (const mapbox::util::bad_variant_access& e) { catch (const std::bad_variant_access& e) {
LMQ_LOG(warn, worker_id, " deserialization failed: found unexpected serialized type (", e.what(), "); ignoring request"); LMQ_LOG(warn, worker_id, " deserialization failed: found unexpected serialized type (", e.what(), "); ignoring request");
} }
catch (const std::out_of_range& e) { catch (const std::out_of_range& e) {

@ -1 +0,0 @@
Subproject commit c94634bbd294204c9ba3f5b267a39582a52e8e5a

View File

@ -5,6 +5,7 @@ set(LMQ_TEST_SRC
main.cpp main.cpp
test_address.cpp test_address.cpp
test_batch.cpp test_batch.cpp
test_bt.cpp
test_connect.cpp test_connect.cpp
test_commands.cpp test_commands.cpp
test_encoding.cpp test_encoding.cpp