QuickStart for C++

Version 10 by FURUHASHI Sadayuki
on Apr 15, 2011 10:42.

<< Changes from 9 to 10

compared with

Current by Lukas Vacek
on Mar 14, 2013 19:53.

Key

This line was removed.

This word was removed. This word was added.

This line was added.

Changes (1)

View Page History

...

{toc}

h1. Implementation Status

The serialization library is production-ready.

Currently, RPC implementation is testing phase. Requires newer kernel, not running on RHEL5/CentOS5.

h1. Install

Same as [C language|QuickStart for C Language].

h1. Serialization QuickStart for C+\+

h2. First program

Include `msgpack.hpp` header and link `msgpack` library to use MessagePack on your program.

{code}
#include <msgpack.hpp>
#include <vector>
#include <string>
#include <iostream>

int main(void) {
// serializes this object.
std::vector<std::string> vec;
vec.push_back("Hello");
vec.push_back("MessagePack");

// serialize it into simple buffer.
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, vec);

// deserialize it.
msgpack::unpacked msg;
msgpack::unpack(&msg, sbuf.data(), sbuf.size());

// print the deserialized object.
msgpack::object obj = msg.get();
std::cout << obj << std::endl; //=> ["Hello", "MessagePack"]

// convert it into statically typed object.
std::vector<std::string> rvec;
obj.convert(&rvec);
}
{code}

Compile it as follows:

{code}
$ g++ hello.cc -lmsgpack -o hello
$ ./hello
["Hello", "MessagePack"]
{code}

h2. Streaming feature

{code}
#include <msgpack.hpp>
#include <iostream>
#include <string>

int main(void) {
// serializes multiple objects using msgpack::packer.
msgpack::sbuffer buffer;

msgpack::packer<msgpack::sbuffer> pk(&buffer);
pk.pack(std::string("Log message ... 1"));
pk.pack(std::string("Log message ... 2"));
pk.pack(std::string("Log message ... 3"));

// deserializes these objects using msgpack::unpacker.
msgpack::unpacker pac;

// feeds the buffer.
pac.reserve_buffer(buffer.size());
memcpy(pac.buffer(), buffer.data(), buffer.size());
pac.buffer_consumed(buffer.size());

// now starts streaming deserialization.
msgpack::unpacked result;
while(pac.next(&result)) {
std::cout << result.get() << std::endl;
}

// results:
// $ g++ stream.cc -lmsgpack -o stream
// $ ./stream
// "Log message ... 1"
// "Log message ... 2"
// "Log message ... 3"

}
{code}

h3. Streaming into an array or map

{code}
#include <msgpack.hpp>
#include <iostream>
#include <string>

int main(void) {
// serializes multiple objects into one message containing an array using msgpack::packer.
msgpack::sbuffer buffer;

msgpack::packer<msgpack::sbuffer> pk(&buffer);
pk.pack_array(3)
pk.pack(std::string("Log message ... 1"));
pk.pack(std::string("Log message ... 2"));
pk.pack(std::string("Log message ... 3"));

// serializes multiple objects into one message containing a map using msgpack::packer.
msgpack::sbuffer buffer2;

msgpack::packer<msgpack::sbuffer> pk2(&buffer2);
pk2.pack_map(2)
pk2.pack(std::string("x"));
pk2.pack(3);
pk2.pack(std::string("y));
pk2.pack(3.4321);

}
{code}

h2. User-defined classes

You can use serialize/deserializes user-defined classes using MSGPACK_DEFINE macro.

{code}
#include <msgpack.hpp>
#include <vector>
#include <string>

class myclass {
private:
std::string m_str;
std::vector<int> m_vec;
public:
MSGPACK_DEFINE(m_str, m_vec);
};

int main(void) {
std::vector<myclass> vec;
// add some elements into vec...

// you can serialize myclass directly
msgpack::sbuffer sbuf;
msgpack::pack(sbuf, vec);

msgpack::unpacked msg;
msgpack::unpack(&msg, sbuf.data(), sbuf.size());

msgpack::object obj = msg.get();

// you can convert object to myclass directly
std::vector<myclass> rvec;
obj.convert(&rvec);
}
{code}