zmq代理类

一 需求：

将zmq 常用模式进行封装

二 代码：

#ifndef SRC_ZMQ_AGENT_HPP_
#define SRC_ZMQ_AGENT_HPP_
#include <string.h>
#include <string>
#include <map>
#include "zmq.h"
namespace zmq_self_agent {
using namespace std;
enum {
    BIND,
    CONNECT
};
enum {
    NO_ERROR,
    CONTEXT_ERROR,
    SOCKET_ERROR,
    SOCKET_TYPE_ERROR,
    BIND_ERROR,
    CONNECT_ERROR,
    SOCKET_ATTRIBUTE_ERROR
};
class zmq_config {
public:
    zmq_config() {
        sock_type = 0;
        addr = nullptr;
        send_hwm = 1000;
        recv_hwm = 1000;
        send_timeout = 5;
    }
public:
    unsigned char sock_type;
    const char *addr;
    int send_hwm;
    int recv_hwm;
    int send_timeout;
};
class zmq_agent {
public:
    zmq_agent() {
        context_ = nullptr;
        socket_ = nullptr;
        init_map();
    }
    virtual ~zmq_agent() {
        if (nullptr != socket_) {
            zmq_close(socket_);
            socket_= nullptr;
        }
        if (nullptr != context_) {
            zmq_ctx_destroy(context_);
            context_ = nullptr;
        }
    }
public:
    unsigned char init(const zmq_config &config) {
        unsigned char ret = init_socket(config);
        if (ret) {
            return ret;
        }
        ret = init_link(config);
        if (ret) {
            return ret;
        }
        ret = init_sock_attribute(config);
        return ret;
    }
    int send(const char *info, int len)
    {
        zmq_msg_t msg = {0};
        int rc = zmq_msg_init_size(&msg, len);
        if (rc) {
            return 0;
        }
        memcpy(zmq_msg_data(&msg), info, len);
        rc = zmq_msg_send(&msg, socket_, 0);
        zmq_msg_close(&msg);
        return rc;
    }
    bool recv(string &recv_str) {
        zmq_msg_t msg = {0};
        int rc = zmq_msg_init(&msg);
        if (rc) {
            return false;
        }
        int len = zmq_msg_recv(&msg, socket_, 0);
        bool succ = false;
        if (len > 0) {
            recv_str.assign((char *)zmq_msg_data(&msg), len);
            succ = true;
        }
        zmq_msg_close(&msg);
        return succ;
    }
private:
    inline void init_map() {
        sock_type_map_[ZMQ_PULL] = BIND;
        sock_type_map_[ZMQ_PUB] = BIND;

        sock_type_map_[ZMQ_PUSH] = CONNECT;
        sock_type_map_[ZMQ_SUB] = CONNECT;
    }
    inline unsigned char init_socket(const zmq_config &config) {
        if (nullptr == (context_ = zmq_ctx_new())) {
            return CONTEXT_ERROR;
        }
        if (nullptr == (socket_ = zmq_socket(context_, config.sock_type))) {
            return SOCKET_ERROR;
        }
        return NO_ERROR;
    }
    unsigned char init_link(const zmq_config &config) {
        auto it = sock_type_map_.find(config.sock_type);
        if (end(sock_type_map_) == it) {
            return SOCKET_TYPE_ERROR;
        }
        unsigned char ret = 0;
        if (BIND == it->second) {
            ret = zmq_bind(socket_, config.addr);
            if (ret) {
                return BIND_ERROR;
            }
            return NO_ERROR;
        }
        ret = zmq_connect(socket_, config.addr);
        if (ret) {
            return CONNECT_ERROR;
        }
        return NO_ERROR;
    }
    inline unsigned char init_sock_attribute(const zmq_config &config) {
        unsigned char ret = zmq_setsockopt(socket_, ZMQ_SNDHWM, &config.send_hwm, sizeof(config.send_hwm));
        if (ret) {
            return SOCKET_ATTRIBUTE_ERROR;
        }
        ret = zmq_setsockopt(socket_, ZMQ_RCVHWM, &config.recv_hwm, sizeof(config.recv_hwm));
        if (ret) {
            return SOCKET_ATTRIBUTE_ERROR;
        }
        ret = zmq_setsockopt(socket_, ZMQ_SNDTIMEO, &config.send_timeout, sizeof(config.send_timeout));
        if (ret) {
            return SOCKET_ATTRIBUTE_ERROR;
        }
        return NO_ERROR;
    }
private:
    void *context_;
    void *socket_;
private:
    map<unsigned char, unsigned char>sock_type_map_;
};
}

#endif /* SRC_ZMQ_AGENT_HPP_ */