Merge pull request #351 from RcppCore/bugfix/unique-modules-names

address issue #350 by renaming Modules

Author: eddelbuettel

ChangeLog

@@ -1,3 +1,21 @@
+2015-08-26  Dirk Eddelbuettel  <[email protected]>
+
+        * inst/unitTests/testRcppClass/src/rcpp_module.cpp: Renamed Module
+        'World' to 'RcppClassWorld' to avoid multiple modules with same name
+        * inst/unitTests/testRcppClass/man/Rcpp_class_examples.Rd: Ditto
+        * inst/unitTests/testRcppClass/R/load.R: Ditto
+        * inst/unitTests/testRcppClass/NAMESPACE: Ditto
+        * inst/unitTests/runit.Module.client.package.R: Re-enable test
+
+        * inst/unitTests/testRcppModule/src/rcpp_module.cpp: Renamed Module
+        'World' to 'RcppModuleWorld' to avoid multiple modules with same name
+
+        * inst/unitTests/cpp/modref.cpp: Rename 'World' to 'ModRefWorld'
+        * inst/unitTests/runit.modref.R (test.modRef): Ditto
+
+        * inst/unitTests/cpp/Module.cpp: Rename 'World' to 'ModuleWorld'
+        * inst/unitTests/runit.Module.R (test.Module): Ditto
+
 2015-08-24  Dirk Eddelbuettel  <[email protected]>
 
         * vignettes/Rcpp.bib: Updated R / R Core references

DESCRIPTION

@@ -1,7 +1,7 @@
 Package: Rcpp
 Title: Seamless R and C++ Integration
-Version: 0.12.0.2
-Date: 2015-08-17
+Version: 0.12.0.3
+Date: 2015-08-26
 Author: Dirk Eddelbuettel, Romain Francois, JJ Allaire, Kevin Ushey, 
  Qiang Kou, Douglas Bates and John Chambers
 Maintainer: Dirk Eddelbuettel <[email protected]>

inst/NEWS.Rd

@@ -19,6 +19,11 @@
       \item Correctly reset directory in case of no-rebuilding but Windows code
       (PR #335)
     }
+    \item Changes in Rcpp Modules:
+    \itemize{
+      \item We no longer define multiple Modules objects named \code{World} in
+      the unit tests with was seen to have a bad effect with R 3.2.2 or later.
+    }
   }
 }
 

inst/unitTests/cpp/Module.cpp

@@ -3,7 +3,7 @@
 //
 // Module.cpp: Rcpp R/C++ interface class library -- module unit tests
 //
-// Copyright (C) 2013 - 2014  Dirk Eddelbuettel and Romain Francois
+// Copyright (C) 2013 - 2015  Dirk Eddelbuettel and Romain Francois
 //
 // This file is part of Rcpp.
 //
@@ -22,45 +22,45 @@
 
 #include <Rcpp.h>
 
-using namespace Rcpp ;
+using namespace Rcpp;
 
 std::string hello() {
-    return "hello" ;
+    return "hello";
 }
 
 int bar(int x) {
-    return x*2 ;
+    return x*2;
 }
 
 double foo(int x, double y) {
-    return x * y ;
+    return x * y;
 }
 
 void bla() {
-    Rprintf("hello\\n") ;
+    Rprintf("hello\\n");
 }
 
 void bla1(int x) {
-    Rprintf("hello (x = %d)\\n", x) ;
+    Rprintf("hello (x = %d)\\n", x);
 }
 
 void bla2(int x, double y) {
-    Rprintf("hello (x = %d, y = %5.2f)\\n", x, y) ;
+    Rprintf("hello (x = %d, y = %5.2f)\\n", x, y);
 }
 
 int test_reference(std::vector<double>& ref) {
-    return ref.size() ;
+    return ref.size();
 }
 int test_const_reference(const std::vector<double>& ref) {
-    return ref.size() ;
+    return ref.size();
 }
 int test_const(const std::vector<double> ref) {
-    return ref.size() ;
+    return ref.size();
 }
 
