This document discusses metaprogramming in C++ and describes an RPC framework implemented using C++ templates and metaprogramming. It defines an interface called calc_interface for a calculator RPC with functions like add and signals like expr_evaluated. It shows how to define the interface using meta_functions, and how a client can invoke functions on the server while handling serialization, transport, and response deserialization. Key aspects covered include defining the interface, invoking functions from the client, argument checking, and verifying functions exist in the interface.

1. www.luxoft.com
Alexey Tsoy
Senior Developer
Meta programming in C++

2. www.luxoft.com
Introduction
Metaprogramming in C++ (Andrei Alexandrescu, 2002).
Templates:
• one of the most powerful part of C++
• quite new technology (just only 18 years old)

3. www.luxoft.comwww.luxoft.com
RPC diagram

4. www.luxoft.comwww.luxoft.com
struct calc_interface {
struct functions {
double add(double, double);
int eval(std::string);
};
struct signals {
void expr_evaluated(int, double);
};
};
Interface definition: Ideal case

5. www.luxoft.com
Example of usage
struct calc_server: server_t<calc_interface>
{
double add(double a, double b) override
{ return a + b; };
int eval(string expr) override {
static int id(0); ++id;
new std::thread( [this, expr, id] () {
sleep(100);
this->expr_evaluated(expr, 12345);
} );
return id;
}
};
client_t<calc_interface> client;
// subscribe to the signal ..
client.expr_evaluated(
[] (int id, string expr, double res)
{ cout << expr << "→" << res; }
);
// execute functions ..
cout << client.add(1,2) << endl;
client.add(1,2,
[] (double res) { cout << res << endl; })

6. www.luxoft.comwww.luxoft.com
struct calc_interface
{
RPC_FUNCTION(double(double, double), add);
RPC_FUNCTION(int(std::string), eval);
RPC_SIGNAL (void(int, double), expr_evaluated);
};
Interface definition: implemented case

7. www.luxoft.com
Usage
server_t<calc_interface> server(transpotr);
server_t::initialize(server)
.add_handler<calc_interface::add> (
[] (double a, double b) { return a + b;} )
.add_handler<calc_interface::eval> (
[] (string expr) → int {
static int id(0); ++id;
new std::thread( [this, expr, id] () {
sleep(100);
server.emit<expr_evaluated>(expr, 12345);
} );
return id;
});
client_t<calc_interface> client(transpotr);
// subscribe to the signal ..
client.subscribe<client_t::expr_evaluated>(
[] (int id, string expr, double res)
{ cout << expr << "→" << res; }
);
// execute functions ..
cout << client.invoke<add>(1,2) << endl;
// async invoke
client.invoke(1,2, [] (double res) { cout << res << endl;
})

8. www.luxoft.com
What should be taken into account
• Wrong function parameters. e.g. the following should cause a compile time
errors
– client.invoke<add>(“hello” , 123) or client.invoke<add>(1) or
client.invoke<add>(1, 2, 3)
• Execution of nonexistent function
– interface_1 { RPC_FN (void (int), fn1) };
– interface_2 { RPC_FN (void (double), fn2) };
– client_t<interface_1>().invoke<interface_2::fn2>(5.);

9. www.luxoft.com
Implementation
struct calc_interface
{
// RPC_FUNCTION(double(double, double), add);
struct add: meta_function_t<double (double, double), true>
{ static const char* uniq_name() { return “add”; } };
//RPC_FUNCTION(int(std::string), eval);
struct eval: meta_function_t<double (double, double), true>
{ static const char* uniq_name() { return “eval”; };
//RPC_SIGNAL (void(int, double), expr_evaluated);
struct expr_evaluated: meta_function_t<double (double, double), false>
{ static const char* uniq_name() { return “expr_evaluated”; };
};
meta_function_t < R (Arg0, …, ArgN) , bool> :: result_type → R;
meta_function_t < R (Arg0, …, ArgN) , bool> :: args_count → N;
meta_function_t < R (Arg0, …, ArgN) , bool> :: arg<0>::type → Arg0;
...
meta_function_t < R (Arg0, …, ArgN) , bool> :: arg<N>::type → ArgN;
meta_function_t < R (Arg0, …, ArgN) , bool> ::is_function → bool

10. www.luxoft.comwww.luxoft.com
namespace details {
template<typename... Args>
struct args_count
{ enum { value = 0 }; };
template<typename A1, typename ... Args>
struct args_count<A1, Args...>
{ enum { value = 1 + args_count<Args...>::value }; };}
cout << detail::args_count < >::value ; → 0
cout << detail::args_count < int >::value ; → 1
cout << detail::args_count < int , float>::value ; → 2

11. www.luxoft.comwww.luxoft.com
namepsace detail {
template<unsigned int N, typename ...Args>
struct arg;
template<typename A0, typename ...Args>
struct arg<0, A0, Args...>
{ typedef A0 type; };
template<unsigned int N, typename A0, typename ...Args>
struct arg<N, A0, Args...>
{ typedef typename arg<N - 1, Args...>::type type; };
}
detail::arg<0, int>::type → int
detail::arg<0, int, double>::type → int
detail::arg<1, int, double>::type → double

12. www.luxoft.comwww.luxoft.com
template<typename FnSygn, bool>
struct meta_function;
template<typename UniqType, bool isFn, typename R, typename ...Args>
struct meta_function<R(Args…), isFn>
{
typedef R result_type;
enum { args_count = detail::args_count<Args...>::value };
template<unsigned int N>
struct arg
{ typedef typename detail::arg<N, Args...>::type type; };
enum { is_function = isFn };
};

13. www.luxoft.com
client.invoke
// calc_interface
struct add: meta_function_t<double (double, double), true> { … };
// client_t<calc_interface> client:
…
auto result = client.invoke<add> ( … ) :
1) check arguments
2) serialize arguments
3) serialize function ID
4) send data
5) wait for response
6) deserialize and return result

