request request::parse(zmq::message_t& msg) {
	request req;
	std::string result(static_cast<const char *>(msg.data()), msg.size());

	std::vector<std::string> results = utils::split(result, " ", 3);

	req.sender = results[0];
	req.conn_id = results[1];
	req.path = results[2];

	std::string body;
	std::string ign;

	req.headers = utils::parse_json(utils::parse_netstring(results[3], body));

	req.body = utils::parse_netstring(body, ign);

	//check disconnect flag
	req.disconnect = false;
	for (std::vector<header>::const_iterator it = req.headers.begin();
			it != req.headers.end(); ++it) {
		if (it->first == "METHOD" && it->second == "JSON" &&
				req.body == "{\"type\":\"disconnect\"}") {
			req.disconnect = true;
			break;
		}
	}

	return req;
}

bool SocketToTF::updateTransformFromSocketTransform(zmq::message_t& message) {
	socket_to_tf::TransformStamped transform;
	boost::iostreams::basic_array_source<char> source((char*)message.data(), message.size());
	boost::iostreams::stream<boost::iostreams::basic_array_source <char> > input_stream(source);
	boost::archive::binary_iarchive ia(input_stream);
	ia >> transform;

	if (boost::math::isfinite(transform.x) && boost::math::isfinite(transform.y) && boost::math::isfinite(transform.z) &&
			boost::math::isfinite(transform.qx) && boost::math::isfinite(transform.qy) && boost::math::isfinite(transform.qz) && boost::math::isfinite(transform.qw)) {
		transform_stamped_.transform.translation.x = transform.x;
		transform_stamped_.transform.translation.y = transform.y;
		transform_stamped_.transform.translation.z = transform.z;
		transform_stamped_.transform.rotation.x = transform.qx;
		transform_stamped_.transform.rotation.y = transform.qy;
		transform_stamped_.transform.rotation.z = transform.qz;
		transform_stamped_.transform.rotation.w = transform.qw;
		transform_stamped_.child_frame_id = transform.source_frame;
		transform_stamped_.header.frame_id = transform.target_frame;
		transform_stamped_.header.stamp.sec = transform.timestamp_seconds;
		transform_stamped_.header.stamp.nsec = transform.timestamp_nanoseconds;

		std::stringstream ss_data;
		ss_data << "{ " << transform.x << " " << transform.y << " " << transform.z << " " << transform.qx << " " << transform.qy << " " << transform.qz << " " << transform.qw << " " << transform.source_frame << " " << transform.target_frame << " }";
		std::string transform_data = ss_data.str();
		ROS_INFO_STREAM("Received message with size " << message.size() << ": " << transform_data);

		return true;
	}

	return false;
}

 inline T
 get_string(zmq::message_t& message, size_t limit)
 {
   return T(
     static_cast<char*>(message.data()), std::min(message.size(), limit)
   );
 }

 /**
  * Return memory region as RawMessage. No copying takes place.
  */
 ZMQMESSAGE_DLL_PUBLIC
 inline
 RawMessage
 get_raw(zmq::message_t& message)
 {
   return RawMessage(message.data(), message.size());
 }

 inline
 T
 get(zmq::message_t& message,
   typename Private::EnableIf<Private::IsStr<T>::value>::type* = 0)
 {
   return T(static_cast<char*>(message.data()), message.size());
 }

 ZMQMESSAGE_DLL_PUBLIC
 inline
 T
 get_string(zmq::message_t& message)
 {
   return T(static_cast<char*>(message.data()), message.size());
 }

	Msg(const zmq::message_t &message) {
	
		msgpack::unpacked msg;
		msgpack::unpack(&msg, (const char *)message.data(), message.size());
		msgpack::object obj = msg.get();
		obj.convert(&data);
		
	}

    static bool unpack(zmq::message_t& message, std::string& value) {
        value.assign(
            static_cast<const char*>(message.data()),
            message.size()
        );

        return true;
    }

 /**
  * Compare message contents to specified memory region.
  * @return like @c memcmp
  */
 ZMQMESSAGE_DLL_PUBLIC
 inline
 int
 msgcmp(zmq::message_t& message, const char* str, size_t len)
 {
   int ret = memcmp(message.data(), str, std::min(message.size(), len));
   return ret ? ret : message.size() - len;
 }

 ZMQMESSAGE_DLL_PUBLIC
 inline
 void
 get(zmq::message_t& message, T& t,
   typename Private::EnableIf<Private::IsStr<T>::value>::type* = 0)
 {
   t = T(static_cast<char*>(message.data()), message.size());
 }

