These routines create a class definition in R for an exposed C++
class, setting up and executing a load action to incorporate the C++
Neither function should normally need to be called directly; for most applications,
a call to
exposeClass() will create both C++ and R code files to
expose the C++ class.
setRcppClass(Class, CppClass = , module = , fields = list(), contains = , methods = , saveAs = Class, where = , ...) loadRcppClass(Class, CppClass = , module = , fields = character(), contains = character(), methods = , saveAs = Class, where = , ...)
The name for the new class.
The C++ class defined in the C++ code for the package that this class
extends. By default, the same as
The Rcpp module in which the class is defined. The module does not
have to be loaded separately;
Additional fields, superclasses and method definitions in R that
extend the C++ class. These arguments are passed on to
Save a generator object for the class in the package's namespace under
this name. By default, the generator object has the name of the
class. To avoid saving any generator object, supply this argument as
(This argument is currently needed because the actual class definition
must take place at package load time, to include C++ pointer
value returned by
The environment in which to save the class definition. By default,
will be the namespace of the package in which the
Arguments, if any, to pass on to
The call to these functions normally appears in the source code for a
package; in particular, a call is written in an R source file when
exposeClass() is called.
R code for this class or (preferably) a subclass can define new fields and methods for the class. Methods for the R class can refer to methods and fields defined in C++ for the C++ class, if those have been exposed.
The fields and methods defined can include overriding C++ fields or methods. Keep in mind, however, that R methods can refer to C++ fields and methods, but not the reverse. If you override a C++ field or method, you essentially need to revise all code that refers to that field or method. Otherwise, the C++ code will continue to use the old C++ definition.
At load time, a generator for the new class is created and stored
according to the
saveAs argument, typically under the name of
The value returned at installation time is a dummy. Future revisions
of the function may allow us to return a valid generator at install
time. We recommend using the standard style of assigning the value
to the name of the class, as one would do with
This function and function
version 2.15.0 of R or later, in order to
use load actions, introduced in that version.
A subtle way this can fail is by somehow loading a legitimate binary version of your package (installed under a valid version of R) into a session with an older R. In this case the load actions created in the binary package will simply not be called. None of the modules will be loaded and none of the classes created.
If your symptom is that classes or other objects from modules don't exist, check the R version.
## Not run: setRcppClass("World", module = "yada", fields = list(more = "character"), methods = list( test = function(what) message("Testing: ", what, "; ", more)), saveAs = "genWorld" ) ## End(Not run)
Add the following code to your website.
For more information on customizing the embed code, read Embedding Snippets.