The Big Programming Thread - Page 447

supplied types are unique (req from boost::variant)
supplied types are lexical_castable
the resulting size of any given lexical_cast does not exceed the size of the biggest supplied type
size of message below OS max limit on a message, and recv it in one shot

#pragma once

#include<boost/lexical_cast.hpp>
#include<boost/variant.hpp>

#include<algorithm>
#include<array>
#include<stdexcept>
#include<utility>

#include<errno.h>
#include<string.h>
#include<sys/msg.h>
#include<sys/ipc.h>

namespace AUX{

//lexical_cast data into jth type of boost::variant<...> and construct boost::variant with it
template<int i,class var_t,class... ts>
struct make_var_h{
	static var_t a(int j,std::string const& data){ 
		throw std::out_of_range("which() index: "+std::to_string(j)+" out of bounds."); 
	}
};

template<int i,class var_t,class t,class... ts>
struct make_var_h<i,var_t,t,ts...>{
	static var_t a(int j,std::string const& data){
		if(i==j) return make_var_h<i,var_t,t>::a(j,data);
		else return make_var_h<i+1,var_t,ts...>::a(j,data);
	}
};

template<int i,class var_t,class t>
struct make_var_h<i,var_t,t>{
	static var_t a(int j,std::string const& data){
		return boost::lexical_cast<t>(data);
	}
};

template<class... ts>
using make_var=make_var_h<0,boost::variant<ts...>,ts...>;

//get size of biggest type
template<class msg_t,class... msg_ts>
struct max_size{
	static constexpr msglen_t v=sizeof(msg_t)>max_size<msg_ts...>::v?sizeof(msg_t):max_size<msg_ts...>::v;
};

template<class msg_t>
struct max_size<msg_t>{
	static constexpr msglen_t v=sizeof(msg_t);
};

}

//xsi message_queue wrapper
template<class... msg_ts>
class xsi_mq_t{
public:
	typedef boost::variant<msg_ts...> msg_t;

	xsi_mq_t(key_t key_)noexcept:key(key_){}
	~xsi_mq_t()noexcept{}

	template<int mq_flag=IPC_CREAT|0660>
	void crt(){
		if((msgqid=msgget(key,mq_flag))==-1) 
			throw std::runtime_error("msgcrt fail, code "+std::to_string(errno)+", str: "+strerror(errno)+".");
	}

	void rm()const{
		msqid_ds tmp;
		if(msgctl(msgqid,IPC_RMID,&tmp)==-1)
			throw std::runtime_error("msgrm fail, code "+std::to_string(errno)+", str: "+strerror(errno)+".");
	}

	template<int snd_flag=IPC_NOWAIT>
	void snd(msg_t const& msg)const{
		 //0 not allowed in xsi mq, hence variant types denominated from 1 and up
		xsi_msg_t tmp{msg.which()+1};
		auto str=boost::lexical_cast<std::string>(msg);
		std::move(std::begin(str),std::end(str),begin(tmp.msg_text));
		if(msgsnd(msgqid,(const void*)&tmp,tmp.msg_text.size(),snd_flag)==-1) 
			throw std::runtime_error("msgsnd fail, code "+std::to_string(errno)+", str: "+strerror(errno)+".");
	}

	template<int rcv_flag=IPC_NOWAIT|MSG_NOERROR,int type=0>
	msg_t rcv()const{
		xsi_msg_t tmp;
		ssize_t msg_size;
		if((msg_size=msgrcv(msgqid,(void*)&tmp,max_msglen,type,rcv_flag))==-1)
			throw std::runtime_error("msgrcv fail, code "+std::to_string(errno)+", str: "+strerror(errno)+".");
		return AUX::make_var<msg_ts...>::a(tmp.msg_type-1,std::string(tmp.msg_text.data(),msg_size));
	}

private:
	int msgqid;
	key_t key;
	static constexpr msglen_t max_msglen=AUX::max_size<msg_ts...>::v;

	struct xsi_msg_t{
		long msg_type;
		std::array<char,max_msglen> msg_text;
	};
};