Rcpp modules: Validator function for exposed constructors with same number of parameters - rcpp

Question

I would like to expose a C++ class with Rcpp modules that has two constructors with the same number of parameters. As documented in the Rcpp modules vignette, this can be achieved by using a validator function as the second argument to .constructor with the type
typedef bool (*ValidConstructor)(SEXP*,int);
Could somebody provide an example of how it is supposed to be used? In the vignette, there is only a TODO note that an example should be included there.

Answer 1

To follow up on nrussell's answer, you might want to generate the validators from templates, i.e.
template <typename T0, typename T1>
bool typed_valid( SEXP* args, int nargs ){
return nargs == 2 && Rcpp::is<T0>(args[0]) && Rcpp::is<T1>(args[1]) ;
}
which you would use as:
.constructor<int, int>( & typed_valid<int,int> )
obviously the typed_valid function template is straightforward to generalize with variadic templates.

Answer 2

With the disclaimer that I haven't personally used this before, the following appears to work:
#include <Rcpp.h>
using namespace Rcpp;
class Example {
public:
Example(int x_, int y_)
: x(x_), y(y_)
{
Rcout << __PRETTY_FUNCTION__ << "\n";
}
Example(std::string x_, std::string y_)
: x(x_.size()), y(y_.size())
{
Rcout << __PRETTY_FUNCTION__ << "\n";
}
int add() const
{ return x + y; }
private:
int x, y;
};
bool validate_int_int(SEXP* args, int nargs)
{ return TYPEOF(args[0]) == INTSXP && TYPEOF(args[1]) == INTSXP; }
bool validate_string_string(SEXP* args, int nargs)
{ return TYPEOF(args[0]) == STRSXP && TYPEOF(args[1]) == STRSXP; }
RCPP_MODULE(ExampleMod) {
class_<Example>("Example")
.constructor<int, int>(
"(int, int) constructor",
validate_int_int
)
.constructor<std::string, std::string>(
"(string, string) constructor",
validate_string_string
)
.method("add", &Example::add)
;
}
Testing from R,
ex.int <- new(Example, 1L, 2L)
# Example::Example(int, int)
ex.string <- new(Example, "one", "two")
# Example::Example(std::string, std::string)
ex.int$add()
# [1] 3
ex.string$add()
# [1] 6
In each of validate_int_int and validate_string_string we are just testing the input SEXP types against the signatures of their corresponding constructors.

Answer 3

Following the footsteps of previous answers, I found there is a chance that a universal validator function might exist by using variadic template in cpp.
The implementation is shorter than I have expected though there are many technical details beyond the scope of this post.
template <typename... Types>
bool universal_validator(SEXP* args, int nargs) {
return universal_validator<Types...>(args, nargs, 0);
}
template <typename T = void, typename... Types>
bool universal_validator(SEXP* args, int nargs, int idx) {
if (idx>=nargs) return false;
// optional type traits
typedef typename Rcpp::traits::remove_const_and_reference<T>::type _Tp;
return Rcpp::is<_Tp>(args[idx]) && universal_validator<Types...>(args, nargs, idx+1);
}
template <>
bool universal_validator<>(SEXP* args, int nargs, int idx) {
return nargs == idx;
}
The usage of this universal_validator is quite simple. Given the Example class, the constructors in the RCPP_MODULE will become as follows.
RCPP_MODULE(example_module) {
Rcpp::class_<Example>("Example")
.constructor<int, int>("(int, int) constructor",
universal_validator<int, int>)
.constructor<std::string, std::string> ("(string, string) constructor",
universal_validator<std::string, std::string>)
.method("add", &Example::add)
;
}
Just put the same argument types as the constructor in the validator template, e.g. universal_validator<int, int> will do the job. And this shall work as long as Rcpp::is<T> is defined for any type T.
The source code from github
SEXP newInstance( SEXP* args, int nargs ) indicates that the validator must check the types of SEXP* and nargs simultaneously. That's why not only the type but also the index of SEXP* is also checked in all functions.