14. www.luxoft.com
client.invoke
template< typename MetaFn, typename ...Args>
typename MetaFn::result_type invoke
( Args const&... args)
{
check if <MetaFn> declared in <calc_interface> ;
static_assert(MetaFn::is_function == true);
static_assert(MetaFn::args_count == detail::args_count<Args...>::value);
typename MetaFn::arg<0>::type a0 = get<0>(args...);
...
typename MetaFn::arg<N>::type a1 = get<N>(args...);
// ---->>>
auto ostream = transport.get_ostream( );
ostream << MetaFn::uniq_name()
<< arg0 << … << argN;
int sequence_id = transport.send(ostream);
transport_wait_for_response(sequence_id);
auto istream = transport.get_istream(sequence_id);
MetaFn::result_type result;
istream >> result;
return result;
}

15. www.luxoft.com
client.invoke
template<typename MetaFn, unsigned int N, typename IStream, typename ...Args>
void serrialize_all(IStream & , Args ...args) { };
template<typename MetaFn, unsigned int N, typename IStream, typename Arg0, typename ...Args>
void serrialize_all(IStream & stream, Arg0 const& arg0,Args ...args)
{
typename typedef MetaFn::arg<N>::type arg_to_send = arg0;
stream << arg0;
serrialize_all<MetaFn, N + 1> (stream, args...);
}

16. www.luxoft.com
client.invoke
template< typename MetaFn, typename ...Args>
typename MetaFn::result_type invoke ( Args const&... args )
{
check if <MetaFn> declared in <calc_interface> ;
static_assert(MetaFn::is_function == true);
static_assert(MetaFn::args_count == detail::args_count<Args...>::value);
auto ostream = transport.get_ostream( );
serrialize_all<MetaFn,0>(ostream, MetaFn::uniq_name(), args...);
int sequence_id = transport.send(ostream);
transport_wait_for_response(sequence_id);
auto istream = transport.get_istream(sequence_id);
MetaFn::result_type result;
istream >> result;
return result;
}

17. www.luxoft.com
Exists or not ?
struct calc_interface {
long __registrate_meta_type(…);
// RPC_FUNCTION(double(double, double), add);
struct add: meta_function_t<double (double, double), true>
{ static const char* uniq_name() { return “add”; } };
char __registrate_meta_type(add );
...
char __registrate_meta_type(expr_evaluated);
};
template< typename Interface, typename MetaFn> struct is_present {
enum { value = sizeof( ((Interface*)0)→
__registrate_meta_type(MetaFn())) == 1 ? 1 : 0 }; };
std::cout << is_present<calc_interface,
calc_interface::add>::value → 1
std::cout << is_present<calc_interface,
calc_interface::eval>::value → 1
std::cout << is_present<calc_interface, int>::value → 0

18. www.luxoft.com
Client.invoke – final version
//client_t<calc_interface> client;
// template<Interface> client_t { typedef Interface interface; };
template< typename MetaFn, typename ...Args>0
typename MetaFn::result_type invoke( Args const&... args ) {
static_assert(is_present<interface, MetaFn> :: value == 1);
static_assert(MetaFn::is_function == true);
static_assert(MetaFn::args_count == detail::args_count<Args...>::value);
auto ostream = transport.get_ostream( );
serrialize_all<MetaFn,0>(ostream, MetaFn::uniq_name(), args...);
int sequence_id = transport.send(ostream);
transport_wait_for_response(sequence_id);
auto istream = transport.get_istream(sequence_id);
MetaFn::result_type result;
istream >> result;
return result;
}

19. www.luxoft.comwww.luxoft.com
Tsoy Alexey
Mails:
atsoy@luxoft.com
tsoy.alexey@gmail.com
Contact details

20. www.luxoft.com
Thank you