From 88ab7b6349a4819babd70a4a386347a8f7d75d4f Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Sun, 30 Aug 2015 17:05:04 +0900 Subject: [PATCH] Unified variant and variant_ref to basic_variant. Added is_* and as_* member functions to basic_variant. Added tests. --- example/boost/msgpack_variant_mapbased.cpp | 6 +- .../msgpack/adaptor/boost/msgpack_variant.hpp | 454 ++++++++-------- test/boost_variant.cpp | 490 ++++++++++-------- 3 files changed, 476 insertions(+), 474 deletions(-) diff --git a/example/boost/msgpack_variant_mapbased.cpp b/example/boost/msgpack_variant_mapbased.cpp index dae2d8c7..a4d4ddce 100644 --- a/example/boost/msgpack_variant_mapbased.cpp +++ b/example/boost/msgpack_variant_mapbased.cpp @@ -35,9 +35,9 @@ struct proc:boost::static_visitor { std::multimap::iterator it = v.begin(); std::multimap::iterator end = v.end(); while(it != end) { - boost::string_ref const& key = boost::get(it->first); + boost::string_ref const& key = it->first.as_boost_string_ref(); if (key == "name") { - boost::string_ref const& value = boost::get(it->second); + boost::string_ref const& value = it->second.as_boost_string_ref(); if (value == "Takatoshi Kondo") { // You can add values to msgpack::type::variant_ref. v.insert( @@ -67,7 +67,7 @@ struct proc:boost::static_visitor { // "Tokyo" -> "Tokyo, JAPAN" // Use msgpack::type::variant instead of msgpack::type::variant_ref // or do as follows: - boost::string_ref const& value = boost::get(it->second); + boost::string_ref const& value = it->second.as_boost_string_ref(); it->second = std::string(&value.front(), value.size()) + ", JAPAN"; ++it; } diff --git a/include/msgpack/adaptor/boost/msgpack_variant.hpp b/include/msgpack/adaptor/boost/msgpack_variant.hpp index 65ff7777..1e662675 100644 --- a/include/msgpack/adaptor/boost/msgpack_variant.hpp +++ b/include/msgpack/adaptor/boost/msgpack_variant.hpp @@ -47,55 +47,189 @@ MSGPACK_API_VERSION_NAMESPACE(v1) { namespace type { -struct variant; -namespace detail { -typedef boost::variant< - nil, // NIL - bool, // BOOL - int64_t, // NEGATIVE_INTEGER - uint64_t, // POSITIVE_INTEGER - double, // FLOAT - std::string, // STR +template +struct basic_variant : + boost::variant< + nil, // NIL + bool, // BOOL + int64_t, // NEGATIVE_INTEGER + uint64_t, // POSITIVE_INTEGER + double, // FLOAT + std::string, // STR #if (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53 - boost::string_ref, // STR + boost::string_ref, // STR #endif // (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53 - std::vector, // BIN - msgpack::type::raw_ref, // BIN - ext, // EXT - ext_ref, // EXT - boost::recursive_wrapper >, // ARRAY - boost::recursive_wrapper >, // MAP - boost::recursive_wrapper >// MAP -> variant_imp; - -} // namespace detail - -struct variant : detail::variant_imp, private boost::totally_ordered { - typedef detail::variant_imp base; - variant() {} + std::vector, // BIN + msgpack::type::raw_ref, // BIN + ext, // EXT + ext_ref, // EXT + boost::recursive_wrapper > >, // ARRAY + boost::recursive_wrapper, basic_variant > >, // MAP + boost::recursive_wrapper, basic_variant > >// MAP + >, + private boost::totally_ordered > { + typedef boost::variant< + nil, // NIL + bool, // BOOL + int64_t, // NEGATIVE_INTEGER + uint64_t, // POSITIVE_INTEGER + double, // FLOAT + std::string, // STR +#if (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53 + boost::string_ref, // STR +#endif // (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53 + std::vector, // BIN + msgpack::type::raw_ref, // BIN + ext, // EXT + ext_ref, // EXT + boost::recursive_wrapper > >, // ARRAY + boost::recursive_wrapper, basic_variant > >, // MAP + boost::recursive_wrapper, basic_variant > >// MAP + > base; + basic_variant() {} template - variant(T const& t):base(t) {} - variant(char const* p):base(std::string(p)) {} - variant(char v) { + basic_variant(T const& t):base(t) {} + basic_variant(char const* p):base(std::string(p)) {} + basic_variant(char v) { int_init(v); } - variant(signed char v) { + basic_variant(signed char v) { int_init(v); } - variant(unsigned char v):base(uint64_t(v)) {} - variant(signed int v) { + basic_variant(unsigned char v):base(uint64_t(v)) {} + basic_variant(signed int v) { int_init(v); } - variant(unsigned int v):base(uint64_t(v)) {} - variant(signed long v) { + basic_variant(unsigned int v):base(uint64_t(v)) {} + basic_variant(signed long v) { int_init(v); } - variant(unsigned long v):base(uint64_t(v)) {} - variant(signed long long v) { + basic_variant(unsigned long v):base(uint64_t(v)) {} + basic_variant(signed long long v) { int_init(v); } - variant(unsigned long long v):base(uint64_t(v)) {} + basic_variant(unsigned long long v):base(uint64_t(v)) {} + + bool is_nil() const { + return boost::get(this); + } + bool is_bool() const { + return boost::get(this); + } + bool is_int64_t() const { + return boost::get(this); + } + bool is_uint64_t() const { + return boost::get(this); + } + bool is_double() const { + return boost::get(this); + } + bool is_string() const { + return boost::get(this); + } +#if (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53 + bool is_boost_string_ref() const { + return boost::get(this); + } +#endif // (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53 + bool is_vector_char() const { + return boost::get >(this); + } + bool is_vector_char() { + return boost::get >(this); + } + bool is_raw_ref() const { + return boost::get(this); + } + bool is_ext() const { + return boost::get(this); + } + bool is_ext_ref() const { + return boost::get(this); + } + bool is_vector() const { + return boost::get > >(this); + } + bool is_map() const { + return boost::get, basic_variant > >(this); + } + bool is_multimap() const { + return boost::get, basic_variant > >(this); + } + + bool as_bool() const { + return boost::get(*this); + } + int64_t as_int64_t() const { + return boost::get(*this); + } + int64_t& as_int64_t() { + return boost::get(*this); + } + uint64_t as_uint64_t() const { + return boost::get(*this); + } + uint64_t& as_uint64_t() { + return boost::get(*this); + } + double as_double() const { + return boost::get(*this); + } + double& as_double() { + return boost::get(*this); + } + std::string const& as_string() const { + return boost::get(*this); + } + std::string& as_string() { + return boost::get(*this); + } +#if (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53 + boost::string_ref const& as_boost_string_ref() const { + return boost::get(*this); + } + boost::string_ref& as_boost_string_ref() { + return boost::get(*this); + } +#endif // (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53 + std::vector const& as_vector_char() const { + return boost::get >(*this); + } + std::vector& as_vector_char() { + return boost::get >(*this); + } + raw_ref const& as_raw_ref() const { + return boost::get(*this); + } + ext const& as_ext() const { + return boost::get(*this); + } + ext& as_ext() { + return boost::get(*this); + } + ext_ref const& as_ext_ref() const { + return boost::get(*this); + } + std::vector > const& as_vector() const { + return boost::get > >(*this); + } + std::vector >& as_vector() { + return boost::get > >(*this); + } + std::map, basic_variant > const& as_map() const { + return boost::get, basic_variant > >(*this); + } + std::map, basic_variant >& as_map() { + return boost::get, basic_variant > >(*this); + } + std::multimap, basic_variant > const& as_multimap() const { + return boost::get, basic_variant > >(*this); + } + std::multimap, basic_variant >& as_multimap() { + return boost::get, basic_variant > >(*this); + } private: template void int_init(T v) { @@ -108,94 +242,38 @@ private: } }; -inline bool operator<(variant const& lhs, variant const& rhs) { - return static_cast(lhs) < static_cast(rhs); +template +inline bool operator<(basic_variant const& lhs, basic_variant const& rhs) { + return + static_cast::base const&>(lhs) < + static_cast::base const&>(rhs); } -inline bool operator==(variant const& lhs, variant const& rhs) { - return static_cast(lhs) == static_cast(rhs); +template +inline bool operator==(basic_variant const& lhs, basic_variant const& rhs) { + return + static_cast::base const&>(lhs) == + static_cast::base const&>(rhs); } - -struct variant_ref; - -namespace detail { -typedef boost::variant< - nil, // NIL - bool, // BOOL - int64_t, // NEGATIVE_INTEGER - uint64_t, // POSITIVE_INTEGER - double, // FLOAT - std::string, // STR +typedef basic_variant, ext> variant; +typedef basic_variant< #if (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53 - boost::string_ref, // STR + boost::string_ref, +#else // (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53 + std::string, #endif // (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53 - std::vector, // BIN - msgpack::type::raw_ref, // BIN - ext, // EXT - ext_ref, // EXT - boost::recursive_wrapper >, // ARRAY - boost::recursive_wrapper >, // MAP - boost::recursive_wrapper >// MAP -> variant_ref_imp; - -} // namespace detail - -struct variant_ref : detail::variant_ref_imp, private boost::totally_ordered { - typedef detail::variant_ref_imp base; - variant_ref() {} - template - variant_ref(T const& t):base(t) {} - variant_ref(char const* p):base(std::string(p)) {} - variant_ref(char v) { - int_init(v); - } - variant_ref(signed char v) { - int_init(v); - } - variant_ref(unsigned char v):base(uint64_t(v)) {} - variant_ref(signed int v) { - int_init(v); - } - variant_ref(unsigned int v):base(uint64_t(v)) {} - variant_ref(signed long v) { - int_init(v); - } - variant_ref(unsigned long v):base(uint64_t(v)) {} - variant_ref(signed long long v) { - int_init(v); - } - variant_ref(unsigned long long v):base(uint64_t(v)) {} -private: - template - void int_init(T v) { - if (v < 0) { - static_cast(*this) = int64_t(v); - } - else { - static_cast(*this) = uint64_t(v); - } - } -}; - -inline bool operator<(variant_ref const& lhs, variant_ref const& rhs) { - return static_cast(lhs) < static_cast(rhs); -} - -inline bool operator==(variant_ref const& lhs, variant_ref const& rhs) { - return static_cast(lhs) == static_cast(rhs); -} + raw_ref, ext_ref> variant_ref; } // namespace type - namespace adaptor { #if !defined (MSGPACK_USE_CPP03) -template <> -struct as { - msgpack::type::variant operator()(msgpack::object const& o) const { +template +struct as > { + msgpack::type::basic_variant operator()(msgpack::object const& o) const { switch(o.type) { case type::NIL: return o.as(); @@ -208,30 +286,30 @@ struct as { case type::FLOAT: return o.as(); case type::STR: - return o.as(); + return o.as(); case type::BIN: - return o.as >(); + return o.as(); case type::EXT: - return o.as(); + return o.as(); case type::ARRAY: - return o.as >(); + return o.as > >(); case type::MAP: - return o.as >(); + return o.as, msgpack::type::basic_variant > >(); default: break; } - return msgpack::type::variant(); + return msgpack::type::basic_variant(); } }; #endif // !defined (MSGPACK_USE_CPP03) -template <> -struct convert { +template +struct convert > { msgpack::object const& operator()( msgpack::object const& o, - msgpack::type::variant& v) const { + msgpack::type::basic_variant& v) const { switch(o.type) { case type::NIL: v = o.as(); @@ -249,19 +327,19 @@ struct convert { v = o.as(); break; case type::STR: - v = o.as(); + v = o.as(); break; case type::BIN: - v = o.as >(); + v = o.as(); break; case type::EXT: - v = o.as(); + v = o.as(); break; case type::ARRAY: - v = o.as >(); + v = o.as > >(); break; case type::MAP: - v = o.as >(); + v = o.as, msgpack::type::basic_variant > >(); break; default: break; @@ -284,10 +362,10 @@ struct pack_imp:boost::static_visitor { } // namespace detail -template <> -struct pack { +template +struct pack > { template - msgpack::packer& operator()(msgpack::packer& o, const msgpack::type::variant& v) const { + msgpack::packer& operator()(msgpack::packer& o, const msgpack::type::basic_variant& v) const { boost::apply_visitor(detail::pack_imp(o), v); return o; } @@ -321,9 +399,9 @@ struct object_imp:boost::static_visitor { } // namespace detail -template <> -struct object { - void operator()(msgpack::object& o, const msgpack::type::variant& v) const { +template +struct object > { + void operator()(msgpack::object& o, const msgpack::type::basic_variant& v) const { boost::apply_visitor(detail::object_imp(o), v); } }; @@ -341,119 +419,9 @@ struct object_with_zone_imp:boost::static_visitor { } // namespace detail -template <> -struct object_with_zone { - void operator()(msgpack::object::with_zone& o, const msgpack::type::variant& v) const { - boost::apply_visitor(detail::object_with_zone_imp(o), v); - } -}; - -#if !defined (MSGPACK_USE_CPP03) - -template <> -struct as { - msgpack::type::variant_ref operator()(msgpack::object const& o) const { - switch(o.type) { - case type::NIL: - return o.as(); - case type::BOOLEAN: - return o.as(); - case type::POSITIVE_INTEGER: - return o.as(); - case type::NEGATIVE_INTEGER: - return o.as(); - case type::FLOAT: - return o.as(); - case type::STR: -#if (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53 - return o.as(); -#else // (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53 - return o.as(); -#endif // (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53 - case type::BIN: - return o.as(); - case type::EXT: - return o.as(); - case type::ARRAY: - return o.as >(); - case type::MAP: - return o.as >(); - default: - break; - } - return msgpack::type::variant_ref(); - } -}; - -#endif // !defined (MSGPACK_USE_CPP03) - - -template <> -struct convert { - msgpack::object const& operator()( - msgpack::object const& o, - msgpack::type::variant_ref& v) const { - switch(o.type) { - case type::NIL: - v = o.as(); - break; - case type::BOOLEAN: - v = o.as(); - break; - case type::POSITIVE_INTEGER: - v = o.as(); - break; - case type::NEGATIVE_INTEGER: - v = o.as(); - break; - case type::FLOAT: - v = o.as(); - break; - case type::STR: -#if (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53 - v = o.as(); -#else // (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53 - v = o.as(); -#endif // (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53 - break; - case type::BIN: - v = o.as(); - break; - case type::EXT: - v = o.as(); - break; - case type::ARRAY: - v = o.as >(); - break; - case type::MAP: - v = o.as >(); - break; - default: - break; - } - return o; - } -}; - -template <> -struct pack { - template - msgpack::packer& operator()(msgpack::packer& o, const msgpack::type::variant_ref& v) const { - boost::apply_visitor(detail::pack_imp(o), v); - return o; - } -}; - -template <> -struct object { - void operator()(msgpack::object& o, const msgpack::type::variant_ref& v) const { - boost::apply_visitor(detail::object_imp(o), v); - } -}; - -template <> -struct object_with_zone { - void operator()(msgpack::object::with_zone& o, const msgpack::type::variant_ref& v) const { +template +struct object_with_zone > { + void operator()(msgpack::object::with_zone& o, const msgpack::type::basic_variant& v) const { boost::apply_visitor(detail::object_with_zone_imp(o), v); } }; diff --git a/test/boost_variant.cpp b/test/boost_variant.cpp index d84cff21..abc574ce 100644 --- a/test/boost_variant.cpp +++ b/test/boost_variant.cpp @@ -1,3 +1,4 @@ +#include #include #include #include @@ -9,26 +10,31 @@ #if defined(MSGPACK_USE_BOOST) +const double kEPS = 1e-10; + // nil TEST(MSGPACK_BOOST, pack_convert_variant_nil) { std::stringstream ss; msgpack::type::variant val1 = msgpack::type::nil(); - + EXPECT_TRUE(val1.is_nil()); msgpack::pack(ss, val1); msgpack::unpacked ret; msgpack::unpack(ret, ss.str().data(), ss.str().size()); msgpack::type::variant val2 = ret.get().as(); + EXPECT_TRUE(val2.is_nil()); EXPECT_NO_THROW(boost::get(val2)); } TEST(MSGPACK_BOOST, object_variant_nil) { msgpack::type::variant val1 = msgpack::type::nil(); + EXPECT_TRUE(val1.is_nil()); msgpack::object obj(val1); msgpack::type::variant val2 = obj.as(); + EXPECT_TRUE(val2.is_nil()); EXPECT_NO_THROW(boost::get(val2)); } @@ -36,8 +42,10 @@ TEST(MSGPACK_BOOST, object_with_zone_variant_nil) { msgpack::zone z; msgpack::type::variant val1 = msgpack::type::nil(); + EXPECT_TRUE(val1.is_nil()); msgpack::object obj(val1, z); msgpack::type::variant val2 = obj.as(); + EXPECT_TRUE(val2.is_nil()); EXPECT_NO_THROW(boost::get(val2)); } @@ -47,20 +55,24 @@ TEST(MSGPACK_BOOST, pack_convert_variant_nil_default) { std::stringstream ss; msgpack::type::variant val1; + EXPECT_TRUE(val1.is_nil()); msgpack::pack(ss, val1); msgpack::unpacked ret; msgpack::unpack(ret, ss.str().data(), ss.str().size()); msgpack::type::variant val2 = ret.get().as(); + EXPECT_TRUE(val2.is_nil()); EXPECT_NO_THROW(boost::get(val2)); } TEST(MSGPACK_BOOST, object_variant_nil_default) { msgpack::type::variant val1; + EXPECT_TRUE(val1.is_nil()); msgpack::object obj(val1); msgpack::type::variant val2 = obj.as(); + EXPECT_TRUE(val2.is_nil()); EXPECT_NO_THROW(boost::get(val2)); } @@ -68,8 +80,10 @@ TEST(MSGPACK_BOOST, object_with_zone_variant_nil_default) { msgpack::zone z; msgpack::type::variant val1; + EXPECT_TRUE(val1.is_nil()); msgpack::object obj(val1, z); msgpack::type::variant val2 = obj.as(); + EXPECT_TRUE(val2.is_nil()); EXPECT_NO_THROW(boost::get(val2)); } @@ -79,12 +93,16 @@ TEST(MSGPACK_BOOST, pack_convert_variant_bool) { std::stringstream ss; msgpack::type::variant val1 = true; + EXPECT_TRUE(val1.is_bool()); + EXPECT_TRUE(val1.as_bool()); msgpack::pack(ss, val1); msgpack::unpacked ret; msgpack::unpack(ret, ss.str().data(), ss.str().size()); msgpack::type::variant val2 = ret.get().as(); + EXPECT_TRUE(val2.is_bool()); + EXPECT_TRUE(val2.as_bool()); EXPECT_NO_THROW(boost::get(val2)); EXPECT_TRUE(val1 == val2); // Tests for totally ordered @@ -98,8 +116,12 @@ TEST(MSGPACK_BOOST, pack_convert_variant_bool) TEST(MSGPACK_BOOST, object_variant_bool) { msgpack::type::variant val1 = true; + EXPECT_TRUE(val1.is_bool()); + EXPECT_TRUE(val1.as_bool()); msgpack::object obj(val1); msgpack::type::variant val2 = obj.as(); + EXPECT_TRUE(val2.is_bool()); + EXPECT_TRUE(val2.as_bool()); EXPECT_NO_THROW(boost::get(val2)); EXPECT_TRUE(val1 == val2); } @@ -108,8 +130,12 @@ TEST(MSGPACK_BOOST, object_with_zone_variant_bool) { msgpack::zone z; msgpack::type::variant val1 = true; + EXPECT_TRUE(val1.is_bool()); + EXPECT_TRUE(val1.as_bool()); msgpack::object obj(val1, z); msgpack::type::variant val2 = obj.as(); + EXPECT_TRUE(val2.is_bool()); + EXPECT_TRUE(val2.as_bool()); EXPECT_NO_THROW(boost::get(val2)); EXPECT_TRUE(val1 == val2); } @@ -120,12 +146,16 @@ TEST(MSGPACK_BOOST, pack_convert_variant_positive_integer) { std::stringstream ss; msgpack::type::variant val1 = 123; + EXPECT_TRUE(val1.is_uint64_t()); + EXPECT_EQ(val1.as_uint64_t(), 123); msgpack::pack(ss, val1); msgpack::unpacked ret; msgpack::unpack(ret, ss.str().data(), ss.str().size()); msgpack::type::variant val2 = ret.get().as(); + EXPECT_TRUE(val2.is_uint64_t()); + EXPECT_EQ(val2.as_uint64_t(), 123); EXPECT_NO_THROW(boost::get(val2)); EXPECT_TRUE(val1 == val2); } @@ -133,8 +163,12 @@ TEST(MSGPACK_BOOST, pack_convert_variant_positive_integer) TEST(MSGPACK_BOOST, object_variant_positive_integer) { msgpack::type::variant val1 = 123; + EXPECT_TRUE(val1.is_uint64_t()); + EXPECT_EQ(val1.as_uint64_t(), 123); msgpack::object obj(val1); msgpack::type::variant val2 = obj.as(); + EXPECT_TRUE(val2.is_uint64_t()); + EXPECT_EQ(val2.as_uint64_t(), 123); EXPECT_NO_THROW(boost::get(val2)); EXPECT_TRUE(val1 == val2); } @@ -143,8 +177,12 @@ TEST(MSGPACK_BOOST, object_with_zone_variant_positive_integer) { msgpack::zone z; msgpack::type::variant val1 = 123; + EXPECT_TRUE(val1.is_uint64_t()); + EXPECT_EQ(val1.as_uint64_t(), 123); msgpack::object obj(val1, z); msgpack::type::variant val2 = obj.as(); + EXPECT_TRUE(val2.is_uint64_t()); + EXPECT_EQ(val2.as_uint64_t(), 123); EXPECT_NO_THROW(boost::get(val2)); EXPECT_TRUE(val1 == val2); } @@ -155,12 +193,16 @@ TEST(MSGPACK_BOOST, pack_convert_variant_negative_integer) { std::stringstream ss; msgpack::type::variant val1 = -123; + EXPECT_TRUE(val1.is_int64_t()); + EXPECT_EQ(val1.as_int64_t(), -123); msgpack::pack(ss, val1); msgpack::unpacked ret; msgpack::unpack(ret, ss.str().data(), ss.str().size()); msgpack::type::variant val2 = ret.get().as(); + EXPECT_TRUE(val2.is_int64_t()); + EXPECT_EQ(val2.as_int64_t(), -123); EXPECT_NO_THROW(boost::get(val2)); EXPECT_TRUE(val1 == val2); } @@ -168,8 +210,12 @@ TEST(MSGPACK_BOOST, pack_convert_variant_negative_integer) TEST(MSGPACK_BOOST, object_variant_negative_integer) { msgpack::type::variant val1 = -123; + EXPECT_TRUE(val1.is_int64_t()); + EXPECT_EQ(val1.as_int64_t(), -123); msgpack::object obj(val1); msgpack::type::variant val2 = obj.as(); + EXPECT_TRUE(val2.is_int64_t()); + EXPECT_EQ(val2.as_int64_t(), -123); EXPECT_NO_THROW(boost::get(val2)); EXPECT_TRUE(val1 == val2); } @@ -178,8 +224,12 @@ TEST(MSGPACK_BOOST, object_with_zone_variant_negative_integer) { msgpack::zone z; msgpack::type::variant val1 = -123; + EXPECT_TRUE(val1.is_int64_t()); + EXPECT_EQ(val1.as_int64_t(), -123); msgpack::object obj(val1, z); msgpack::type::variant val2 = obj.as(); + EXPECT_TRUE(val2.is_int64_t()); + EXPECT_EQ(val2.as_int64_t(), -123); EXPECT_NO_THROW(boost::get(val2)); EXPECT_TRUE(val1 == val2); } @@ -190,33 +240,45 @@ TEST(MSGPACK_BOOST, pack_convert_variant_float) { std::stringstream ss; msgpack::type::variant val1 = 12.34; + EXPECT_TRUE(val1.is_double()); + EXPECT_TRUE(fabs(12.34 - val1.as_double()) <= kEPS); msgpack::pack(ss, val1); msgpack::unpacked ret; msgpack::unpack(ret, ss.str().data(), ss.str().size()); msgpack::type::variant val2 = ret.get().as(); + EXPECT_TRUE(val2.is_double()); + EXPECT_TRUE(fabs(12.34 - val2.as_double()) <= kEPS); EXPECT_NO_THROW(boost::get(val2)); - EXPECT_TRUE(val1 == val2); + EXPECT_TRUE(fabs(val2.as_double() - val2.as_double()) <= kEPS); } TEST(MSGPACK_BOOST, object_variant_float) { msgpack::type::variant val1 = 12.34; + EXPECT_TRUE(val1.is_double()); + EXPECT_TRUE(fabs(12.34 - val1.as_double()) <= kEPS); msgpack::object obj(val1); msgpack::type::variant val2 = obj.as(); + EXPECT_TRUE(val2.is_double()); + EXPECT_TRUE(fabs(12.34 - val2.as_double()) <= kEPS); EXPECT_NO_THROW(boost::get(val2)); - EXPECT_TRUE(val1 == val2); + EXPECT_TRUE(fabs(val2.as_double() - val2.as_double()) <= kEPS); } TEST(MSGPACK_BOOST, object_with_zone_variant_float) { msgpack::zone z; msgpack::type::variant val1 = 12.34; + EXPECT_TRUE(val1.is_double()); + EXPECT_TRUE(fabs(12.34 - val1.as_double()) <= kEPS); msgpack::object obj(val1, z); msgpack::type::variant val2 = obj.as(); + EXPECT_TRUE(val2.is_double()); + EXPECT_TRUE(fabs(12.34 - val2.as_double()) <= kEPS); EXPECT_NO_THROW(boost::get(val2)); - EXPECT_TRUE(val1 == val2); + EXPECT_TRUE(fabs(val2.as_double() - val2.as_double()) <= kEPS); } // str @@ -225,28 +287,58 @@ TEST(MSGPACK_BOOST, pack_convert_variant_str) { std::stringstream ss; msgpack::type::variant val1 = "ABC"; + EXPECT_TRUE(val1.is_string()); + EXPECT_EQ(val1.as_string(), "ABC"); msgpack::pack(ss, val1); msgpack::unpacked ret; msgpack::unpack(ret, ss.str().data(), ss.str().size()); msgpack::type::variant val2 = ret.get().as(); + EXPECT_TRUE(val2.is_string()); + EXPECT_EQ(val2.as_string(), "ABC"); EXPECT_NO_THROW(boost::get(val2)); EXPECT_TRUE(val1 == val2); } - TEST(MSGPACK_BOOST, object_with_zone_variant_str) { msgpack::zone z; msgpack::type::variant val1 = "ABC"; + EXPECT_TRUE(val1.is_string()); + EXPECT_EQ(val1.as_string(), "ABC"); msgpack::object obj(val1, z); msgpack::type::variant val2 = obj.as(); + EXPECT_TRUE(val2.is_string()); + EXPECT_EQ(val2.as_string(), "ABC"); EXPECT_NO_THROW(boost::get(val2)); EXPECT_TRUE(val1 == val2); } +#if (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53 + +TEST(MSGPACK_BOOST, object_with_zone_variant_str_ref) +{ + // You can use boost::string_ref with msgpack::type::variant. + msgpack::zone z; + std::string s = "ABC"; + boost::string_ref sr(s); + msgpack::type::variant val1(sr); + EXPECT_TRUE(val1.is_boost_string_ref()); + EXPECT_EQ(val1.as_boost_string_ref(), "ABC"); + msgpack::object obj(val1, z); + msgpack::type::variant val2 = obj.as(); + // Coverted as std::string. + EXPECT_TRUE(val2.is_string()); + EXPECT_EQ(val2.as_string(), "ABC"); + EXPECT_NO_THROW(boost::get(val2)); + // boost::string_ref and std::string are different. + EXPECT_FALSE(val1 == val2); +} + +#endif // (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53 + // bin TEST(MSGPACK_BOOST, pack_convert_variant_bin) @@ -257,12 +349,16 @@ TEST(MSGPACK_BOOST, pack_convert_variant_bin) v.push_back('b'); v.push_back('c'); msgpack::type::variant val1 = v; + EXPECT_TRUE(val1.is_vector_char()); + EXPECT_EQ(val1.as_vector_char(), v); msgpack::pack(ss, val1); msgpack::unpacked ret; msgpack::unpack(ret, ss.str().data(), ss.str().size()); msgpack::type::variant val2 = ret.get().as(); + EXPECT_TRUE(val2.is_vector_char()); + EXPECT_EQ(val2.as_vector_char(), v); EXPECT_NO_THROW(boost::get >(val2)); EXPECT_TRUE(val1 == val2); } @@ -277,12 +373,42 @@ TEST(MSGPACK_BOOST, object_with_zone_variant_bin) v.push_back('b'); v.push_back('c'); msgpack::type::variant val1 = v; + EXPECT_TRUE(val1.is_vector_char()); + EXPECT_EQ(val1.as_vector_char(), v); msgpack::object obj(val1, z); msgpack::type::variant val2 = obj.as(); + EXPECT_TRUE(val2.is_vector_char()); + EXPECT_EQ(val2.as_vector_char(), v); EXPECT_NO_THROW(boost::get >(val2)); EXPECT_TRUE(val1 == val2); } +#if (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53 + +TEST(MSGPACK_BOOST, object_with_zone_variant_raw_ref) +{ + // You can use boost::string_ref with msgpack::type::variant. + msgpack::zone z; + std::vector v; + v.push_back('a'); + v.push_back('b'); + v.push_back('c'); + msgpack::type::raw_ref rr(&v.front(), v.size()); + msgpack::type::variant val1 = rr; + EXPECT_TRUE(val1.is_raw_ref()); + EXPECT_EQ(val1.as_raw_ref(), msgpack::type::raw_ref(&v.front(), v.size())); + msgpack::object obj(val1, z); + msgpack::type::variant val2 = obj.as(); + // Coverted as std::vector. + EXPECT_TRUE(val2.is_vector_char()); + EXPECT_EQ(val2.as_vector_char(), v); + EXPECT_NO_THROW(boost::get >(val2)); + // msgpack::type::raw_ref and std::vector are different. + EXPECT_FALSE(val1 == val2); +} + +#endif // (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53 + // ext TEST(MSGPACK_BOOST, pack_convert_variant_ext) @@ -292,13 +418,18 @@ TEST(MSGPACK_BOOST, pack_convert_variant_ext) v.push_back('a'); v.push_back('b'); v.push_back('c'); - msgpack::type::variant val1(msgpack::type::ext(42, v.data(), v.size())); + msgpack::type::ext e(42, v.data(), v.size()); + msgpack::type::variant val1(e); + EXPECT_TRUE(val1.is_ext()); + EXPECT_EQ(val1.as_ext(), e); msgpack::pack(ss, val1); msgpack::unpacked ret; msgpack::unpack(ret, ss.str().data(), ss.str().size()); msgpack::type::variant val2 = ret.get().as(); + EXPECT_TRUE(val2.is_ext()); + EXPECT_EQ(val2.as_ext(), e); EXPECT_NO_THROW(boost::get(val2)); EXPECT_TRUE(val1 == val2); } @@ -312,13 +443,40 @@ TEST(MSGPACK_BOOST, object_with_zone_variant_ext) v.push_back('a'); v.push_back('b'); v.push_back('c'); - msgpack::type::variant val1(msgpack::type::ext(42, v.data(), v.size())); + msgpack::type::ext e(42, v.data(), v.size()); + msgpack::type::variant val1(e); + EXPECT_TRUE(val1.is_ext()); + EXPECT_EQ(val1.as_ext(), e); msgpack::object obj(val1, z); msgpack::type::variant val2 = obj.as(); + EXPECT_TRUE(val2.is_ext()); + EXPECT_EQ(val2.as_ext(), e); EXPECT_NO_THROW(boost::get(val2)); EXPECT_TRUE(val1 == val2); } +TEST(MSGPACK_BOOST, object_with_zone_variant_ext_ref) +{ + // You can use msgpack::type::ext_ref with msgpack::type::variant. + msgpack::zone z; + std::vector v; + v.push_back('a'); + v.push_back('b'); + v.push_back('c'); + msgpack::type::ext_ref e(v.data(), v.size()); + msgpack::type::variant val1(e); + EXPECT_TRUE(val1.is_ext_ref()); + EXPECT_EQ(val1.as_ext_ref(), e); + msgpack::object obj(val1, z); + msgpack::type::variant val2 = obj.as(); + // Coverted as msgpack::type::ext. + EXPECT_TRUE(val2.is_ext()); + EXPECT_EQ(val2.as_ext(), e); + EXPECT_NO_THROW(boost::get(val2)); + // msgpack::type::ext_ref and msgpack::type::ext are different. + EXPECT_FALSE(val1 == val2); +} + // array TEST(MSGPACK_BOOST, pack_convert_variant_array) @@ -327,15 +485,18 @@ TEST(MSGPACK_BOOST, pack_convert_variant_array) std::vector v; v.push_back(msgpack::type::variant(1)); v.push_back(msgpack::type::variant(-1)); - v.push_back(msgpack::type::variant(23.4)); v.push_back(msgpack::type::variant("ABC")); msgpack::type::variant val1 = v; + EXPECT_TRUE(val1.is_vector()); + EXPECT_EQ(val1.as_vector(), v); msgpack::pack(ss, val1); msgpack::unpacked ret; msgpack::unpack(ret, ss.str().data(), ss.str().size()); msgpack::type::variant val2 = ret.get().as(); + EXPECT_TRUE(val2.is_vector()); + EXPECT_EQ(val2.as_vector(), v); EXPECT_NO_THROW(boost::get >(val2)); EXPECT_TRUE(val1 == val2); } @@ -346,11 +507,14 @@ TEST(MSGPACK_BOOST, object_with_zone_variant_array) std::vector v; v.push_back(msgpack::type::variant(1)); v.push_back(msgpack::type::variant(-1)); - v.push_back(msgpack::type::variant(23.4)); v.push_back(msgpack::type::variant("ABC")); msgpack::type::variant val1 = v; + EXPECT_TRUE(val1.is_vector()); + EXPECT_EQ(val1.as_vector(), v); msgpack::object obj(val1, z); msgpack::type::variant val2 = obj.as(); + EXPECT_TRUE(val2.is_vector()); + EXPECT_EQ(val2.as_vector(), v); EXPECT_NO_THROW(boost::get >(val2)); EXPECT_TRUE(val1 == val2); } @@ -363,14 +527,18 @@ TEST(MSGPACK_BOOST, pack_convert_variant_map) typedef std::multimap multimap_t; multimap_t v; v.insert(multimap_t::value_type(msgpack::type::variant(1), msgpack::type::variant(-1))); - v.insert(multimap_t::value_type(msgpack::type::variant(23.4), msgpack::type::variant("ABC"))); + v.insert(multimap_t::value_type(msgpack::type::variant("ABC"), msgpack::type::variant("DEF"))); msgpack::type::variant val1 = v; + EXPECT_TRUE(val1.is_multimap()); + EXPECT_EQ(val1.as_multimap(), v); msgpack::pack(ss, val1); msgpack::unpacked ret; msgpack::unpack(ret, ss.str().data(), ss.str().size()); msgpack::type::variant val2 = ret.get().as(); + EXPECT_TRUE(val2.is_multimap()); + EXPECT_EQ(val2.as_multimap(), v); EXPECT_NO_THROW(boost::get(val2)); EXPECT_TRUE(val1 == val2); } @@ -381,233 +549,40 @@ TEST(MSGPACK_BOOST, object_with_zone_variant_map) typedef std::multimap multimap_t; multimap_t v; v.insert(multimap_t::value_type(msgpack::type::variant(1), msgpack::type::variant(-1))); - v.insert(multimap_t::value_type(msgpack::type::variant(23.4), msgpack::type::variant("ABC"))); + v.insert(multimap_t::value_type(msgpack::type::variant("ABC"), msgpack::type::variant("DEF"))); msgpack::type::variant val1 = v; + EXPECT_TRUE(val1.is_multimap()); + EXPECT_EQ(val1.as_multimap(), v); msgpack::object obj(val1, z); msgpack::type::variant val2 = obj.as(); + EXPECT_TRUE(val2.is_multimap()); + EXPECT_EQ(val2.as_multimap(), v); EXPECT_NO_THROW(boost::get(val2)); EXPECT_TRUE(val1 == val2); } // variant_ref -// nil - -TEST(MSGPACK_BOOST, pack_convert_variant_ref_nil) -{ - std::stringstream ss; - msgpack::type::variant_ref val1 = msgpack::type::nil(); - - msgpack::pack(ss, val1); - - msgpack::unpacked ret; - msgpack::unpack(ret, ss.str().data(), ss.str().size()); - msgpack::type::variant_ref val2 = ret.get().as(); - EXPECT_NO_THROW(boost::get(val2)); -} - -TEST(MSGPACK_BOOST, object_variant_ref_nil) -{ - msgpack::type::variant_ref val1 = msgpack::type::nil(); - msgpack::object obj(val1); - msgpack::type::variant_ref val2 = obj.as(); - EXPECT_NO_THROW(boost::get(val2)); -} - -TEST(MSGPACK_BOOST, object_with_zone_variant_ref_nil) -{ - msgpack::zone z; - msgpack::type::variant_ref val1 = msgpack::type::nil(); - msgpack::object obj(val1, z); - msgpack::type::variant_ref val2 = obj.as(); - EXPECT_NO_THROW(boost::get(val2)); -} - -// nil (default constructor) - -TEST(MSGPACK_BOOST, pack_convert_variant_ref_nil_default) -{ - std::stringstream ss; - msgpack::type::variant_ref val1; - - msgpack::pack(ss, val1); - - msgpack::unpacked ret; - msgpack::unpack(ret, ss.str().data(), ss.str().size()); - msgpack::type::variant_ref val2 = ret.get().as(); - EXPECT_NO_THROW(boost::get(val2)); -} - -TEST(MSGPACK_BOOST, object_variant_ref_nil_default) -{ - msgpack::type::variant_ref val1; - msgpack::object obj(val1); - msgpack::type::variant_ref val2 = obj.as(); - EXPECT_NO_THROW(boost::get(val2)); -} - -TEST(MSGPACK_BOOST, object_with_zone_variant_ref_nil_default) -{ - msgpack::zone z; - msgpack::type::variant_ref val1; - msgpack::object obj(val1, z); - msgpack::type::variant_ref val2 = obj.as(); - EXPECT_NO_THROW(boost::get(val2)); -} - -// bool - -TEST(MSGPACK_BOOST, pack_convert_variant_ref_bool) -{ - std::stringstream ss; - msgpack::type::variant_ref val1 = true; - - msgpack::pack(ss, val1); - - msgpack::unpacked ret; - msgpack::unpack(ret, ss.str().data(), ss.str().size()); - msgpack::type::variant_ref val2 = ret.get().as(); - EXPECT_NO_THROW(boost::get(val2)); - EXPECT_TRUE(val1 == val2); -} - -TEST(MSGPACK_BOOST, object_variant_ref_bool) -{ - msgpack::type::variant_ref val1 = true; - msgpack::object obj(val1); - msgpack::type::variant_ref val2 = obj.as(); - EXPECT_NO_THROW(boost::get(val2)); - EXPECT_TRUE(val1 == val2); -} - -TEST(MSGPACK_BOOST, object_with_zone_variant_ref_bool) -{ - msgpack::zone z; - msgpack::type::variant_ref val1 = true; - msgpack::object obj(val1, z); - msgpack::type::variant_ref val2 = obj.as(); - EXPECT_NO_THROW(boost::get(val2)); - EXPECT_TRUE(val1 == val2); -} - -// positive integer - -TEST(MSGPACK_BOOST, pack_convert_variant_ref_positive_integer) -{ - std::stringstream ss; - msgpack::type::variant_ref val1 = 123; - - msgpack::pack(ss, val1); - - msgpack::unpacked ret; - msgpack::unpack(ret, ss.str().data(), ss.str().size()); - msgpack::type::variant_ref val2 = ret.get().as(); - EXPECT_NO_THROW(boost::get(val2)); - EXPECT_TRUE(val1 == val2); -} - -TEST(MSGPACK_BOOST, object_variant_ref_positive_integer) -{ - msgpack::type::variant_ref val1 = 123; - msgpack::object obj(val1); - msgpack::type::variant_ref val2 = obj.as(); - EXPECT_NO_THROW(boost::get(val2)); - EXPECT_TRUE(val1 == val2); -} - -TEST(MSGPACK_BOOST, object_with_zone_variant_ref_positive_integer) -{ - msgpack::zone z; - msgpack::type::variant_ref val1 = 123; - msgpack::object obj(val1, z); - msgpack::type::variant_ref val2 = obj.as(); - EXPECT_NO_THROW(boost::get(val2)); - EXPECT_TRUE(val1 == val2); -} - -// negative integer - -TEST(MSGPACK_BOOST, pack_convert_variant_ref_negative_integer) -{ - std::stringstream ss; - msgpack::type::variant_ref val1 = -123; - - msgpack::pack(ss, val1); - - msgpack::unpacked ret; - msgpack::unpack(ret, ss.str().data(), ss.str().size()); - msgpack::type::variant_ref val2 = ret.get().as(); - EXPECT_NO_THROW(boost::get(val2)); - EXPECT_TRUE(val1 == val2); -} - -TEST(MSGPACK_BOOST, object_variant_ref_negative_integer) -{ - msgpack::type::variant_ref val1 = -123; - msgpack::object obj(val1); - msgpack::type::variant_ref val2 = obj.as(); - EXPECT_NO_THROW(boost::get(val2)); - EXPECT_TRUE(val1 == val2); -} - -TEST(MSGPACK_BOOST, object_with_zone_variant_ref_negative_integer) -{ - msgpack::zone z; - msgpack::type::variant_ref val1 = -123; - msgpack::object obj(val1, z); - msgpack::type::variant_ref val2 = obj.as(); - EXPECT_NO_THROW(boost::get(val2)); - EXPECT_TRUE(val1 == val2); -} - -// float - -TEST(MSGPACK_BOOST, pack_convert_variant_ref_float) -{ - std::stringstream ss; - msgpack::type::variant_ref val1 = 12.34; - - msgpack::pack(ss, val1); - - msgpack::unpacked ret; - msgpack::unpack(ret, ss.str().data(), ss.str().size()); - msgpack::type::variant_ref val2 = ret.get().as(); - EXPECT_NO_THROW(boost::get(val2)); - EXPECT_TRUE(val1 == val2); -} - -TEST(MSGPACK_BOOST, object_variant_ref_float) -{ - msgpack::type::variant_ref val1 = 12.34; - msgpack::object obj(val1); - msgpack::type::variant_ref val2 = obj.as(); - EXPECT_NO_THROW(boost::get(val2)); - EXPECT_TRUE(val1 == val2); -} - -TEST(MSGPACK_BOOST, object_with_zone_variant_ref_float) -{ - msgpack::zone z; - msgpack::type::variant_ref val1 = 12.34; - msgpack::object obj(val1, z); - msgpack::type::variant_ref val2 = obj.as(); - EXPECT_NO_THROW(boost::get(val2)); - EXPECT_TRUE(val1 == val2); -} - // str +#if (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53 + TEST(MSGPACK_BOOST, pack_convert_variant_ref_str) { std::stringstream ss; std::string s("ABC"); - msgpack::type::variant_ref val1 = boost::string_ref(s); + boost::string_ref sr(s); + msgpack::type::variant_ref val1 = sr; + EXPECT_TRUE(val1.is_boost_string_ref()); + EXPECT_EQ(val1.as_boost_string_ref(), sr); msgpack::pack(ss, val1); msgpack::unpacked ret; msgpack::unpack(ret, ss.str().data(), ss.str().size()); msgpack::type::variant_ref val2 = ret.get().as(); + EXPECT_TRUE(val2.is_boost_string_ref()); + EXPECT_EQ(val2.as_boost_string_ref(), sr); EXPECT_NO_THROW(boost::get(val2)); EXPECT_TRUE(val1 == val2); } @@ -618,13 +593,20 @@ TEST(MSGPACK_BOOST, object_with_zone_variant_ref_str) { msgpack::zone z; std::string s("ABC"); - msgpack::type::variant_ref val1 = boost::string_ref(s); + boost::string_ref sr(s); + msgpack::type::variant_ref val1 = sr; + EXPECT_TRUE(val1.is_boost_string_ref()); + EXPECT_EQ(val1.as_boost_string_ref(), sr); msgpack::object obj(val1, z); msgpack::type::variant_ref val2 = obj.as(); + EXPECT_TRUE(val2.is_boost_string_ref()); + EXPECT_EQ(val2.as_boost_string_ref(), sr); EXPECT_NO_THROW(boost::get(val2)); EXPECT_TRUE(val1 == val2); } +#endif // (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53 + // bin TEST(MSGPACK_BOOST, pack_convert_variant_ref_bin) @@ -634,13 +616,18 @@ TEST(MSGPACK_BOOST, pack_convert_variant_ref_bin) v.push_back('a'); v.push_back('b'); v.push_back('c'); - msgpack::type::variant_ref val1 = msgpack::type::raw_ref(v.data(), v.size()); + msgpack::type::raw_ref rr(v.data(), v.size()); + msgpack::type::variant_ref val1 = rr; + EXPECT_TRUE(val1.is_raw_ref()); + EXPECT_EQ(val1.as_raw_ref(), rr); msgpack::pack(ss, val1); msgpack::unpacked ret; msgpack::unpack(ret, ss.str().data(), ss.str().size()); msgpack::type::variant_ref val2 = ret.get().as(); + EXPECT_TRUE(val2.is_raw_ref()); + EXPECT_EQ(val2.as_raw_ref(), rr); EXPECT_NO_THROW(boost::get(val2)); EXPECT_TRUE(val1 == val2); } @@ -654,9 +641,14 @@ TEST(MSGPACK_BOOST, object_with_zone_variant_ref_bin) v.push_back('a'); v.push_back('b'); v.push_back('c'); - msgpack::type::variant_ref val1 = msgpack::type::raw_ref(v.data(), v.size()); + msgpack::type::raw_ref rr(v.data(), v.size()); + msgpack::type::variant_ref val1 = rr; + EXPECT_TRUE(val1.is_raw_ref()); + EXPECT_EQ(val1.as_raw_ref(), rr); msgpack::object obj(val1, z); msgpack::type::variant_ref val2 = obj.as(); + EXPECT_TRUE(val2.is_raw_ref()); + EXPECT_EQ(val2.as_raw_ref(), rr); EXPECT_NO_THROW(boost::get(val2)); EXPECT_TRUE(val1 == val2); } @@ -671,7 +663,10 @@ TEST(MSGPACK_BOOST, pack_convert_variant_ref_ext) v.push_back('a'); v.push_back('b'); v.push_back('c'); - msgpack::type::variant_ref val1(msgpack::type::ext_ref(v.data(), v.size())); + msgpack::type::ext_ref er(v.data(), v.size()); + msgpack::type::variant_ref val1(er); + EXPECT_TRUE(val1.is_ext_ref()); + EXPECT_EQ(val1.as_ext_ref(), er); msgpack::pack(ss, val1); @@ -679,11 +674,12 @@ TEST(MSGPACK_BOOST, pack_convert_variant_ref_ext) msgpack::unpack(ret, ss.str().data(), ss.str().size()); msgpack::type::variant_ref val2 = ret.get().as(); EXPECT_NO_THROW(boost::get(val2)); + EXPECT_TRUE(val2.is_ext_ref()); + EXPECT_EQ(val2.as_ext_ref(), er); EXPECT_TRUE(val1 == val2); } - TEST(MSGPACK_BOOST, object_with_zone_variant_ref_ext) { msgpack::zone z; @@ -692,9 +688,14 @@ TEST(MSGPACK_BOOST, object_with_zone_variant_ref_ext) v.push_back('a'); v.push_back('b'); v.push_back('c'); - msgpack::type::variant_ref val1(msgpack::type::ext_ref(v.data(), v.size())); + msgpack::type::ext_ref er(v.data(), v.size()); + msgpack::type::variant_ref val1(er); + EXPECT_TRUE(val1.is_ext_ref()); + EXPECT_EQ(val1.as_ext_ref(), er); msgpack::object obj(val1, z); msgpack::type::variant_ref val2 = obj.as(); + EXPECT_TRUE(val2.is_ext_ref()); + EXPECT_EQ(val2.as_ext_ref(), er); EXPECT_NO_THROW(boost::get(val2)); EXPECT_TRUE(val1 == val2); } @@ -707,16 +708,23 @@ TEST(MSGPACK_BOOST, pack_convert_variant_ref_array) std::vector v; v.push_back(msgpack::type::variant_ref(1)); v.push_back(msgpack::type::variant_ref(-1)); - v.push_back(msgpack::type::variant_ref(23.4)); std::string s("ABC"); +#if (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53 v.push_back(msgpack::type::variant_ref(boost::string_ref(s))); +#else // (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53 + v.push_back(msgpack::type::variant_ref(s)); +#endif // (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53 msgpack::type::variant_ref val1 = v; + EXPECT_TRUE(val1.is_vector()); + EXPECT_EQ(val1.as_vector(), v); msgpack::pack(ss, val1); msgpack::unpacked ret; msgpack::unpack(ret, ss.str().data(), ss.str().size()); msgpack::type::variant_ref val2 = ret.get().as(); + EXPECT_TRUE(val2.is_vector()); + EXPECT_EQ(val2.as_vector(), v); EXPECT_NO_THROW(boost::get >(val2)); EXPECT_TRUE(val1 == val2); } @@ -727,12 +735,19 @@ TEST(MSGPACK_BOOST, object_with_zone_variant_ref_array) std::vector v; v.push_back(msgpack::type::variant_ref(1)); v.push_back(msgpack::type::variant_ref(-1)); - v.push_back(msgpack::type::variant_ref(23.4)); std::string s("ABC"); +#if (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53 v.push_back(msgpack::type::variant_ref(boost::string_ref(s))); +#else // (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53 + v.push_back(msgpack::type::variant_ref(s)); +#endif // (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53 msgpack::type::variant_ref val1 = v; + EXPECT_TRUE(val1.is_vector()); + EXPECT_EQ(val1.as_vector(), v); msgpack::object obj(val1, z); msgpack::type::variant_ref val2 = obj.as(); + EXPECT_TRUE(val2.is_vector()); + EXPECT_EQ(val2.as_vector(), v); EXPECT_NO_THROW(boost::get >(val2)); EXPECT_TRUE(val1 == val2); } @@ -745,15 +760,24 @@ TEST(MSGPACK_BOOST, pack_convert_variant_ref_map) typedef std::multimap multimap_t; multimap_t v; v.insert(multimap_t::value_type(msgpack::type::variant_ref(1), msgpack::type::variant_ref(-1))); - std::string s("ABC"); - v.insert(multimap_t::value_type(msgpack::type::variant_ref(23.4), msgpack::type::variant_ref(boost::string_ref(s)))); + std::string s1("ABC"); + std::string s2("DEF"); +#if (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53 + v.insert(multimap_t::value_type(msgpack::type::variant_ref(boost::string_ref(s1)), msgpack::type::variant_ref(boost::string_ref(s2)))); +#else // (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53 + v.insert(multimap_t::value_type(msgpack::type::variant_ref(s1), msgpack::type::variant_ref(s2))); +#endif // (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53 msgpack::type::variant_ref val1 = v; + EXPECT_TRUE(val1.is_multimap()); + EXPECT_EQ(val1.as_multimap(), v); msgpack::pack(ss, val1); msgpack::unpacked ret; msgpack::unpack(ret, ss.str().data(), ss.str().size()); msgpack::type::variant_ref val2 = ret.get().as(); + EXPECT_TRUE(val2.is_multimap()); + EXPECT_EQ(val2.as_multimap(), v); EXPECT_NO_THROW(boost::get(val2)); EXPECT_TRUE(val1 == val2); } @@ -764,13 +788,23 @@ TEST(MSGPACK_BOOST, object_with_zone_variant_ref_map) typedef std::multimap multimap_t; multimap_t v; v.insert(multimap_t::value_type(msgpack::type::variant_ref(1), msgpack::type::variant_ref(-1))); - std::string s("ABC"); - v.insert(multimap_t::value_type(msgpack::type::variant_ref(23.4), msgpack::type::variant_ref(boost::string_ref(s)))); + std::string s1("ABC"); + std::string s2("DEF"); +#if (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53 + v.insert(multimap_t::value_type(msgpack::type::variant_ref(boost::string_ref(s1)), msgpack::type::variant_ref(boost::string_ref(s2)))); +#else // (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53 + v.insert(multimap_t::value_type(msgpack::type::variant_ref(s1), msgpack::type::variant_ref(s2))); +#endif // (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53 msgpack::type::variant_ref val1 = v; + EXPECT_TRUE(val1.is_multimap()); + EXPECT_EQ(val1.as_multimap(), v); msgpack::object obj(val1, z); msgpack::type::variant_ref val2 = obj.as(); + EXPECT_TRUE(val2.is_multimap()); + EXPECT_EQ(val2.as_multimap(), v); EXPECT_NO_THROW(boost::get(val2)); EXPECT_TRUE(val1 == val2); } + #endif // defined(MSGPACK_USE_BOOST)