I'm currently using this implementation of MessagePack for serializing/deserializing somewhat complex structures in a project I've been developing.

I want to be able to send and receive serialized MessagePack Objects that can then be parsed and constructed in order to build the "complex structure" on the receiving end.

The complex structure in question is a Blockchain. My Blockchain class consists of an array of Blocks (Block class instances) which themselves contain an array of Transactions (Transaction class instances).

I was able to serialize the Blockchain class by implementing serialize methods in each of the classes: Blockchain::serialize(), Block::serialize(), Transaction::serialize().

After serializing the Blockchain, I would send the dump() output of that object to the receiving end, in order for it to construct it's own Blockchain from the incoming packet.

The problem is that, after serializing the Blockchain, I can access it's elements on the Sender Node (the one where the serialized blockchain originated from); however, I cannot to this on the Receiver Node. I get the MessagePack dump string but I am not able to parse the incoming buffer. I've checked the parse error and it's populated with the message "end of buffer".

I'm not sure if this problem has to do with the way I try to serialize and construct the classes, or if it has to do with how I send the MessagePack dump() output to the receiver Node.

This issue might not have been very explicit but I am not sure how I can explain it better. I'm just looking for help to figure out what's causing this. I can get into further detail if someone's interested in helping out.

Also, keep in mind that I am a young dev, and I'm quite new to C++. The code may look like crap, be advised.

Hello again!

I've been working to support the C++ streams API on my fork (working branch: https://github.com/alwaysmpe/msgpack11/tree/stream_api) so thought I would open this issue to discuss.

It's a work in progress at the moment, but stream insertion is (I believe) working correctly and I've integrated some tests into the existing code. I will write separate tests but, as I said, it's a work in progress (and I've not used gtest before so getting started quickly by modifying the existing tests). I probably won't be able to finish the stream extraction stuff until next week.

Can be fixed with following patch:

diff --git a/msgpack11.cpp b/msgpack11.cpp
index ef87111..6bc6342 100644
--- a/msgpack11.cpp
+++ b/msgpack11.cpp
@@ -409,21 +409,21 @@ protected:
 bool equal_uint64_int64( uint64_t uint64_value, int64_t int64_value )
 {
     bool const is_positive = 0 <= int64_value;
-    bool const is_leq_int64_max = uint64_value <= std::numeric_limits<int64_t>::max();
+    bool const is_leq_int64_max = uint64_value <= static_cast<std::uint64_t>(std::numeric_limits<int64_t>::max());
     return is_positive && is_leq_int64_max && ( uint64_value == static_cast<uint64_t>(int64_value));
 }
 
 bool less_uint64_int64( uint64_t uint64_value, int64_t int64_value )
 {
     bool const is_positive = 0 <= int64_value;
-    bool const is_leq_int64_max = uint64_value <= std::numeric_limits<int64_t>::max();
+    bool const is_leq_int64_max = uint64_value <= static_cast<std::uint64_t>(std::numeric_limits<int64_t>::max());
     return is_positive && is_leq_int64_max && ( uint64_value < static_cast<uint64_t>(int64_value));
 }
 
 bool less_int64_uint64( int64_t int64_value, uint64_t uint64_value )
 {
     bool const is_negative = int64_value < 0;
-    bool const is_gt_int64_max = std::numeric_limits<int64_t>::max() < uint64_value;
+    bool const is_gt_int64_max = static_cast<std::uint64_t>(std::numeric_limits<int64_t>::max()) < uint64_value;
     return is_negative || is_gt_int64_max || ( static_cast<uint64_t>(int64_value) < uint64_value );
 }

Looking at the implementation of MsgPack is_int() it only returns true for int_32_t

To me the logical approach would be to mimic JSON type specification, ie is_int() would return true for all encoded int types (including unsigned) and is_number() should return true for all numbers (floats and ints).

therefore change is_int() to: is_int(){ return is_int8() || is_int16() || is_int32() || is_int64() || is_uint8 || is_uint16 || is_uint32() || is_uint64();} and is_number() to: is_number(){return is_float32() || is_float64() || is_int();}

It might be possible to make this cleaner using bitmasks but I've not had coffee yet so can't think.

But thanks for a nice c++11 friendly implementation!

When building v0.0.7 for Android with NDK 15.0.4075724 using Clang I got a following error message:

msgpack11.cpp:360:58: error: invalid operands to binary expression ('nullptr_t' and 'nullptr_t')
    return is_less_type || (is_same_type && (m_value < static_cast<const Value<tag, T> *>(other)->m_value)); 

msgpack11.cpp:623:5: note: in instantiation of member function 'msgpack11::Value<msgpack11::MsgPack::Type::NUL, nullptr_t>::less' requested here
    MsgPackNull() : Value(nullptr) {}  

As discussed in issue #7 I've added support for the C++ streams API. As we're both happy and there has been no noticeable performance impact, and all tests pass I propose merging.

All ints should return true for is_int(), regardless of how many bits are used to encode and all numbers should return true for is_number(). Use bit-mask to implement efficiently. (NB: All ints are numbers, but not all numbers are ints).

This is in response to issue #5

Hi,

I was looking over your code and noticed that all the NumberValue implementations are all comparing to float64_value(). Is this what you meant to do? I would assume for UINT32 you would want to call "other->uint32_value()" as an example.

class MsgPackUint32 final : public NumberValue<MsgPack::UINT32, uint32_t> { bool equals(const MsgPackValue * other) const override { return m_value == other->float64_value(); } bool less(const MsgPackValue * other) const override { return m_value < other->float64_value(); }

Hello, is this library suited only for packing jsons? What if I just need to serialize data in such a format:

struct example {
    string id;
    vector<object> v;
};

struct object {
    long a;
    double b;
    double c;
    int d;
    bool e;
}

? Without any {, ", keys and so on?

Looks like the Visual Studio compiler doesn't like a few things in here if "warning as error" is turned on:

a) the dump methods all fail with "warning 4309: 'argument: truncation of constant value" b) the int/uint comparitor functions give a "warning 4018: ',=': signed/unsigned mismatch"

Any thoughts on whether it's safe to ignore those warnings? It seems like it's not...

Would be nice to have some parsing example , I suppose if I have an object containing a string with "route" key I can get the data like this:

msg["route"].string_value()

but having a complete example would be great.