Fixed #521.

Introduced new object type `FLOAT32` and `FLOAT64`.
`FLOAT64` is equivalent to `FLOAT`.
The both internal expressions are f64(double).

include/msgpack/object.h

@@ -29,6 +29,8 @@ typedef enum {
     MSGPACK_OBJECT_BOOLEAN              = 0x01,
     MSGPACK_OBJECT_POSITIVE_INTEGER     = 0x02,
     MSGPACK_OBJECT_NEGATIVE_INTEGER     = 0x03,
+    MSGPACK_OBJECT_FLOAT32              = 0x0a,
+    MSGPACK_OBJECT_FLOAT64              = 0x04,
     MSGPACK_OBJECT_FLOAT                = 0x04,
 #if defined(MSGPACK_USE_LEGACY_NAME_AS_FLOAT)
     MSGPACK_OBJECT_DOUBLE               = MSGPACK_OBJECT_FLOAT, /* obsolete */

include/msgpack/v1/adaptor/boost/msgpack_variant.hpp

@@ -47,7 +47,7 @@ struct basic_variant :
         bool,              // BOOL
         int64_t,           // NEGATIVE_INTEGER
         uint64_t,          // POSITIVE_INTEGER
-        double,            // FLOAT
+        double,            // FLOAT32, FLOAT64
         std::string,       // STR
 #if (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53
         boost::string_ref, // STR
@@ -66,7 +66,7 @@ struct basic_variant :
         bool,              // BOOL
         int64_t,           // NEGATIVE_INTEGER
         uint64_t,          // POSITIVE_INTEGER
-        double,            // FLOAT
+        double,            // FLOAT32, FLOAT64
         std::string,       // STR
 #if (BOOST_VERSION / 100000) >= 1 && ((BOOST_VERSION / 100) % 1000) >= 53
         boost::string_ref, // STR
@@ -286,7 +286,8 @@ struct as<type::basic_variant<STR, BIN, EXT> > {
             return o.as<uint64_t>();
         case type::NEGATIVE_INTEGER:
             return o.as<int64_t>();
-        case type::FLOAT:
+        case type::FLOAT32:
+        case type::FLOAT64:
             return o.as<double>();
         case type::STR:
             return o.as<STR>();
@@ -326,7 +327,8 @@ struct convert<type::basic_variant<STR, BIN, EXT> > {
         case type::NEGATIVE_INTEGER:
             v = o.as<int64_t>();
             break;
-        case type::FLOAT:
+        case type::FLOAT32:
+        case type::FLOAT64:
             v = o.as<double>();
             break;
         case type::STR:

include/msgpack/v1/adaptor/float.hpp

@@ -27,7 +27,7 @@ namespace adaptor {
 template <>
 struct convert<float> {
     msgpack::object const& operator()(msgpack::object const& o, float& v) const {
-        if(o.type == msgpack::type::FLOAT) {
+        if(o.type == msgpack::type::FLOAT32 || o.type == msgpack::type::FLOAT64) {
             v = static_cast<float>(o.via.f64);
         }
         else if (o.type == msgpack::type::POSITIVE_INTEGER) {
@@ -56,7 +56,7 @@ struct pack<float> {
 template <>
 struct convert<double> {
     msgpack::object const& operator()(msgpack::object const& o, double& v) const {
-        if(o.type == msgpack::type::FLOAT) {
+        if(o.type == msgpack::type::FLOAT32 || o.type == msgpack::type::FLOAT64) {
             v = o.via.f64;
         }
         else if (o.type == msgpack::type::POSITIVE_INTEGER) {
@@ -85,7 +85,7 @@ struct pack<double> {
 template <>
 struct object<float> {
     void operator()(msgpack::object& o, float v) const {
-        o.type = msgpack::type::FLOAT;
+        o.type = msgpack::type::FLOAT32;
         o.via.f64 = static_cast<double>(v);
     }
 };
@@ -93,7 +93,7 @@ struct object<float> {
 template <>
 struct object<double> {
     void operator()(msgpack::object& o, double v) const {
-        o.type = msgpack::type::FLOAT;
+        o.type = msgpack::type::FLOAT64;
         o.via.f64 = v;
     }
 };

include/msgpack/v1/object.hpp

@@ -257,7 +257,11 @@ struct pack<msgpack::object> {
             o.pack_int64(v.via.i64);
             return o;
 
-        case msgpack::type::FLOAT:
+        case msgpack::type::FLOAT32:
+            o.pack_float(static_cast<float>(v.via.f64));
+            return o;
+
+        case msgpack::type::FLOAT64:
             o.pack_double(v.via.f64);
             return o;
 
@@ -311,7 +315,8 @@ struct object_with_zone<msgpack::object> {
         case msgpack::type::BOOLEAN:
         case msgpack::type::POSITIVE_INTEGER:
         case msgpack::type::NEGATIVE_INTEGER:
-        case msgpack::type::FLOAT:
+        case msgpack::type::FLOAT32:
+        case msgpack::type::FLOAT64:
             std::memcpy(&o.via, &v.via, sizeof(v.via));
             return;
 
@@ -438,7 +443,8 @@ inline bool operator==(const msgpack::object& x, const msgpack::object& y)
     case msgpack::type::NEGATIVE_INTEGER:
         return x.via.i64 == y.via.i64;
 
-    case msgpack::type::FLOAT:
+    case msgpack::type::FLOAT32:
+    case msgpack::type::FLOAT64:
         return x.via.f64 == y.via.f64;
 
     case msgpack::type::STR:
@@ -698,7 +704,11 @@ inline msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, const ms
         o.pack_int64(v.via.i64);
         return o;
 
-    case msgpack::type::FLOAT:
+    case msgpack::type::FLOAT32:
+        o.pack_float(v.via.f64);
+        return o;
+
+    case msgpack::type::FLOAT64:
         o.pack_double(v.via.f64);
         return o;
 
@@ -766,7 +776,8 @@ inline std::ostream& operator<< (std::ostream& s, const msgpack::object& o)
         s << o.via.i64;
         break;
 
-    case msgpack::type::FLOAT:
+    case msgpack::type::FLOAT32:
+    case msgpack::type::FLOAT64:
         s << o.via.f64;
         break;
 

include/msgpack/v1/object_fwd_decl.hpp

@@ -30,6 +30,8 @@ namespace type {
         BOOLEAN             = MSGPACK_OBJECT_BOOLEAN,
         POSITIVE_INTEGER    = MSGPACK_OBJECT_POSITIVE_INTEGER,
         NEGATIVE_INTEGER    = MSGPACK_OBJECT_NEGATIVE_INTEGER,
+        FLOAT32             = MSGPACK_OBJECT_FLOAT32,
+        FLOAT64             = MSGPACK_OBJECT_FLOAT64,
         FLOAT               = MSGPACK_OBJECT_FLOAT,
 #if defined(MSGPACK_USE_LEGACY_NAME_AS_FLOAT)
         DOUBLE              = MSGPACK_OBJECT_DOUBLE, // obsolete

include/msgpack/v1/unpack.hpp

@@ -184,10 +184,10 @@ inline void unpack_int64(int64_t d, msgpack::object& o)
         else { o.type = msgpack::type::NEGATIVE_INTEGER; o.via.i64 = d; } }
 
 inline void unpack_float(float d, msgpack::object& o)
-{ o.type = msgpack::type::FLOAT; o.via.f64 = d; }
+{ o.type = msgpack::type::FLOAT32; o.via.f64 = d; }
 
 inline void unpack_double(double d, msgpack::object& o)
-{ o.type = msgpack::type::FLOAT; o.via.f64 = d; }
+{ o.type = msgpack::type::FLOAT64; o.via.f64 = d; }
 
 inline void unpack_nil(msgpack::object& o)
 { o.type = msgpack::type::NIL; }

include/msgpack/v2/object_fwd_decl.hpp

@@ -25,6 +25,8 @@ using v1::type::NIL;
 using v1::type::BOOLEAN;
 using v1::type::POSITIVE_INTEGER;
 using v1::type::NEGATIVE_INTEGER;
+using v1::type::FLOAT32;
+using v1::type::FLOAT64;
 using v1::type::FLOAT;
 #if defined(MSGPACK_USE_LEGACY_NAME_AS_FLOAT)
 using v1::type::DOUBLE;

src/objectc.c

@@ -45,7 +45,10 @@ int msgpack_pack_object(msgpack_packer* pk, msgpack_object d)
     case MSGPACK_OBJECT_NEGATIVE_INTEGER:
         return msgpack_pack_int64(pk, d.via.i64);
 
-    case MSGPACK_OBJECT_FLOAT:
+    case MSGPACK_OBJECT_FLOAT32:
+        return msgpack_pack_float(pk, (float)d.via.f64);
+
+    case MSGPACK_OBJECT_FLOAT64:
         return msgpack_pack_double(pk, d.via.f64);
 
     case MSGPACK_OBJECT_STR:
@@ -191,7 +194,8 @@ void msgpack_object_print(FILE* out, msgpack_object o)
 #endif
         break;
 
-    case MSGPACK_OBJECT_FLOAT:
+    case MSGPACK_OBJECT_FLOAT32:
+    case MSGPACK_OBJECT_FLOAT64:
         fprintf(out, "%f", o.via.f64);
         break;
 
@@ -324,7 +328,8 @@ int msgpack_object_print_buffer(char *buffer, size_t buffer_size, msgpack_object
 #endif
         break;
 
-    case MSGPACK_OBJECT_FLOAT:
+    case MSGPACK_OBJECT_FLOAT32:
+    case MSGPACK_OBJECT_FLOAT64:
         ret = snprintf(aux_buffer, aux_buffer_size, "%f", o.via.f64);
         aux_buffer = aux_buffer + ret;
         aux_buffer_size = aux_buffer_size - ret;
@@ -481,7 +486,8 @@ bool msgpack_object_equal(const msgpack_object x, const msgpack_object y)
     case MSGPACK_OBJECT_NEGATIVE_INTEGER:
         return x.via.i64 == y.via.i64;
 
-    case MSGPACK_OBJECT_FLOAT:
+    case MSGPACK_OBJECT_FLOAT32:
+    case MSGPACK_OBJECT_FLOAT64:
         return x.via.f64 == y.via.f64;
 
     case MSGPACK_OBJECT_STR:

src/unpack.c

@@ -151,7 +151,7 @@ static inline int template_callback_int64(unpack_user* u, int64_t d, msgpack_obj
 static inline int template_callback_float(unpack_user* u, float d, msgpack_object* o)
 {
     MSGPACK_UNUSED(u);
-    o->type = MSGPACK_OBJECT_FLOAT;
+    o->type = MSGPACK_OBJECT_FLOAT32;
     o->via.f64 = d;
     return 0;
 }
@@ -159,7 +159,7 @@ static inline int template_callback_float(unpack_user* u, float d, msgpack_objec
 static inline int template_callback_double(unpack_user* u, double d, msgpack_object* o)
 {
     MSGPACK_UNUSED(u);
-    o->type = MSGPACK_OBJECT_FLOAT;
+    o->type = MSGPACK_OBJECT_FLOAT64;
     o->via.f64 = d;
     return 0;
 }

test/msgpack_c.cpp

@@ -225,10 +225,7 @@ TEST(MSGPACKC, simple_buffer_float)
         msgpack_unpack_return ret =
             msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj);
         EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret);
-        EXPECT_EQ(MSGPACK_OBJECT_FLOAT, obj.type);
+        EXPECT_EQ(MSGPACK_OBJECT_FLOAT32, obj.type);
-#if defined(MSGPACK_USE_LEGACY_NAME_AS_FLOAT)
-        EXPECT_EQ(MSGPACK_OBJECT_DOUBLE, obj.type);
-#endif // MSGPACK_USE_LEGACY_NAME_AS_FLOAT
         if (isnan(val)) {
             EXPECT_TRUE(isnan(obj.via.f64));
 #if defined(MSGPACK_USE_LEGACY_NAME_AS_FLOAT)
@@ -290,6 +287,7 @@ TEST(MSGPACKC, simple_buffer_double)
         msgpack_unpack_return ret =
             msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj);
         EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret);
+        EXPECT_EQ(MSGPACK_OBJECT_FLOAT64, obj.type);
         EXPECT_EQ(MSGPACK_OBJECT_FLOAT, obj.type);
 #if defined(MSGPACK_USE_LEGACY_NAME_AS_FLOAT)
         EXPECT_EQ(MSGPACK_OBJECT_DOUBLE, obj.type);

test/object.cpp

@@ -277,12 +277,17 @@ TEST(object, construct_primitive)
     EXPECT_EQ(msgpack::type::NEGATIVE_INTEGER, obj_int.type);
     EXPECT_EQ(-1, obj_int.via.i64);
 
-    msgpack::object obj_float(1.2);
+    msgpack::object obj_float(1.2F);
-    EXPECT_EQ(msgpack::type::FLOAT, obj_float.type);
+    EXPECT_EQ(msgpack::type::FLOAT32, obj_float.type);
-    EXPECT_EQ(1.2, obj_float.via.f64);
+    EXPECT_EQ(1.2F, obj_float.via.f64);
+
+    msgpack::object obj_double(1.2);
+    EXPECT_EQ(msgpack::type::FLOAT64, obj_double.type);
+    EXPECT_EQ(msgpack::type::FLOAT, obj_double.type);
+    EXPECT_EQ(1.2, obj_double.via.f64);
 #if defined(MSGPACK_USE_LEGACY_NAME_AS_FLOAT)
-    EXPECT_EQ(msgpack::type::DOUBLE, obj_float.type);
+    EXPECT_EQ(msgpack::type::DOUBLE, obj_double.type);
-    EXPECT_EQ(1.2, obj_float.via.dec);
+    EXPECT_EQ(1.2, obj_double.via.dec);
 #endif // MSGPACK_USE_LEGACY_NAME_AS_FLOAT
 
     msgpack::object obj_bool(true);
@@ -418,3 +423,25 @@ TEST(object, clone_map)
     EXPECT_EQ(h.get(), obj);
     EXPECT_EQ(sz1, msgpack::aligned_zone_size(h.get()));
 }
+
+TEST(object, pack_float)
+{
+    msgpack::object obj(1.2F);
+    std::stringstream ss1;
+    msgpack::pack(ss1, obj);
+    std::stringstream ss2;
+    msgpack::pack(ss2, 1.2F);
+    EXPECT_EQ(5, ss1.str().size());
+    EXPECT_EQ(ss1.str(), ss2.str());
+}
+
+TEST(object, pack_double)
+{
+    msgpack::object obj(1.2);
+    std::stringstream ss1;
+    msgpack::pack(ss1, obj);
+    std::stringstream ss2;
+    msgpack::pack(ss2, 1.2);
+    EXPECT_EQ(9, ss1.str().size());
+    EXPECT_EQ(ss1.str(), ss2.str());
+}

test/object_with_zone.cpp

@@ -176,6 +176,7 @@ TEST(object_with_zone, float)
     float v = 1.23f;
     msgpack::zone z;
     msgpack::object obj(v, z);
+    EXPECT_EQ(obj.type, msgpack::type::FLOAT32);
     EXPECT_TRUE(fabs(obj.as<float>() - v) <= kEPS);
     v = 4.56f;
     EXPECT_TRUE(fabs(obj.as<float>() - static_cast<float>(1.23)) <= kEPS);
@@ -187,6 +188,7 @@ TEST(object_with_zone, double)
     double v = 1.23;
     msgpack::zone z;
     msgpack::object obj(v, z);
+    EXPECT_EQ(obj.type, msgpack::type::FLOAT64);
     EXPECT_TRUE(fabs(obj.as<double>() - v) <= kEPS);
     v = 4.56;
     EXPECT_TRUE(fabs(obj.as<double>() - 1.23) <= kEPS);