-class World {
+class ModuleWorld {
 public:
-    World() : msg("hello") {}
+    ModuleWorld() : msg("hello") {}
     void set(std::string msg_) { this->msg = msg_; }
     void set_ref(std::string& msg_) { this->msg = msg_; }
     void set_const_ref(const std::string& msg_) { this->msg = msg_; }
@@ -70,73 +70,73 @@ class World {
     std::string msg;
 };
 
-void clearWorld(World* w) {
+void clearWorld(ModuleWorld* w) {
     w->set("");
 }
 
-class Num{
+class ModuleNum{
 public:
-    Num() : x(0.0), y(0) {} ;
+    ModuleNum() : x(0.0), y(0) {};
 
-    double getX() const { return x ; }
-    void setX(double value) { x = value ; }
+    double getX() const { return x; }
+    void setX(double value) { x = value; }
 
-    int getY() { return y ; }
+    int getY() { return y; }
 
 private:
-    double x ;
-    int y ;
+    double x;
+    int y;
 };
 
-class Number{
+class ModuleNumber{
 public:
-    Number() : x(0.0), y(0) {} ;
+    ModuleNumber() : x(0.0), y(0) {};
 
-    double x ;
-    int y ;
+    double x;
+    int y;
 };
 
-class Randomizer {
+class ModuleRandomizer {
 public:
 
     // Randomizer() : min(0), max(1) {}
-    Randomizer(double min_, double max_) : min(min_), max(max_) {}
+    ModuleRandomizer(double min_, double max_) : min(min_), max(max_) {}
 
     NumericVector get(int n) {
-        RNGScope scope ;
+        RNGScope scope;
         return runif(n, min, max);
     }
 
 private:
-    double min, max ;
-} ;
+    double min, max;
+};
 
-RCPP_EXPOSED_CLASS(Test)
-class Test{
+RCPP_EXPOSED_CLASS(ModuleTest)
+class ModuleTest {
 public:
-    double value ;
-    Test(double v) : value(v) {}
+    double value;
+    ModuleTest(double v) : value(v) {}
 private:
     // hiding those on purpose
     // we work by reference or pointers here. Not by copy.
-    Test(const Test& other) ;
-    Test& operator=(const Test&) ;
-} ;
+    ModuleTest(const ModuleTest& other);
+    ModuleTest& operator=(const ModuleTest&);
+};
 
-double Test_get_x_const_ref(const Test& x) {
-    return x.value ;
+double Test_get_x_const_ref(const ModuleTest& x) {
+    return x.value;
 }
-double Test_get_x_ref(Test& x) {
+double Test_get_x_ref(ModuleTest& x) {
     return x.value;
 }
-double Test_get_x_const_pointer(const Test* x) {
-    return x->value ;
+double Test_get_x_const_pointer(const ModuleTest* x) {
+    return x->value;
 }
-double Test_get_x_pointer(Test* x) {
-    return x->value ;
+double Test_get_x_pointer(ModuleTest* x) {
+    return x->value;
 }
 
-RCPP_MODULE(yada) {
+RCPP_MODULE(demoModule) {
     function("hello", &hello);
     function("bar"  , &bar  );
     function("foo"  , &foo  );
@@ -145,43 +145,41 @@ RCPP_MODULE(yada) {
     function("bla2" , &bla2 );
 
     function("test_reference", test_reference);
-    function("test_const_reference", test_const_reference) ;
-    function("test_const", test_const) ;
+    function("test_const_reference", test_const_reference);
+    function("test_const", test_const);
 
-    class_<Test>("Test")
+    class_<ModuleTest>("ModuleTest")
         .constructor<double>()
         ;
 
-    class_<World>("World")
-
+    class_<ModuleWorld>("ModuleWorld")
         .constructor()
-
-        .method("greet", &World::greet)
-        .method("set", &World::set)
-        .method("set_ref", &World::set_ref)
-        .method("set_const_ref", &World::set_const_ref)
+        .method("greet", &ModuleWorld::greet)
+        .method("set", &ModuleWorld::set)
+        .method("set_ref", &ModuleWorld::set_ref)
+        .method("set_const_ref", &ModuleWorld::set_const_ref)
         .method("clear", &clearWorld)
-	;
+        ;
 
-    class_<Num>("Num")
+    class_<ModuleNum>("ModuleNum")
         .constructor()
 
         // read and write property
-        .property("x", &Num::getX, &Num::setX)
+        .property("x", &ModuleNum::getX, &ModuleNum::setX)
 
         // read-only property
-        .property("y", &Num::getY)
+        .property("y", &ModuleNum::getY)
         ;
 
-    class_<Number>("Number")
+    class_<ModuleNumber>("ModuleNumber")
 
         .constructor()
 
         // read and write data member
-        .field("x", &Number::x)
+        .field("x", &ModuleNumber::x)
 
         // read only data member
-        .field_readonly("y", &Number::y)
+        .field_readonly("y", &ModuleNumber::y)
         ;
 
     function("Test_get_x_const_ref", Test_get_x_const_ref);
@@ -190,32 +188,31 @@ RCPP_MODULE(yada) {
     function("Test_get_x_pointer", Test_get_x_pointer);
 
 
-    class_<Randomizer>("Randomizer")
+    class_<ModuleRandomizer>("ModuleRandomizer")
         // No default: .default_constructor()
         .constructor<double,double>()
 
-        .method("get" , &Randomizer::get)
+        .method("get" , &ModuleRandomizer::get)
         ;
 }
 
 // [[Rcpp::export]]
-double attr_Test_get_x_const_ref(const Test& x) {
-    return x.value ;
+double attr_Test_get_x_const_ref(const ModuleTest& x) {
+    return x.value;
 }
 
 // [[Rcpp::export]]
-double attr_Test_get_x_ref(Test& x) {
+double attr_Test_get_x_ref(ModuleTest& x) {
     return x.value;
 }
 
 // [[Rcpp::export]]
-double attr_Test_get_x_const_pointer(const Test* x) {
-    return x->value ;
+double attr_Test_get_x_const_pointer(const ModuleTest* x) {
+    return x->value;
 }
 
 // [[Rcpp::export]]
-double attr_Test_get_x_pointer(Test* x) {
-    return x->value ;
+double attr_Test_get_x_pointer(ModuleTest* x) {
+    return x->value;
 }
 
-

inst/unitTests/cpp/modref.cpp

@@ -2,7 +2,7 @@
 //
 // modref.cpp: Rcpp R/C++ interface class library -- module unit tests
 //
-// Copyright (C) 2013 Dirk Eddelbuettel and Romain Francois
+// Copyright (C) 2013 - 2015  Dirk Eddelbuettel and Romain Francois
 //
 // This file is part of Rcpp.
 //
@@ -22,9 +22,9 @@
 #include <Rcpp.h>
 using namespace Rcpp ;
 
-class World {
+class ModRefWorld {
 public:
-    World() : foo(1), msg("hello") {}
+    ModRefWorld() : foo(1), msg("hello") {}
     void set(std::string msg_) { this->msg = msg_; }
     std::string greet() { return msg; }
 
@@ -35,21 +35,21 @@ class World {
     std::string msg;
 };
 
-void clearWorld( World* w ){
+void clearWorld( ModRefWorld* w ){
     w->set( "" );
 }
 
-RCPP_MODULE(yada){
-	class_<World>( "World" )
+RCPP_MODULE(modrefmodule){
+    class_<ModRefWorld>( "ModRefWorld" )
         .default_constructor()
 
-        .method( "greet", &World::greet )
-        .method( "set", &World::set )
+        .method( "greet", &ModRefWorld::greet )
+        .method( "set", &ModRefWorld::set )
         .method( "clear", &clearWorld )
 
-        .field( "foo", &World::foo )
-        .field_readonly( "bar", &World::bar )
-	;
+        .field( "foo", &ModRefWorld::foo )
+        .field_readonly( "bar", &ModRefWorld::bar )
+        ;
 
 }