bool SocketToTF::updateTransformFromSocketPointTranslation(zmq::message_t& message) {
	socket_to_tf::PointTranslation point_translation;

	if (use_boost_to_parse_point_translation_message_) {
		boost::iostreams::basic_array_source<char> source((char*)message.data(), message.size());
		boost::iostreams::stream<boost::iostreams::basic_array_source <char> > input_stream(source);
		boost::archive::binary_iarchive ia(input_stream);
		ia >> point_translation;
	} else {

 static inline
 void
 unpack(/* const */ zmq::message_t& message,
        std::string& value)
 {
     value.assign(
         static_cast<const char*>(message.data()),
         message.size()
     );
 }

    static bool recv_zmq_message(zmq::socket_t& sock,
                                 zmq::message_t& msg,
                                 T& object,
                                 int flags = ZMQ_NOBLOCK)
    {
        if (!sock.recv(&msg, flags)) {
            return false;
        }

        memcpy(&object, msg.data(), msg.size());
        return true;
    }

 static inline
 void
 pack(zmq::message_t& message,
      const std::string& value)
 {
     message.rebuild(value.size());
     
     std::memcpy(
         message.data(),
         value.data(),
         value.size()
     );
 }

bool
nutils::recv_zmq_message(zmq::socket_t& sock,
						 zmq::message_t& msg,
						 std::string& str,
						 int flags)
{
    if (!sock.recv(&msg, flags)) {
        return false;
    }

    str.clear();
    str.append(reinterpret_cast<char*>(msg.data()), msg.size());
    return true;
}

Request::Request(const zmq::message_t& message) : m_valid(false)
{
    std::string in(static_cast<const char*>(message.data()), message.size());
    std::istringstream stream(in);

    std::string path;
    std::string headers;

    // Decode message
    stream >> m_sender >> m_connectionId;
    stream >> path;
    headers = utility::readNetString(stream);
    m_body = utility::readNetString(stream);

    // Decode path
    if(!utility::decodeUrl(path, m_path)) {
        // TODO: Throw exception
        m_path = path;
    }

    // Parse http header
    Json::Reader reader;
    if ( !reader.parse(headers, m_headers) )
    {
        // TODO: Throw exception
    }

    // Parse json body
    if(m_headers.isMember("METHOD") && m_headers["METHOD"] == "JSON") {
        if ( !reader.parse(m_body, m_jsonBody) )
        {
            // TODO: Throw exception
        }
    }

    // Parse query parameters
    std::string query = m_headers.get("QUERY", std::string()).asString();
    if(!query.empty()) {
        std::string decodedQuery;
        if(utility::decodeUrl(query, decodedQuery)) {
            utility::parseQuery(decodedQuery, m_query);
        }
        else {
            // TODO: Throw exception
        }
    }

    m_valid = true;
}

 ZMQMESSAGE_DLL_PUBLIC
 inline
 void
 get_bin(zmq::message_t& message, T& t)
 {
   t = *(reinterpret_cast<T*>(message.data()));
 }

/** Unpacks a message from a zeromq message */
static Message unpack(const zmq::message_t &msg) {
    auto begin = reinterpret_cast<const capnp::word*>(msg.data()); // NOLINT
    auto end = reinterpret_cast<const capnp::word*>(static_cast<const char*>(msg.data()) + msg.size()); // NOLINT
    kj::ArrayPtr<const capnp::word> ptr(begin, end);
    capnp::FlatArrayMessageReader msg_reader(ptr);
    capnqml::Message ret;
    auto reader = msg_reader.getRoot<serialize::Message>();
    ret.setType(static_cast<Message::Type>(reader.getType()));
    ret.setEndpoint(reader.getEndpoint().cStr());
    ret.setExpectsAnswer(reader.getExpectsAnswer());
    ret.setId(reader.getId());
    ret.setOriginator(reader.getOriginator());
    ret.setSchema(reader.getSchema().cStr());
    auto payload = reader.getPayload();
    Message::Payload data(payload.begin(), payload.end());
    ret.setData(std::move(data));
    return ret;
}

void
blastbeat_t::on_body(const std::string& sid,
                     zmq::message_t& body)
{
    stream_map_t::iterator it(
        m_streams.find(sid)
    );

    if(it == m_streams.end()) {
        COCAINE_LOG_WARNING(m_log, "received an unknown session body");
        return;
    }

    try {
        it->second->write(
            static_cast<const char*>(body.data()),
            body.size()
        );
    } catch(const cocaine::error_t& e) {
        COCAINE_LOG_ERROR(m_log, "unable to push a body chunk to a session - %s", e.what());
    }
}

 /**
  * Copy contents of one message part to another
  */
 inline void
 copy_msg(zmq::message_t& target, zmq::message_t& source)
   throw(ZmqErrorType)
 {
   try
   {
     target.copy(&source);
   }
   catch (const zmq::error_t& e)
   {
     throw_zmq_exception(e);
   }
 }