Overview Tutorial API reference Examples Build Download

ZmqMessage 0.1 - 21 Oct 2011

---

include/ZmqTools.hpp

Go to the documentation of this file.

#ifndef ZMQMESSAGE_ZMQ_TOOLS_INCLUDED_
#define ZMQMESSAGE_ZMQ_TOOLS_INCLUDED_

#include <cstdlib>
#include <ctime>

#include <string>
#include <sstream>

#include "zmqmessage/Config.hpp"
#include "zmqmessage/MetaTypes.hpp"
#include "zmqmessage/RawMessage.hpp"

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

  template <typename T>
  inline T
  get_bin(zmq::message_t& message)
  {
    return *(reinterpret_cast<T*>(message.data()));
  }

  template <typename T>
  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());
  }

  template <typename T>
  inline
  T
  get(zmq::message_t& message,
    typename Private::DisableIf<Private::IsStr<T>::value>::type* = 0,
    typename Private::DisableIf<Private::IsRaw<T>::value>::type* = 0)
  {
    std::stringstream ss;
    ss.write(static_cast<char*>(message.data()), message.size());
    T t;
    ss >> t;
    return t;
  }

  template <typename T>
  inline
  T
  get(zmq::message_t& message,
    typename Private::DisableIf<Private::IsStr<T>::value>::type* = 0,
    typename Private::EnableIf<Private::IsRaw<T>::value>::type* = 0)
  {
    return get_bin<T>(message);
  }

  template <typename T>
  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());
  }

  template <typename T>
  inline
  void
  get(zmq::message_t& message, T& t,
    typename Private::DisableIf<Private::IsStr<T>::value>::type* = 0,
    typename Private::DisableIf<Private::IsRaw<T>::value>::type* = 0)
  {
    std::stringstream ss;
    ss.write(static_cast<char*>(message.data()), message.size());
    ss >> t;
  }

  template <typename T>
  inline
  void
  get(zmq::message_t& message, T& t,
    typename Private::DisableIf<Private::IsStr<T>::value>::type* = 0,
    typename Private::EnableIf<Private::IsRaw<T>::value>::type* = 0)
  {
    get_bin(message, t);
  }

  template <typename T>
  inline
  T
  get(zmq::message_t& message, bool binary_mode)
  {
    return binary_mode ? get_bin<T>(message) : get<T>(message);
  }

  template <typename T>
  inline
  void
  get(zmq::message_t& message, T& t,  bool binary_mode)
  {
    binary_mode ? get_bin(message, t) : get(message, t);
  }

  inline RawMessage
  get_raw(zmq::message_t& message)
  {
    return RawMessage(message.data(), message.size());
  }

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

  inline ZMQMESSAGE_STRING_CLASS
  get_string(zmq::message_t& message)
  {
    return get_string<ZMQMESSAGE_STRING_CLASS>(message);
  }

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

  inline ZMQMESSAGE_STRING_CLASS
  get_string(zmq::message_t& message, size_t limit)
  {
    return get_string<ZMQMESSAGE_STRING_CLASS>(message, limit);
  }

  time_t
  get_time(zmq::message_t& message);

  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;
  }

  inline int
  msgcmp(zmq::message_t& message, const char* str)
  {
    return msgcmp(message, str, strlen(str));
  }

  template <typename T>
  inline int
  msgcmp(zmq::message_t& message, const T& str,
    typename Private::EnableIf<Private::IsStr<T>::value>::type* = 0)
  {
    return msgcmp(message, str.data(), str.length());
  }

  void
  init_msg(const void* t, size_t sz, zmq::message_t& msg);

  template <class T>
  inline void
  init_msg(const T& t, zmq::message_t& msg,
    typename Private::EnableIf<Private::IsStr<T>::value>::type* = 0)
  {
    init_msg(t.data(), t.length(), msg);
  }

  /*
   * Initialize zmq message by arbitrary (non-string) type that can be
   * written to output stream.
   */
  template <class T>
  inline void
  init_msg(const T& t, zmq::message_t& msg,
           typename Private::DisableIf<Private::IsStr<T>::value>::type* = 0,
           typename Private::DisableIf<Private::IsRaw<T>::value>::type* = 0)
  {
    std::ostringstream os;
    os << t;
    const std::string& s = os.str();
    init_msg(s, msg);
  }

  /*
   * Initialize zmq message by arbitrary (non-string) type to send
   * in binary form.
   * For types explicitly marked as raw (containing raw_mark typedef)
   */
  template <class T>
  inline void
  init_msg(const T& t, zmq::message_t& msg,
           typename Private::DisableIf<Private::IsStr<T>::value>::type* = 0,
           typename Private::EnableIf<Private::IsRaw<T>::value>::type* = 0)
  {
    init_msg(&t, sizeof(T), msg);
  }

  inline void
  init_msg(const char* t, zmq::message_t& msg)
  {
    init_msg(t, strlen(t), msg);
  }

  template <class T>
  inline void
  init_msg_bin(const T& t, zmq::message_t& msg)
  {
    init_msg(&t, sizeof(T), msg);
  }

  template <class T>
  inline void
  init_msg(const T& t, zmq::message_t& msg, bool binary_mode)
  {
    binary_mode ? init_msg_bin(t, msg) : init_msg(t, msg);
  }


  inline void
  throw_zmq_exception(const zmq::error_t& e)
    throw(ZmqErrorType)
  {
#ifdef ZMQMESSAGE_WRAP_ZMQ_ERROR
    throw ZmqErrorType(e.what());
#else
    throw e;
#endif
  }

  inline void
  recv_msg(zmq::socket_t& sock, zmq::message_t& msg,
    int flags = 0) throw(ZmqErrorType)
  {
    try
    {
      if (!sock.recv(&msg, flags))
      {
        throw zmq::error_t();
      }
    }
    catch (const zmq::error_t& e)
    {
      throw_zmq_exception(e);
    }
  }

  inline bool
  try_recv_msg(zmq::socket_t& sock, zmq::message_t& msg,
    int flags = ZMQ_NOBLOCK) throw(ZmqErrorType)
  {
    bool res = false;
    try
    {
      res = sock.recv(&msg, flags);
    }
    catch (const zmq::error_t& e)
    {
      throw_zmq_exception(e);
    }
    return res;
  }

  inline void
  send_msg(zmq::socket_t& sock, zmq::message_t& msg, int flags)
    throw(ZmqErrorType)
  {
    try
    {
      if (!sock.send(msg, flags))
      {
        throw zmq::error_t();
      }
    }
    catch (const zmq::error_t& e)
    {
      throw_zmq_exception(e);
    }
  }

  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);
    }
  }

  bool
  has_more(zmq::socket_t& sock);

  int
  relay_raw(zmq::socket_t& src, zmq::socket_t& dst,
    bool check_first_part = true);
}


#endif //ZMQMESSAGE_ZMQ_TOOLS_INCLUDED_

---

ZmqMessage 0.1 — open source software, support@zmqmessage.org