Replaced boost::variant typedef with a class inheriting boost::variant.

Added char const* to std::string conversion constructor.
Added integer familiy constructor. int64_t is only used when an actual value is negative.

Clients no longer need to use casts for std::string and ingeter family.

include/msgpack/adaptor/boost/msgpack_variant.hpp

@@ -46,46 +46,10 @@ MSGPACK_API_VERSION_NAMESPACE(v1) {
 
 namespace type {
 
-typedef boost::make_recursive_variant<
+struct 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<char>, // BIN
-    msgpack::type::raw_ref, // BIN
-    ext,               // EXT
-    ext_ref,           // EXT
-    std::vector<boost::recursive_variant_>, // ARRAY
-    std::map<boost::recursive_variant_, boost::recursive_variant_>, // MAP
-    std::multimap<boost::recursive_variant_, boost::recursive_variant_> // MAP
->::type variant;
 
 namespace detail {
-struct ref_tag {
+typedef boost::variant<
-#if defined(MSGPACK_USE_CPP03)
-private:
-    ref_tag();
-#else  // defined(MSGPACK_USE_CPP03)
-    ref_tag() = delete;
-#endif // defined(MSGPACK_USE_CPP03)
-public:
-    MSGPACK_DEFINE();
-};
-
-inline bool operator<(ref_tag const& lhs, ref_tag const& rhs) {
-    return &lhs < &rhs;
-}
-inline bool operator==(ref_tag const& lhs, ref_tag const& rhs) {
-    return &lhs == &rhs;
-}
-} // namespace detail
-
-typedef boost::make_recursive_variant<
     nil,               // NIL
     bool,              // BOOL
     int64_t,           // NEGATIVE_INTEGER
@@ -99,17 +63,130 @@ typedef boost::make_recursive_variant<
     msgpack::type::raw_ref, // BIN
     ext,               // EXT
     ext_ref,           // EXT
-    std::vector<boost::recursive_variant_>, // ARRAY
+    boost::recursive_wrapper<std::vector<variant> >, // ARRAY
-    std::map<boost::recursive_variant_, boost::recursive_variant_>, // MAP
+    boost::recursive_wrapper<std::map<variant, variant> >, // MAP
-    std::multimap<boost::recursive_variant_, boost::recursive_variant_>, // MAP
+    boost::recursive_wrapper<std::multimap<variant, variant> >// MAP
-    detail::ref_tag
+> variant_imp;
->::type variant_ref;
+
+} // namespace detail
+
+struct variant : detail::variant_imp {
+    typedef detail::variant_imp base;
+    variant() {}
+    template <typename T>
+    variant(T const& t):base(t) {}
+    variant(char const* p):base(std::string(p)) {}
+    variant(char v) {
+        int_init(v);
+    }
+    variant(signed char v) {
+        int_init(v);
+    }
+    variant(unsigned char v):base(uint64_t(v)) {}
+    variant(signed int v) {
+        int_init(v);
+    }
+    variant(unsigned int v):base(uint64_t(v)) {}
+    variant(signed long v) {
+        int_init(v);
+    }
+    variant(unsigned long v):base(uint64_t(v)) {}
+    variant(signed long long v) {
+        int_init(v);
+    }
+    variant(unsigned long long v):base(uint64_t(v)) {}
+private:
+    template <typename T>
+    void int_init(T v) {
+        if (v < 0) {
+            static_cast<base&>(*this) = int64_t(v);
+        }
+        else {
+            static_cast<base&>(*this) = uint64_t(v);
+        }
+    }
+};
+
+inline bool operator<(variant const& lhs, variant const& rhs) {
+    return static_cast<variant::base const&>(lhs) < static_cast<variant::base const&>(rhs);
+}
+
+inline bool operator==(variant const& lhs, variant const& rhs) {
+    return static_cast<variant::base const&>(lhs) == static_cast<variant::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
+#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<char>, // BIN
+    msgpack::type::raw_ref, // BIN
+    ext,               // EXT
+    ext_ref,           // EXT
+    boost::recursive_wrapper<std::vector<variant_ref> >, // ARRAY
+    boost::recursive_wrapper<std::map<variant_ref, variant_ref> >, // MAP
+    boost::recursive_wrapper<std::multimap<variant_ref, variant_ref> >// MAP
+> variant_ref_imp;
+
+} // namespace detail
+
+struct variant_ref : detail::variant_ref_imp {
+    typedef detail::variant_ref_imp base;
+    variant_ref() {}
+    template <typename T>
+    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 <typename T>
+    void int_init(T v) {
+        if (v < 0) {
+            static_cast<base&>(*this) = int64_t(v);
+        }
+        else {
+            static_cast<base&>(*this) = uint64_t(v);
+        }
+    }
+};
+
+inline bool operator<(variant_ref const& lhs, variant_ref const& rhs) {
+    return static_cast<variant_ref::base const&>(lhs) < static_cast<variant_ref::base const&>(rhs);
+}
+
+inline bool operator==(variant_ref const& lhs, variant_ref const& rhs) {
+    return static_cast<variant_ref::base const&>(lhs) == static_cast<variant_ref::base const&>(rhs);
+}
 
 } // namespace type
 
 
