zmq_device test

/************************************************************************* 
    > File Name: test.cpp 
    > Author: wangzhicheng 
    > Mail: 2363702560@qq.com  
    > Created Time:2017-02-13
 ************************************************************************/  
#include <iostream>  
#include <vector>  
#include <thread>  
#include <chrono>  
#include "ZMQ_PipeSocket.h"
using namespace zmqpipe;
static const string ADDR0 = "tcp://127.0.0.1:8888";
static const chrono::milliseconds dura(1000);  // 1s
void client_thread()
{
	string str;
	ZMQ_PIPESocket sender;
	if(!sender.Init(ZMQ_REQ, ADDR0))
	{
		cerr << "client init failed...!" << endl;
		exit(EXIT_FAILURE);
	}
	while(1)
	{
		if(!sender.Send("Hello World...!"))
		{
			cerr << "client send failed...!" << endl;
		}
		if(!sender.Recv(str))
		{
			cerr << "client recv failed...!" << endl;
		}
		else 
		{
			cout << "client recv = " << str << endl;
		}
		this_thread::sleep_for(dura);
	}
}
int main()  
{  
	thread th_client(client_thread);
	th_client.join();

    return 0;  
}  

/************************************************************************* 
    > File Name: test.cpp 
    > Author: wangzhicheng 
    > Mail: 2363702560@qq.com  
    > Created Time:2017-02-13
 ************************************************************************/  
#include <iostream>  
#include <vector>  
#include <thread>  
#include <chrono>  
#include "ZMQ_PipeSocket.h"
using namespace zmqpipe;
static const string ADDR = "ipc://127.0.0.1.ipc";
//static const string ADDR = "tcp://127.0.0.1:9999";
static const chrono::milliseconds dura(1000);  // 1s
void server_thread()
{
	string str;
	ZMQ_PIPESocket receiver;
	if(!receiver.Init(ZMQ_REP, ADDR))
	{
		cerr << "server init failed...!" << endl;
		exit(EXIT_FAILURE);
	}
	while(1)
	{
		if(!receiver.Recv(str))
		{
			cerr << "server recv failed...!" << endl;
		}
		else cout << "server recv = " << str << endl;
		if(!receiver.Send(str))
		{
			cerr << "server send failed...!" << endl;
		}
		this_thread::sleep_for(dura);
	}
}
int main()  
{  
	static const int N = 1;
	vector<thread>worker_threads;
	for(int i = 0;i < N;i++)
	{
		worker_threads.emplace_back(thread(server_thread));
	}
	for(auto &th:worker_threads) 
	{
		th.join();
	}

    return 0;  
}  


/************************************************************************* 
    > File Name: test.cpp 
    > Author: wangzhicheng 
    > Mail: 2363702560@qq.com  
    > Created Time:2017-02-13
 ************************************************************************/  
#include <iostream>  
#include <vector>  
#include <thread>  
#include <chrono>  
#include "ZMQ_PipeSocket.h"
using namespace zmqpipe;
static const string ADDR0 = "tcp://*:8888";
static const string ADDR1 = "ipc://127.0.0.1.ipc";
//static const string ADDR1 = "tcp://*:9999";
int main()  
{  
	ZMQ_PIPESocket clients;
	if(!clients.Init(ZMQ_ROUTER, ADDR0))
	{
		cerr << "client init failed...!" << endl;
		exit(EXIT_FAILURE);
	}
	ZMQ_PIPESocket workers;
	if(!workers.Init(ZMQ_DEALER, ADDR1))
	{
		cerr << "workers init failed...!" << endl;
		exit(EXIT_FAILURE);
	}
	zmq_device(ZMQ_QUEUE, clients.m_pSocket, workers.m_pSocket);
	cout << "ll" << endl;

    return 0;  
}  
/************************************************************************* 
 *      > File Name: ZMQ_PipeSocket.cpp 
 *      > Author: wangzhicheng 
 *      > Mail: 2363702560@qq.com 
 *      > Created Time: 2017-02-07
 *      > statement: ZMQ封装类 
 *************************************************************************/  
