{"id":7579,"date":"2017-12-17T15:23:30","date_gmt":"2017-12-17T20:23:30","guid":{"rendered":"https:\/\/rud.is\/b\/?p=7579"},"modified":"2018-03-10T08:01:08","modified_gmt":"2018-03-10T13:01:08","slug":"mqtt-development-log-on-dsls-rcpp-modules-and-custom-formula-functions","status":"publish","type":"post","link":"https:\/\/rud.is\/b\/2017\/12\/17\/mqtt-development-log-on-dsls-rcpp-modules-and-custom-formula-functions\/","title":{"rendered":"mqtt Development Log : On DSLs, Rcpp Modules and Custom Formula Functions"},"content":{"rendered":"

I know some folks had a bit of fun with the previous post since it exposed the fact that I left out unique MQTT client id generation from the initial 0.1.0 release of the in-development package (client ids need to be unique<\/a>).<\/p>\n

There have been some serious improvements since said post and I thought a (hopefully not-too-frequent) blog-journal of the development of this particular package might be interesting\/useful to some folks, especially since I’m delving into some not-oft-blogged (anywhere) topics as I use some new tricks in this particular package.<\/p>\n

Thank The Great Maker for C++<\/h2>\n

I’m comfortable and not-too-shabby at wrapping C\/C++ things with an R bow and I felt quite daft seeing this<\/a> after I had started banging on the mosquitto<\/code> C interface. Yep, that’s right: it has a C++ interface. It’s waaaaay easier (in my experience) bridging C++ libraries since Dirk\/Romain’s (et al, as I know there are many worker hands<\/a> involved as well) Rcpp<\/code> has so many tools<\/em> available to do that very thing.<\/p>\n

\n As an aside, if you do any work with Rcpp or want to start doing work in Rcpp, Masaki E. Tsuda’s Rcpp for Everyone<\/a> is an excellent<\/strong> tome.<\/em>\n<\/p><\/blockquote>\n

I hadn’t used Rcpp Modules<\/a> before (that link goes to a succinct but very helpful post by James Curran) but they make exposing C++ library functionality even easier than I had experienced before. So easy, in fact, that it made it possible to whip out an alpha version of a “domain specific language” (or a pipe-able, customized API — however you want to frame these things in your head) for the package. But, I’m getting ahead of myself.<\/p>\n

The mosquittopp<\/code> class in the mosqpp<\/code> namespace is much like the third bowl of porridge: just right. It’s neither too low-level nor too high-level and it was well thought out enough that it only required a bit of tweaking to use as an Rcpp Module.<\/p>\n

First there are more than a few char *<\/code> parameters that needed to be std::string<\/code>s. So, something like:<\/p>\n

int username_pw_set(const char *username, const char *password);<\/code><\/pre>\n
becomes:<\/p>\n
int username_pw_set(std::string username, std::string password);<\/code><\/pre>\n
in our custom wrapper class.<\/p>\n
Since the whole point of the mqtt<\/code> package is to work in R vs C[++] or any other language, the callbacks — the functions that do the work when message<\/code>, publish<\/code>, subscribe<\/code>, etc. events are triggered — need to be in R. I wanted to have some default callbacks during the testing phase and they’re really straightforward to setup in Rcpp<\/code>:<\/p>\n
Rcpp::Environment pkg_env = Rcpp::Environment::namespace_env("mqtt");\r\n\r\nRcpp::Function ccb = pkg_env[".mqtt_connect_cb"];\r\nRcpp::Function dcb = pkg_env[".mqtt_disconnect_cb"];\r\nRcpp::Function pcb = pkg_env[".mqtt_publish_cb"];\r\nRcpp::Function mcb = pkg_env[".mqtt_message_cb"];\r\nRcpp::Function scb = pkg_env[".mqtt_subscribe_cb"];\r\nRcpp::Function ucb = pkg_env[".mqtt_unsubscribe_cb"];\r\nRcpp::Function lcb = pkg_env[".mqtt_log_cb"];\r\nRcpp::Function ecb = pkg_env[".mqtt_error_cb"];<\/code><\/pre>\n
The handy thing about that approach is you don’t need to export the functions (it works like the :::<\/code> does).<\/p>\n
But the kicker is the Rcpp Module syntactic sugar:<\/p>\n
RCPP_MODULE(MQTT) {\r\n\r\n  using namespace Rcpp;\r\n\r\n  class_<mqtt_r>("mqtt_r")\r\n    .constructor<std::string, std::string, int>("id\/host\/port constructor")\r\n    .constructor<std::string, std::string, int, std::string, std::string>("id\/host\/port\/user\/pass constructor")\r\n    .constructor<std::string, std::string, int, Rcpp::Function, Rcpp::Function, Rcpp::Function>("id\/host\/post\/con\/mess\/discon constructor")\r\n    .method("connect", &mqtt_r::connect)\r\n    .method("disconnect", &mqtt_r::disconnect)\r\n    .method("reconnect", &mqtt_r::reconnect)\r\n    .method("username_pw_set", &mqtt_r::username_pw_set)\r\n    .method("loop_start", &mqtt_r::loop_start)\r\n    .method("loop_stop", &mqtt_r::loop_stop)\r\n    .method("loop", &mqtt_r::loop)\r\n    .method("publish_raw", &mqtt_r::publish_raw)\r\n    .method("publish_chr", &mqtt_r::publish_chr)\r\n    .method("subscribe", &mqtt_r::subscribe)\r\n    .method("unsubscribe", &mqtt_r::unsubscribe)\r\n    .method("set_connection_cb", &mqtt_r::set_connection_cb)\r\n    .method("set_discconn_cb", &mqtt_r::set_discconn_cb)\r\n    .method("set_publish_cb", &mqtt_r::set_publish_cb)\r\n    .method("set_message_cb", &mqtt_r::set_message_cb)\r\n    .method("set_subscribe_cb", &mqtt_r::set_subscribe_cb)\r\n    .method("set_unsubscribe_cb", &mqtt_r::set_unsubscribe_cb)\r\n    .method("set_log_cb", &mqtt_r::set_log_cb)\r\n    .method("set_error_cb", &mqtt_r::set_error_cb)\r\n   ;\r\n\r\n}<\/code><\/pre>\n
That, combined with RcppModules: MQTT<\/code> in the DESCRIPTION<\/code> file and a MQTT <- Rcpp::Module(\"MQTT\")<\/code> just above where you’d put an .onLoad<\/code> handler means you can do something like (internally, since it’s not exported):<\/p>\n
mqtt_obj <- MQTT$mqtt_r\r\n\r\nmqtt_conn_obj <- new(mqtt_obj, "unique_client_id", "test.mosquitto.org", 1883L)<\/code><\/pre>\n
and have access to each of those methods right from R (e.g. mqtt_conn_obj$subscribe(0, \"topic\", 0)<\/code>).<\/p>\n
If you’re careful with your C++ class code, you’ll be able to breeze through exposing functionality.<\/p>\n
Because of the existence of Rcpp Modules, I was able to do what follows in the next section in near record time.<\/p>\n
“The stump of a %>%<\/code> he held tight in his teeth”<\/h2>\n
I felt compelled to get a Christmas reference in the post and it’s relevant to this section. I like %>%<\/code>, recommend the use of %>%<\/code> and use %>%<\/code> in my own day-to-day R coding (it’s even creeping into internal package code, though I still try not to do that). I knew I wanted to expose a certain way of approaching MQTT workflows in this mqtt<\/code> package and that meant coming up with an initial — but far from complete — mini-language or pipe-able API for it. Here’s the current thinking\/implementation:<\/p>\n