-
-
 namespace adaptor {
 
 #if !defined (MSGPACK_USE_CPP03)

test/boost_variant.cpp

@@ -113,7 +113,7 @@ TEST(MSGPACK_BOOST, object_with_zone_variant_bool)
 TEST(MSGPACK_BOOST, pack_convert_variant_positive_integer)
 {
     std::stringstream ss;
-    msgpack::type::variant val1 = uint64_t(123);
+    msgpack::type::variant val1 = 123;
 
     msgpack::pack(ss, val1);
 
@@ -126,7 +126,7 @@ TEST(MSGPACK_BOOST, pack_convert_variant_positive_integer)
 
 TEST(MSGPACK_BOOST, object_variant_positive_integer)
 {
-    msgpack::type::variant val1 = uint64_t(123);
+    msgpack::type::variant val1 = 123;
     msgpack::object obj(val1);
     msgpack::type::variant val2 = obj.as<msgpack::type::variant>();
     EXPECT_NO_THROW(boost::get<uint64_t>(val2));
@@ -136,7 +136,7 @@ TEST(MSGPACK_BOOST, object_variant_positive_integer)
 TEST(MSGPACK_BOOST, object_with_zone_variant_positive_integer)
 {
     msgpack::zone z;
-    msgpack::type::variant val1 = uint64_t(123);
+    msgpack::type::variant val1 = 123;
     msgpack::object obj(val1, z);
     msgpack::type::variant val2 = obj.as<msgpack::type::variant>();
     EXPECT_NO_THROW(boost::get<uint64_t>(val2));
@@ -148,7 +148,7 @@ TEST(MSGPACK_BOOST, object_with_zone_variant_positive_integer)
 TEST(MSGPACK_BOOST, pack_convert_variant_negative_integer)
 {
     std::stringstream ss;
-    msgpack::type::variant val1 = int64_t(-123);
+    msgpack::type::variant val1 = -123;
 
     msgpack::pack(ss, val1);
 
@@ -161,7 +161,7 @@ TEST(MSGPACK_BOOST, pack_convert_variant_negative_integer)
 
 TEST(MSGPACK_BOOST, object_variant_negative_integer)
 {
-    msgpack::type::variant val1 = int64_t(-123);
+    msgpack::type::variant val1 = -123;
     msgpack::object obj(val1);
     msgpack::type::variant val2 = obj.as<msgpack::type::variant>();
     EXPECT_NO_THROW(boost::get<int64_t>(val2));
@@ -171,7 +171,7 @@ TEST(MSGPACK_BOOST, object_variant_negative_integer)
 TEST(MSGPACK_BOOST, object_with_zone_variant_negative_integer)
 {
     msgpack::zone z;
-    msgpack::type::variant val1 = int64_t(-123);
+    msgpack::type::variant val1 = -123;
     msgpack::object obj(val1, z);
     msgpack::type::variant val2 = obj.as<msgpack::type::variant>();
     EXPECT_NO_THROW(boost::get<int64_t>(val2));
@@ -218,7 +218,7 @@ TEST(MSGPACK_BOOST, object_with_zone_variant_float)
 TEST(MSGPACK_BOOST, pack_convert_variant_str)
 {
     std::stringstream ss;
-    msgpack::type::variant val1 = std::string("ABC");
+    msgpack::type::variant val1 = "ABC";
 
     msgpack::pack(ss, val1);
 
@@ -234,7 +234,7 @@ TEST(MSGPACK_BOOST, pack_convert_variant_str)
 TEST(MSGPACK_BOOST, object_with_zone_variant_str)
 {
     msgpack::zone z;
-    msgpack::type::variant val1 = std::string("ABC");
+    msgpack::type::variant val1 = "ABC";
     msgpack::object obj(val1, z);
     msgpack::type::variant val2 = obj.as<msgpack::type::variant>();
     EXPECT_NO_THROW(boost::get<std::string>(val2));
@@ -319,10 +319,10 @@ TEST(MSGPACK_BOOST, pack_convert_variant_array)
 {
     std::stringstream ss;
     std::vector<msgpack::type::variant> v;
-    v.push_back(msgpack::type::variant(uint64_t(1)));
+    v.push_back(msgpack::type::variant(1));
-    v.push_back(msgpack::type::variant(int64_t(-1)));
+    v.push_back(msgpack::type::variant(-1));
     v.push_back(msgpack::type::variant(23.4));
-    v.push_back(msgpack::type::variant(std::string("ABC")));
+    v.push_back(msgpack::type::variant("ABC"));
     msgpack::type::variant val1 = v;
 
     msgpack::pack(ss, val1);
@@ -338,10 +338,10 @@ TEST(MSGPACK_BOOST, object_with_zone_variant_array)
 {
     msgpack::zone z;
     std::vector<msgpack::type::variant> v;
-    v.push_back(msgpack::type::variant(uint64_t(1)));
+    v.push_back(msgpack::type::variant(1));
-    v.push_back(msgpack::type::variant(int64_t(-1)));
+    v.push_back(msgpack::type::variant(-1));
     v.push_back(msgpack::type::variant(23.4));
-    v.push_back(msgpack::type::variant(std::string("ABC")));
+    v.push_back(msgpack::type::variant("ABC"));
     msgpack::type::variant val1 = v;
     msgpack::object obj(val1, z);
     msgpack::type::variant val2 = obj.as<msgpack::type::variant>();
@@ -356,8 +356,8 @@ TEST(MSGPACK_BOOST, pack_convert_variant_map)
     std::stringstream ss;
     typedef std::multimap<msgpack::type::variant, msgpack::type::variant> multimap_t;
     multimap_t v;
-    v.insert(multimap_t::value_type(msgpack::type::variant(uint64_t(1)), msgpack::type::variant(int64_t(-1))));
+    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(std::string("ABC"))));
+    v.insert(multimap_t::value_type(msgpack::type::variant(23.4), msgpack::type::variant("ABC")));
     msgpack::type::variant val1 = v;
 
     msgpack::pack(ss, val1);
@@ -374,8 +374,8 @@ TEST(MSGPACK_BOOST, object_with_zone_variant_map)
     msgpack::zone z;
     typedef std::multimap<msgpack::type::variant, msgpack::type::variant> multimap_t;
     multimap_t v;
-    v.insert(multimap_t::value_type(msgpack::type::variant(uint64_t(1)), msgpack::type::variant(int64_t(-1))));
+    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(std::string("ABC"))));
+    v.insert(multimap_t::value_type(msgpack::type::variant(23.4), msgpack::type::variant("ABC")));
     msgpack::type::variant val1 = v;
     msgpack::object obj(val1, z);
     msgpack::type::variant val2 = obj.as<msgpack::type::variant>();
@@ -489,7 +489,7 @@ TEST(MSGPACK_BOOST, object_with_zone_variant_ref_bool)
 TEST(MSGPACK_BOOST, pack_convert_variant_ref_positive_integer)
 {
     std::stringstream ss;
-    msgpack::type::variant_ref val1 = uint64_t(123);
+    msgpack::type::variant_ref val1 = 123;
 
     msgpack::pack(ss, val1);
 
@@ -502,7 +502,7 @@ TEST(MSGPACK_BOOST, pack_convert_variant_ref_positive_integer)
 
 TEST(MSGPACK_BOOST, object_variant_ref_positive_integer)
 {
-    msgpack::type::variant_ref val1 = uint64_t(123);
+    msgpack::type::variant_ref val1 = 123;
     msgpack::object obj(val1);
     msgpack::type::variant_ref val2 = obj.as<msgpack::type::variant_ref>();
     EXPECT_NO_THROW(boost::get<uint64_t>(val2));
@@ -512,7 +512,7 @@ TEST(MSGPACK_BOOST, object_variant_ref_positive_integer)
 TEST(MSGPACK_BOOST, object_with_zone_variant_ref_positive_integer)
 {
     msgpack::zone z;
-    msgpack::type::variant_ref val1 = uint64_t(123);
+    msgpack::type::variant_ref val1 = 123;
     msgpack::object obj(val1, z);
     msgpack::type::variant_ref val2 = obj.as<msgpack::type::variant_ref>();
     EXPECT_NO_THROW(boost::get<uint64_t>(val2));
@@ -524,7 +524,7 @@ TEST(MSGPACK_BOOST, object_with_zone_variant_ref_positive_integer)
 TEST(MSGPACK_BOOST, pack_convert_variant_ref_negative_integer)
 {
     std::stringstream ss;
-    msgpack::type::variant_ref val1 = int64_t(-123);
+    msgpack::type::variant_ref val1 = -123;
 
     msgpack::pack(ss, val1);
 
@@ -537,7 +537,7 @@ TEST(MSGPACK_BOOST, pack_convert_variant_ref_negative_integer)
 
 TEST(MSGPACK_BOOST, object_variant_ref_negative_integer)
 {
-    msgpack::type::variant_ref val1 = int64_t(-123);
+    msgpack::type::variant_ref val1 = -123;
     msgpack::object obj(val1);
     msgpack::type::variant_ref val2 = obj.as<msgpack::type::variant_ref>();
     EXPECT_NO_THROW(boost::get<int64_t>(val2));
@@ -547,7 +547,7 @@ TEST(MSGPACK_BOOST, object_variant_ref_negative_integer)
 TEST(MSGPACK_BOOST, object_with_zone_variant_ref_negative_integer)
 {
     msgpack::zone z;
-    msgpack::type::variant_ref val1 = int64_t(-123);
+    msgpack::type::variant_ref val1 = -123;
     msgpack::object obj(val1, z);
     msgpack::type::variant_ref val2 = obj.as<msgpack::type::variant_ref>();
     EXPECT_NO_THROW(boost::get<int64_t>(val2));
@@ -699,8 +699,8 @@ TEST(MSGPACK_BOOST, pack_convert_variant_ref_array)
 {
     std::stringstream ss;
     std::vector<msgpack::type::variant_ref> v;
-    v.push_back(msgpack::type::variant_ref(uint64_t(1)));
+    v.push_back(msgpack::type::variant_ref(1));
-    v.push_back(msgpack::type::variant_ref(int64_t(-1)));
+    v.push_back(msgpack::type::variant_ref(-1));
     v.push_back(msgpack::type::variant_ref(23.4));
     std::string s("ABC");
     v.push_back(msgpack::type::variant_ref(boost::string_ref(s)));
@@ -719,8 +719,8 @@ TEST(MSGPACK_BOOST, object_with_zone_variant_ref_array)
 {
     msgpack::zone z;
     std::vector<msgpack::type::variant_ref> v;
-    v.push_back(msgpack::type::variant_ref(uint64_t(1)));
+    v.push_back(msgpack::type::variant_ref(1));
-    v.push_back(msgpack::type::variant_ref(int64_t(-1)));
+    v.push_back(msgpack::type::variant_ref(-1));
     v.push_back(msgpack::type::variant_ref(23.4));
     std::string s("ABC");
     v.push_back(msgpack::type::variant_ref(boost::string_ref(s)));
@@ -738,7 +738,7 @@ TEST(MSGPACK_BOOST, pack_convert_variant_ref_map)
     std::stringstream ss;
     typedef std::multimap<msgpack::type::variant_ref, msgpack::type::variant_ref> multimap_t;
     multimap_t v;
-    v.insert(multimap_t::value_type(msgpack::type::variant_ref(uint64_t(1)), msgpack::type::variant_ref(int64_t(-1))));
+    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))));
     msgpack::type::variant_ref val1 = v;
@@ -757,7 +757,7 @@ TEST(MSGPACK_BOOST, object_with_zone_variant_ref_map)
     msgpack::zone z;
     typedef std::multimap<msgpack::type::variant_ref, msgpack::type::variant_ref> multimap_t;
     multimap_t v;
-    v.insert(multimap_t::value_type(msgpack::type::variant_ref(uint64_t(1)), msgpack::type::variant_ref(int64_t(-1))));
+    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))));
     msgpack::type::variant_ref val1 = v;