zmqpp_compat.hpp

Go to the documentation of this file.

/*
  _____ __  __  ___  ____  ____     ____                            _
 |__  /|  \/  |/ _ \|  _ \|  _ \   / ___|___  _ __ ___  _ __   __ _| |_
   / / | |\/| | | | | |_) | |_) | | |   / _ \| '_ ` _ \| '_ \ / _` | __|
  / /_ | |  | | |_| |  __/|  __/  | |__| (_) | | | | | | |_) | (_| | |_
 /____||_|  |_|\__\_\_|   |_|      \____\___/|_| |_| |_| .__/ \__,_|\__|
                                                       |_|
DEPRECATED source-compatibility shim for pre-cppzmq downstream agents
Copyright (C) 2026 Paolo Bosetti
*/
 
#pragma once
#ifdef _WIN32
#ifndef NOMINMAX
#define NOMINMAX
#endif
#ifndef WIN32_LEAN_AND_MEAN
#define WIN32_LEAN_AND_MEAN
#endif
#include <winsock2.h>
#endif
 
#include <cstring>
#include <string>
#include <utility>
 
#include <zmq.hpp>
#include <zmq_addon.hpp>
 
#include "zap_auth.hpp"
 
#if defined(MADS_NO_ZMQPP_COMPAT_WARNING)
#define MADS_ZMQPP_DEPRECATED(msg)
#else
#define MADS_ZMQPP_DEPRECATED(msg) [[deprecated(msg)]]
#endif
 
namespace zmqpp {
 
using socket_type = zmq::socket_type;
 
using exception = zmq::error_t;
using zmq_internal_exception = zmq::error_t;
 
namespace socket_option {
inline constexpr auto linger = zmq::sockopt::linger;
inline constexpr auto receive_timeout = zmq::sockopt::rcvtimeo;
inline constexpr auto send_timeout = zmq::sockopt::sndtimeo;
inline constexpr auto conflate = zmq::sockopt::conflate;
inline constexpr auto receive_high_water_mark = zmq::sockopt::rcvhwm;
inline constexpr auto send_high_water_mark = zmq::sockopt::sndhwm;
inline constexpr auto identity = zmq::sockopt::routing_id;
inline constexpr auto curve_server = zmq::sockopt::curve_server;
inline constexpr auto curve_public_key = zmq::sockopt::curve_publickey;
inline constexpr auto curve_secret_key = zmq::sockopt::curve_secretkey;
inline constexpr auto curve_server_key = zmq::sockopt::curve_serverkey;
} // namespace socket_option
 
class MADS_ZMQPP_DEPRECATED("use zmq::context_t") context
    : public zmq::context_t {
public:
  using zmq::context_t::context_t;
 
  void terminate() { close(); }
};
 
class MADS_ZMQPP_DEPRECATED("use zmq::multipart_t") message
    : public zmq::multipart_t {
public:
  using zmq::multipart_t::multipart_t;
 
  message() = default;
  message(zmq::multipart_t &&other) noexcept
      : zmq::multipart_t(std::move(other)) {}
 
  size_t parts() const { return size(); }
 
  std::string get(size_t n) const { return at(n).to_string(); }
 
  template <typename T> T get(size_t n) const {
    T value{};
    const auto &frame = at(n);
    std::memcpy(&value, frame.data(),
                frame.size() < sizeof(T) ? frame.size() : sizeof(T));
    return value;
  }
 
  const void *raw_data(size_t n) const { return at(n).data(); }
 
  size_t size(size_t n) const { return at(n).size(); }
 
  size_t size() const { return zmq::multipart_t::size(); }
 
  void add_raw(const void *data, size_t len) { addmem(data, len); }
 
  message copy() const { return message(clone()); }
 
  message &operator<<(const std::string &part) {
    addstr(part);
    return *this;
  }
  message &operator<<(const char *part) {
    addstr(std::string(part));
    return *this;
  }
 
  message &operator>>(std::string &part) {
    part = popstr();
    return *this;
  }
};
 
class MADS_ZMQPP_DEPRECATED("use zmq::socket_t") socket
    : public zmq::socket_t {
public:
  using zmq::socket_t::socket_t;
 
  socket(zmq::context_t &ctx, socket_type type) : zmq::socket_t(ctx, type) {}
 
  void subscribe(const std::string &topic) {
    set(zmq::sockopt::subscribe, topic);
  }
 
  void unsubscribe(const std::string &topic) {
    set(zmq::sockopt::unsubscribe, topic);
  }
 
  bool send(zmq::multipart_t &msg, bool dont_block = false) {
    return msg.send(*this, dont_block ? ZMQ_DONTWAIT : 0);
  }
 
  bool send(const std::string &payload, bool dont_block = false) {
    return zmq::socket_t::send(zmq::buffer(payload),
                               dont_block ? zmq::send_flags::dontwait
                                          : zmq::send_flags::none)
        .has_value();
  }
 
  bool receive(zmq::multipart_t &msg, bool dont_block = false) {
    return msg.recv(*this, dont_block ? ZMQ_DONTWAIT : 0);
  }
 
  template <typename Opt, typename T> void get(Opt opt, T &out) const {
    out = zmq::socket_t::get(opt);
  }
 
  using zmq::socket_t::get;
};
 
namespace curve {
 
using keypair = Mads::CurveKeypair;
 
inline keypair generate_keypair() { return Mads::generate_keypair(); }
 
} // namespace curve
 
} // namespace zmqpp