#include "ZMQ_PipeSocket.h"  
namespace zmqpipe  
{  
ZMQ_PIPESocket::ZMQ_PIPESocket()   
{  
    m_pContext = NULL;  
    m_pSocket = NULL;  
}  
bool ZMQ_PIPESocket::Init(int SocketType, 
						  const string &addr, 
						  int sendhwm, 
						  int recvhwm, 
						  int sendtimeout)   
{  
    m_pContext = zmq_ctx_new();  
    if(!m_pContext) return false;  
    m_pSocket = zmq_socket(m_pContext, SocketType);  
    if(!m_pSocket) return false;  
	int rc;
	switch(SocketType)
	{
	case ZMQ_PULL:
	case ZMQ_PUB:
	case ZMQ_ROUTER:
	case ZMQ_DEALER:
		rc = zmq_bind(this->m_pSocket, addr.c_str());
		break;
	case ZMQ_REP:
	case ZMQ_REQ:
	case ZMQ_PUSH:
	case ZMQ_SUB:
		rc = zmq_connect(this->m_pSocket, addr.c_str());
		break;
	default:
		return false;
	}
    rc = zmq_setsockopt(m_pSocket, ZMQ_SNDHWM, &sendhwm, sizeof(sendhwm));  
    if(rc) return false;  
    rc = zmq_setsockopt(m_pSocket, ZMQ_RCVHWM, &recvhwm, sizeof(recvhwm));  
    if(rc) return false;  
    rc = zmq_setsockopt(m_pSocket, ZMQ_SNDTIMEO, &sendtimeout, sizeof(sendtimeout));  
    if(rc) return false;  
    m_strSendServer = addr;  
  
    return true;  
}  
/* 
 * @brief 发送info指向的对象  
 * @len 对象的大小 字节数 
 * */  
bool ZMQ_PIPESocket::Send(void *info, int len)   
{  
    int rc;  
    zmq_msg_t msg;  
    rc = zmq_msg_init_size(&msg, len);  
    if(rc) return false;  
    memcpy(zmq_msg_data(&msg), (char *)info, len);  
    rc = zmq_msg_send(&msg, this->m_pSocket, 0);  
  
    return rc == len;  
}  
/* 
 * @brief 发送string对象  
 * */  
bool ZMQ_PIPESocket::Send(const string &strSend)   
{  
    int rc;  
    size_t len = strSend.size();  
    zmq_msg_t msg;  
    rc = zmq_msg_init_size(&msg, len);  
    if(rc) return false;  
    memcpy(zmq_msg_data(&msg), strSend.c_str(), len);  
    size_t Len = zmq_msg_send(&msg, this->m_pSocket, 0);  
  
    return Len == len;  
}  
/* 
 * @brief 接收数据 接收的数据由info指向 
 * */  
bool ZMQ_PIPESocket::Recv(void *info)   
{  
    int rc;  
    zmq_msg_t msg;  
    rc = zmq_msg_init(&msg);  
    if(rc) return false;  
    int len = zmq_msg_recv(&msg, this->m_pSocket, 0);    // 阻塞方式  
    if(len <= 0) return false;  
    memcpy(info, (char *)zmq_msg_data(&msg), len);  
    if(zmq_msg_close(&msg)) return false;  
  
    return true;  
}     
/* 
 * @brief 接收string对象数据 
 * */  
bool ZMQ_PIPESocket::Recv(string &strRecv)   
{  
    int rc;  
    zmq_msg_t msg;  
    rc = zmq_msg_init(&msg);  
    if(rc) return false;  
    int len = zmq_msg_recv(&msg, this->m_pSocket, 0);    // 阻塞方式  
    if(len <= 0) return false;  
    strRecv.assign((char *)zmq_msg_data(&msg), len);  
    if(zmq_msg_close(&msg)) return false;  
  
    return true;  
}     
/*
 * @brief recieving from a socket is over
 * */
bool ZMQ_PIPESocket::RecvOver()
{
	int64_t more;
	size_t more_size = sizeof(more);
	zmq_getsockopt(m_pSocket, ZMQ_RCVMORE, &more, &more_size);

	return more <= 0;
}
ZMQ_PIPESocket::~ZMQ_PIPESocket()   
{  
    if(m_pSocket)   
    {  
        zmq_close(m_pSocket);  
        m_pSocket = NULL;  
    }  
    if(m_pContext)   
    {  
        zmq_ctx_destroy(m_pContext);  
        m_pContext = NULL;  
    }  
}  
}