[Rcpp-commits] r251 - in pkg: inst inst/examples/RcppInline inst/unitTests src src/Rcpp

noreply at r-forge.r-project.org noreply at r-forge.r-project.org
Fri Jan 1 09:25:56 CET 2010


Author: romain
Date: 2010-01-01 09:25:55 +0100 (Fri, 01 Jan 2010)
New Revision: 251

Modified:
   pkg/inst/ChangeLog
   pkg/inst/examples/RcppInline/RcppInlineWithLibsExamples.r
   pkg/inst/examples/RcppInline/RcppSexpTests.r
   pkg/inst/examples/RcppInline/external_pointer.r
   pkg/inst/unitTests/runit.RObject.R
   pkg/inst/unitTests/runit.XPTr.R
   pkg/inst/unitTests/runit.environments.R
   pkg/src/Evaluator.cpp
   pkg/src/RObject.cpp
   pkg/src/Rcpp/RObject.h
Log:
replace RObject::RObject constructors with RObject::wrap functions

Modified: pkg/inst/ChangeLog
===================================================================
--- pkg/inst/ChangeLog	2010-01-01 07:01:02 UTC (rev 250)
+++ pkg/inst/ChangeLog	2010-01-01 08:25:55 UTC (rev 251)
@@ -1,12 +1,20 @@
 2010-01-01  Romain Francois <francoisromain at free.fr>
 
+	* pkg/src/Rcpp/RObject.h: RObject::RObject constructors are 
+	replaced by the Rcpp::wrap set of functions. Currently the wrap 
+	functions make a RObject object but it is likely that as new
+	classes become available in the new API, wrap will return 
+	instances of classes that extend RObject.
+	
 	* pkg/src/Rcpp/RObject.h: s/protect/preserve/, added methods
 	isPreserved and forgetPreserve
-	
-	* pkg/src/Rcpp/XPtr.h 
-	* pkg/src/RObject.cpp
-	* pkg/src/Evaluator.cpp
 
+	* ** : adapted examples, code, and unit tests to reflect both 
+	above items
+
+2010-01-01  Romain Francois <francoisromain at free.fr>
+
+
 2009-12-31  Romain Francois <francoisromain at free.fr>
 
 	* src/Rcpp/Evaluator.h : new class Rcpp::Evaluator that eases

Modified: pkg/inst/examples/RcppInline/RcppInlineWithLibsExamples.r
===================================================================
--- pkg/inst/examples/RcppInline/RcppInlineWithLibsExamples.r	2010-01-01 07:01:02 UTC (rev 250)
+++ pkg/inst/examples/RcppInline/RcppInlineWithLibsExamples.r	2010-01-01 08:25:55 UTC (rev 251)
@@ -56,7 +56,7 @@
 
     ## now use Rcpp to pass down a parameter for the seed
     gslrng <- '
-    int seed = Rcpp::RObject(par).asInt();
+    int seed = Rcpp::wrap(par).asInt();
 
     gsl_rng *r;
     gsl_rng_env_setup();
@@ -74,7 +74,7 @@
     #endif
 
     gsl_rng_free(r);
-    return Rcpp::RObject(v) ;
+    return Rcpp::wrap(v) ;
     '
 
     ## turn into a function that R can call
@@ -103,8 +103,8 @@
 
     ## now use Rcpp to pass down a parameter for the seed, and a vector size
     gslrng <- '
-    int seed = Rcpp::RObject(s).asInt();
-    int len = Rcpp::RObject(n).asInt();
+    int seed = Rcpp::wrap(s).asInt();
+    int len = Rcpp::wrap(n).asInt();
 
     gsl_rng *r;
     gsl_rng_env_setup();
@@ -118,7 +118,7 @@
     }
     gsl_rng_free(r);
 
-    return Rcpp::RObject(v) ;
+    return Rcpp::wrap(v) ;
     '
 
     ## turn into a function that R can call

Modified: pkg/inst/examples/RcppInline/RcppSexpTests.r
===================================================================
--- pkg/inst/examples/RcppInline/RcppSexpTests.r	2010-01-01 07:01:02 UTC (rev 250)
+++ pkg/inst/examples/RcppInline/RcppSexpTests.r	2010-01-01 08:25:55 UTC (rev 251)
@@ -22,9 +22,9 @@
 
 cat("===Doubles\n")
 foo <- '
-        double d = Rcpp::RObject(x).asDouble();
+        double d = Rcpp::wrap(x).asDouble();
 	std::cout << "Returning twice the value of " << d << " : ";
-	return(Rcpp::RObject( 2*d ) );
+	return(Rcpp::wrap( 2*d ) );
         '
 funx <- cfunction(signature(x="numeric"), foo, Rcpp=TRUE, verbose=FALSE)
 cat(funx(x=2.123), "\n")
@@ -35,9 +35,9 @@
 
 cat("\n===Int\n")
 foo <- '
-        int i = Rcpp::RObject(x).asInt();
+        int i = Rcpp::wrap(x).asInt();
 	std::cout << "Returning twice the value of " << i << " : ";
-	return(Rcpp::RObject( 2*i ) );
+	return(Rcpp::wrap( 2*i ) );
         '
 funx <- cfunction(signature(x="numeric"), foo, Rcpp=TRUE, verbose=FALSE)
 cat(funx(x=2), "\n")
@@ -47,18 +47,18 @@
 
 cat("\n===String\n")
 foo <- '
-        std::string s = Rcpp::RObject(x).asStdString();
+        std::string s = Rcpp::wrap(x).asStdString();
 	std::cout << "Returning twice the value of " << s << " : ";
-	return(Rcpp::RObject( s+s ) );
+	return(Rcpp::wrap( s+s ) );
         '
 funx <- cfunction(signature(x="character"), foo, Rcpp=TRUE, verbose=FALSE)
 cat(funx(x="abc"), "\n")
 
 cat("\n===Raw (bytes)\n")
 foo <- '
-        Rbyte i = Rcpp::RObject(x).asRaw();
+        Rbyte i = Rcpp::wrap(x).asRaw();
 	std::cout << "Returning twice the value of " << (int)i << " : ";
-	return(Rcpp::RObject( (Rbyte)(2*i) ) );
+	return(Rcpp::wrap( (Rbyte)(2*i) ) );
         '
 funx <- cfunction(signature(x="numeric"), foo, Rcpp=TRUE, verbose=FALSE)
 cat( funx(x=2), "\n")
@@ -69,9 +69,9 @@
 
 cat("\n=== logical \n")
 foo <- '
-bool b = Rcpp::RObject(x).asBool();
+bool b = Rcpp::wrap(x).asBool();
 std::cout << "flip  " << ( b ? "TRUE" : "FALSE" ) << " : ";
-return(Rcpp::RObject( !b ));
+return(Rcpp::wrap( !b ));
 '
 funx <- cfunction(signature(x="logical"), foo, Rcpp=TRUE, verbose=FALSE)
 cat( res <- funx(x=TRUE) , "\n")  ; stopifnot( !res )
@@ -90,7 +90,7 @@
 
 cat("\n===Int Vector via RcppResultSet.getSEXP\n")
 foo <- '
-        std::vector<int> iv = Rcpp::RObject(x).asStdVectorInt();
+        std::vector<int> iv = Rcpp::wrap(x).asStdVectorInt();
 	std::cout << "Returning twice the value of vector : ";
         for (size_t i=0; i<iv.size(); i++) {
             iv[i] = 2*iv[i];
@@ -108,12 +108,12 @@
 
 cat("\n===Int Vector\n")
 foo <- '
-        std::vector<int> iv = Rcpp::RObject(x).asStdVectorInt();
+        std::vector<int> iv = Rcpp::wrap(x).asStdVectorInt();
 	std::cout << "Returning twice the value of vector : ";
         for (size_t i=0; i<iv.size(); i++) {
             iv[i] = 2*iv[i];
         }
-	return(Rcpp::RObject( iv ) );
+	return(Rcpp::wrap( iv ) );
         '
 funx <- cfunction(signature(x="numeric"), foo, Rcpp=TRUE, verbose=FALSE)
 print(funx(x=2:5+.1))
@@ -125,12 +125,12 @@
 
 cat("\n===Double Vector\n")
 foo <- '
-        std::vector<double> iv = Rcpp::RObject(x).asStdVectorDouble();
+        std::vector<double> iv = Rcpp::wrap(x).asStdVectorDouble();
 	std::cout << "Returning twice the value of vector : ";
         for (size_t i=0; i<iv.size(); i++) {
             iv[i] = 2*iv[i];
         }
- 	return(Rcpp::RObject( iv ));
+ 	return(Rcpp::wrap( iv ));
         '
 funx <- cfunction(signature(x="numeric"), foo, Rcpp=TRUE, verbose=FALSE)
 print(funx(x=0.1+2:5))
@@ -141,12 +141,12 @@
 
 cat("\n===Raw Vector\n")
 foo <- '
-        std::vector<Rbyte> iv = Rcpp::RObject(x).asStdVectorRaw();
+        std::vector<Rbyte> iv = Rcpp::wrap(x).asStdVectorRaw();
 	std::cout << "Returning twice the value of vector : ";
         for (size_t i=0; i<iv.size(); i++) {
             iv[i] = 2*iv[i];
         }
- 	return(Rcpp::RObject( iv ));
+ 	return(Rcpp::wrap( iv ));
         '
 funx <- cfunction(signature(x="raw"), foo, Rcpp=TRUE, verbose=FALSE)
 print(funx(x=as.raw(0:9)))
@@ -157,12 +157,12 @@
 
 cat("\n=== vector<bool>\n")
 foo <- '
-std::vector<bool> bv = Rcpp::RObject(x).asStdVectorBool();
+std::vector<bool> bv = Rcpp::wrap(x).asStdVectorBool();
 std::cout << "Flip the value of vector : ";
 for (size_t i=0; i<bv.size(); i++) {
     bv[i].flip() ;
 }
-return(Rcpp::RObject( bv ));
+return(Rcpp::wrap( bv ));
 '
 funx <- cfunction(signature(x="logical"), foo, Rcpp=TRUE, verbose=FALSE)
 print(funx(x=c(TRUE,FALSE)))
@@ -176,12 +176,12 @@
 
 cat("\n===String Vector\n")
 foo <- '
-        std::vector<std::string> iv = Rcpp::RObject(x).asStdVectorString();
+        std::vector<std::string> iv = Rcpp::wrap(x).asStdVectorString();
 	std::cout << "Returning twice the value of vector : ";
         for (size_t i=0; i<iv.size(); i++) {
             iv[i] = iv[i] + iv[i];
         }
- 	return(Rcpp::RObject( iv ));
+ 	return(Rcpp::wrap( iv ));
         '
 funx <- cfunction(signature(x="character"), foo, Rcpp=TRUE, verbose=FALSE)
 print(funx(x=c("foo", "bar")))
@@ -193,7 +193,7 @@
 iv.insert( 0 ) ;
 iv.insert( 1 ) ;
 iv.insert( 0 ) ;
-return Rcpp::RObject( iv );'
+return Rcpp::wrap( iv );'
 funx <- cfunction(signature(), foo, Rcpp=TRUE, verbose=FALSE, includes = "#include <set>" )
 print(res <- funx())
 stopifnot( identical( res, 0:1 ) )
@@ -204,7 +204,7 @@
 ds.insert( 0.0 );
 ds.insert( 1.0 );
 ds.insert( 0.0 );
-return(Rcpp::RObject( ds )); '
+return(Rcpp::wrap( ds )); '
 funx <- cfunction(signature(), foo, Rcpp=TRUE, verbose=FALSE, includes = "#include <set>")
 print( res <- funx() )
 stopifnot( identical( res, as.numeric(0:1)))
@@ -215,7 +215,7 @@
 bs.insert( (Rbyte)0 ) ;
 bs.insert( (Rbyte)1 ) ;
 bs.insert( (Rbyte)0 ) ;
-return(Rcpp::RObject( bs )); '
+return(Rcpp::wrap( bs )); '
 funx <- cfunction(signature(), foo, Rcpp=TRUE, verbose=FALSE, includes = "#include <set>")
 print( res <- funx() )
 stopifnot( identical( res, as.raw(0:1)))
@@ -226,7 +226,7 @@
 ss.insert( "foo" ) ;
 ss.insert( "bar" ) ;
 ss.insert( "foo" ) ;
-return(Rcpp::RObject( ss )); '
+return(Rcpp::wrap( ss )); '
 funx <- cfunction(signature(), foo, Rcpp=TRUE, verbose=FALSE, include = "#include <set>" )
 print( res <- funx() )
 stopifnot( identical( res, c("bar","foo")) )
@@ -236,29 +236,29 @@
 
 funx <- cfunction(
 	signature(x="data.frame"), '
-std::vector<std::string> iv = Rcpp::RObject(x).attributeNames();
-return(Rcpp::RObject( iv ));
+std::vector<std::string> iv = Rcpp::wrap(x).attributeNames();
+return(Rcpp::wrap( iv ));
 ', Rcpp=TRUE, verbose=FALSE)
 res <- funx( iris )
 stopifnot( all( c("names", "row.names", "class" ) %in% res ) )
 
 funx <- cfunction(signature(x="data.frame"), '
-bool has_class = Rcpp::RObject(x).hasAttribute( "class" ) ;
-return Rcpp::RObject( has_class ) ;
+bool has_class = Rcpp::wrap(x).hasAttribute( "class" ) ;
+return Rcpp::wrap( has_class ) ;
 ', Rcpp=TRUE, verbose=FALSE)
 res <- funx( iris )
 stopifnot( res )
 
 funx <- cfunction(signature(x="data.frame"), '
-return Rcpp::RObject(x).attr( "row.names" ) ;
+return Rcpp::wrap(x).attr( "row.names" ) ;
 ', Rcpp=TRUE, verbose=FALSE)
 res <- funx( iris )
 stopifnot( identical(res, 1:150) )
 
 #============ NULL
 funx <- cfunction(signature(x="ANY"), '
-bool is_null = Rcpp::RObject(x).isNULL() ;
-return Rcpp::RObject( is_null ) ;
+bool is_null = Rcpp::wrap(x).isNULL() ;
+return Rcpp::wrap( is_null ) ;
 ', Rcpp=TRUE, verbose=FALSE)
 res <- funx( iris )
 stopifnot( !res )

Modified: pkg/inst/examples/RcppInline/external_pointer.r
===================================================================
--- pkg/inst/examples/RcppInline/external_pointer.r	2010-01-01 07:01:02 UTC (rev 250)
+++ pkg/inst/examples/RcppInline/external_pointer.r	2010-01-01 08:25:55 UTC (rev 251)
@@ -51,7 +51,7 @@
 	Rcpp::XPtr< std::vector<int> > p(x) ;
 	
 	/* just return the front of the vector as a SEXP */
-	return( Rcpp::RObject( p->front() ) ) ;
+	return( Rcpp::wrap( p->front() ) ) ;
 ', Rcpp=TRUE, verbose=FALSE)
 front <- funx(xp)
 stopifnot( identical( front, 1L ) )

Modified: pkg/inst/unitTests/runit.RObject.R
===================================================================
--- pkg/inst/unitTests/runit.RObject.R	2010-01-01 07:01:02 UTC (rev 250)
+++ pkg/inst/unitTests/runit.RObject.R	2010-01-01 08:25:55 UTC (rev 251)
@@ -25,8 +25,8 @@
 
 test.RObject.asDouble <- function(){
 	foo <- '
-	double d = Rcpp::RObject(x).asDouble();
-	return(Rcpp::RObject( 2*d ) );
+	double d = Rcpp::wrap(x).asDouble();
+	return(Rcpp::wrap( 2*d ) );
 	'
 	funx <- cfunction(signature(x="numeric"), foo, 
 		Rcpp=TRUE, verbose=FALSE)
@@ -39,8 +39,8 @@
 
 test.RObject.asInt <- function(){
 	foo <- '
-	int i = Rcpp::RObject(x).asInt();
-	return(Rcpp::RObject( 2*i ) ); '
+	int i = Rcpp::wrap(x).asInt();
+	return(Rcpp::wrap( 2*i ) ); '
 	funx <- cfunction(signature(x="numeric"), foo, 
 		Rcpp=TRUE, verbose=FALSE)
 	checkEquals( funx(2.123), 4L, msg = "RObject.asInt()" )
@@ -54,8 +54,8 @@
 
 test.RObject.asStdString <- function(){
 	foo <- '
-	std::string s = Rcpp::RObject(x).asStdString();
-	return(Rcpp::RObject( s+s ) );'
+	std::string s = Rcpp::wrap(x).asStdString();
+	return(Rcpp::wrap( s+s ) );'
 	funx <- cfunction(signature(x="character"), foo, 
 		Rcpp=TRUE, verbose=FALSE)
 	checkEquals( funx("abc"), "abcabc", msg = "RObject.asStdString()" )
@@ -70,8 +70,8 @@
 
 test.RObject.asRaw <- function(){
 	foo <- '
-	Rbyte i = Rcpp::RObject(x).asRaw();
-	return(Rcpp::RObject( (Rbyte)(2*i) ) ); '
+	Rbyte i = Rcpp::wrap(x).asRaw();
+	return(Rcpp::wrap( (Rbyte)(2*i) ) ); '
 	funx <- cfunction(signature(x="raw"), foo, Rcpp=TRUE, verbose=FALSE)
 	checkEquals( funx(1L), as.raw(2L), msg = "RObject.asRaw(integer)" )
 	checkEquals( funx(1.3), as.raw(2L), msg = "RObject.asRaw(numeric)" )
@@ -88,8 +88,8 @@
 
 test.RObject.asLogical <- function(){
 	foo <- '
-	bool b = Rcpp::RObject(x).asBool();
-	return(Rcpp::RObject( !b ));'
+	bool b = Rcpp::wrap(x).asBool();
+	return(Rcpp::wrap( !b ));'
 	funx <- cfunction(signature(x="logical"), foo, Rcpp=TRUE, verbose=FALSE)
 	checkTrue( !funx(TRUE), msg = "RObject::asBool(TRUE) -> true" )
 	checkTrue( funx(FALSE), msg = "RObject::asBool(FALSE) -> false" )
@@ -113,7 +113,7 @@
 
 test.RObject.asStdVectorIntResultsSet <- function(){
 	foo <- '
-		std::vector<int> iv = Rcpp::RObject(x).asStdVectorInt();
+		std::vector<int> iv = Rcpp::wrap(x).asStdVectorInt();
 		for (size_t i=0; i<iv.size(); i++) {
     	    iv[i] = 2*iv[i];
     	}
@@ -130,11 +130,11 @@
 
 test.RObject.asStdVectorInt <- function(){
 	foo <- '
-		std::vector<int> iv = Rcpp::RObject(x).asStdVectorInt();
+		std::vector<int> iv = Rcpp::wrap(x).asStdVectorInt();
 		for (size_t i=0; i<iv.size(); i++) {
     	    iv[i] = 2*iv[i];
     	}
-		return(Rcpp::RObject( iv ) );'
+		return(Rcpp::wrap( iv ) );'
 	funx <- cfunction(signature(x="numeric"), foo, Rcpp=TRUE, verbose=FALSE)
 	checkEquals( funx(x=2:5), 2:5*2L, msg = "RObject(integer).asStdVectorInt" )
     checkEquals( funx(x=2:5+.1), 2:5*2L, msg = "RObject(numeric).asStdVectorInt" )
@@ -146,11 +146,11 @@
 
 test.RObject.asStdVectorDouble <- function(){
 	foo <- '
-		std::vector<double> iv = Rcpp::RObject(x).asStdVectorDouble();
+		std::vector<double> iv = Rcpp::wrap(x).asStdVectorDouble();
 		for (size_t i=0; i<iv.size(); i++) {
 	        iv[i] = 2*iv[i];
 	    }
-	 	return(Rcpp::RObject( iv ));'
+	 	return(Rcpp::wrap( iv ));'
 	funx <- cfunction(signature(x="numeric"), foo, Rcpp=TRUE, verbose=FALSE)
 	checkEquals( funx(x=0.1+2:5), 2*(0.1+2:5), msg = "RObject(numeric).asStdVectorDouble" )
 	checkEquals( funx(x=2:5), 2*(2:5), msg = "RObject(integer).asStdVectorDouble" )
@@ -162,11 +162,11 @@
 
 test.RObject.asStdVectorRaw <- function(){
 	foo <- '
-    	std::vector<Rbyte> iv = Rcpp::RObject(x).asStdVectorRaw();
+    	std::vector<Rbyte> iv = Rcpp::wrap(x).asStdVectorRaw();
 		for (size_t i=0; i<iv.size(); i++) {
     	    iv[i] = 2*iv[i];
     	}
- 		return(Rcpp::RObject( iv ));'
+ 		return(Rcpp::wrap( iv ));'
 	funx <- cfunction(signature(x="raw"), foo, Rcpp=TRUE, verbose=FALSE)
 	checkEquals( funx(x=as.raw(0:9)), as.raw(2*(0:9)), msg = "RObject(raw).asStdVectorRaw" )
 	checkEquals( funx(x=0:9), as.raw(2*(0:9)), msg = "RObject(integer).asStdVectorRaw" )
@@ -178,11 +178,11 @@
 
 test.RObject.asStdVectorBool <- function(){
 	foo <- '
-		std::vector<bool> bv = Rcpp::RObject(x).asStdVectorBool();
+		std::vector<bool> bv = Rcpp::wrap(x).asStdVectorBool();
 		for (size_t i=0; i<bv.size(); i++) {
 		    bv[i].flip() ;
 		}
-		return(Rcpp::RObject( bv ));'
+		return(Rcpp::wrap( bv ));'
 	funx <- cfunction(signature(x="logical"), foo, Rcpp=TRUE, verbose=FALSE)
 	checkEquals( funx(x=c(TRUE,FALSE)), c(FALSE, TRUE), msg = "RObject(logical).asStdVectorBool" )
 	checkEquals( funx(x=c(1L, 0L)), c(FALSE, TRUE), msg = "RObject(integer).asStdVectorBool" )
@@ -194,11 +194,11 @@
 
 test.RObject.asStdVectorString <- function(){
 	foo <- '
-    	std::vector<std::string> iv = Rcpp::RObject(x).asStdVectorString();
+    	std::vector<std::string> iv = Rcpp::wrap(x).asStdVectorString();
 		for (size_t i=0; i<iv.size(); i++) {
     	    iv[i] = iv[i] + iv[i];
     	}
- 	return(Rcpp::RObject( iv ));'
+ 	return(Rcpp::wrap( iv ));'
 	funx <- cfunction(signature(x="character"), foo, Rcpp=TRUE, verbose=FALSE)
 	checkEquals( funx(c("foo", "bar")), c("foofoo", "barbar"), msg = "RObject(character).asStdVectorString" )
 	checkException( funx(1L), msg = "RObject(integer).asStdVectorString -> exception" )
@@ -214,7 +214,7 @@
 		iv.insert( 0 ) ;
 		iv.insert( 1 ) ;
 		iv.insert( 0 ) ;
-		return Rcpp::RObject( iv );'
+		return Rcpp::wrap( iv );'
 	funx <- cfunction(signature(), foo, Rcpp=TRUE, verbose=FALSE, includes = "#include <set>" )
 	checkEquals( funx(), c(0L, 1L), msg = "RObject( set<int> )" )
 }
@@ -225,7 +225,7 @@
 		ds.insert( 0.0 );
 		ds.insert( 1.0 );
 		ds.insert( 0.0 );
-		return(Rcpp::RObject( ds )); '
+		return(Rcpp::wrap( ds )); '
 	funx <- cfunction(signature(), foo, Rcpp=TRUE, verbose=FALSE, includes = "#include <set>")
 	checkEquals( funx(), as.numeric(0:1), msg = "RObject( set<double>" )
 }
@@ -236,7 +236,7 @@
 		bs.insert( (Rbyte)0 ) ;
 		bs.insert( (Rbyte)1 ) ;
 		bs.insert( (Rbyte)0 ) ;
-		return(Rcpp::RObject( bs )); '
+		return(Rcpp::wrap( bs )); '
 	funx <- cfunction(signature(), foo, Rcpp=TRUE, verbose=FALSE, includes = "#include <set>")
 	checkEquals( funx(), as.raw(0:1), msg = "RObject(set<raw>)" )
 }
@@ -247,38 +247,38 @@
 		ss.insert( "foo" ) ;
 		ss.insert( "bar" ) ;
 		ss.insert( "foo" ) ;
-		return(Rcpp::RObject( ss )); '
+		return(Rcpp::wrap( ss )); '
 	funx <- cfunction(signature(), foo, Rcpp=TRUE, verbose=FALSE, include = "#include <set>" )
 	checkEquals( funx(), c("bar", "foo"), msg = "RObject(set<string>)" )
 }
 
 test.RObject.attributeNames <- function(){
 	funx <- cfunction(signature(x="data.frame"), '
-		std::vector<std::string> iv = Rcpp::RObject(x).attributeNames();
-		return(Rcpp::RObject( iv ));', 
+		std::vector<std::string> iv = Rcpp::wrap(x).attributeNames();
+		return(Rcpp::wrap( iv ));', 
 		Rcpp=TRUE, verbose=FALSE)
 	checkTrue( all( c("names","row.names","class") %in% funx(iris)), msg = "RObject.attributeNames" )
 }
 
 test.RObject.hasAttribute <- function(){
 	funx <- cfunction(signature(x="data.frame"), '
-		bool has_class = Rcpp::RObject(x).hasAttribute( "class" ) ;
-		return Rcpp::RObject( has_class ) ;', 
+		bool has_class = Rcpp::wrap(x).hasAttribute( "class" ) ;
+		return Rcpp::wrap( has_class ) ;', 
 		Rcpp=TRUE, verbose=FALSE)
 	checkTrue( funx( iris ), msg = "RObject.hasAttribute" )
 }
 
 test.RObject.attr <- function(){
 	funx <- cfunction(signature(x="data.frame"), '
-		return Rcpp::RObject(x).attr( "row.names" ) ;
+		return Rcpp::wrap(x).attr( "row.names" ) ;
 		', Rcpp=TRUE, verbose=FALSE)
 	checkEquals( funx( iris ), 1:150, msg = "RObject.attr" )
 }
 
 test.RObject.isNULL <- function(){
 	funx <- cfunction(signature(x="ANY"), '
-		bool is_null = Rcpp::RObject(x).isNULL() ;
-		return Rcpp::RObject( is_null ) ;
+		bool is_null = Rcpp::wrap(x).isNULL() ;
+		return Rcpp::wrap( is_null ) ;
 		', Rcpp=TRUE, verbose=FALSE)
 	checkTrue( !funx( iris ), msg = "RObject.isNULL(iris) -> false" )
 	checkTrue( funx(NULL), msg = "RObject.isNULL(NULL) -> true" )

Modified: pkg/inst/unitTests/runit.XPTr.R
===================================================================
--- pkg/inst/unitTests/runit.XPTr.R	2010-01-01 07:01:02 UTC (rev 250)
+++ pkg/inst/unitTests/runit.XPTr.R	2010-01-01 08:25:55 UTC (rev 251)
@@ -55,7 +55,7 @@
 		Rcpp::XPtr< std::vector<int> > p(x) ;
 		
 		/* just return the front of the vector as a SEXP */
-		return( Rcpp::RObject( p->front() ) ) ;
+		return( Rcpp::wrap( p->front() ) ) ;
 	', Rcpp=TRUE, verbose=FALSE)
 	front <- funx(xp)
 	checkEquals( front, 1L, msg = "check usage of external pointer" )

Modified: pkg/inst/unitTests/runit.environments.R
===================================================================
--- pkg/inst/unitTests/runit.environments.R	2010-01-01 07:01:02 UTC (rev 250)
+++ pkg/inst/unitTests/runit.environments.R	2010-01-01 08:25:55 UTC (rev 251)
@@ -48,7 +48,7 @@
 test.environment.get <- function(){
 	funx <- cfunction(signature(x="environment", name = "character" ), '
 	Rcpp::Environment env(x) ;
-	return env.get( Rcpp::RObject(name).asStdString() ) ;
+	return env.get( Rcpp::wrap(name).asStdString() ) ;
 	', Rcpp=TRUE, verbose=FALSE)
 	
 	e <- new.env( )
@@ -65,8 +65,8 @@
 test.environment.exists <- function(){
 	funx <- cfunction(signature(x="environment", name = "character" ), '
 	Rcpp::Environment env(x) ;
-	std::string st = Rcpp::RObject(name).asStdString() ;
-	return Rcpp::RObject( env.exists(st) ) ;
+	std::string st = Rcpp::wrap(name).asStdString() ;
+	return Rcpp::wrap( env.exists(st) ) ;
 	', Rcpp=TRUE, verbose=FALSE)
 	
 	e <- new.env( )
@@ -83,8 +83,8 @@
 	
 	funx <- cfunction(signature(x="environment", name = "character", object = "ANY" ), '
 	Rcpp::Environment env(x) ;
-	std::string st = Rcpp::RObject(name).asStdString() ;
-	return Rcpp::RObject( env.assign(st, object) ) ;
+	std::string st = Rcpp::wrap(name).asStdString() ;
+	return Rcpp::wrap( env.assign(st, object) ) ;
 	', Rcpp=TRUE, verbose=FALSE)
 	
 	e <- new.env( )
@@ -104,7 +104,7 @@
 test.environment.isLocked <- function(){
 	funx <- cfunction(signature(x="environment" ), '
 	Rcpp::Environment env(x) ;
-	return Rcpp::RObject( env.isLocked() ) ;
+	return Rcpp::wrap( env.isLocked() ) ;
 	', Rcpp=TRUE, verbose=FALSE)
 	
 	e <- new.env()
@@ -117,8 +117,8 @@
 	
 	funx <- cfunction(signature(x="environment", name = "character" ), '
 	Rcpp::Environment env(x) ;
-	std::string st = Rcpp::RObject(name).asStdString() ;
-	return Rcpp::RObject( env.bindingIsActive(st) ) ;
+	std::string st = Rcpp::wrap(name).asStdString() ;
+	return Rcpp::wrap( env.bindingIsActive(st) ) ;
 	', Rcpp=TRUE, verbose=FALSE)
 	
 	e <- new.env()
@@ -137,8 +137,8 @@
 	
 	funx <- cfunction(signature(x="environment", name = "character" ), '
 	Rcpp::Environment env(x) ;
-	std::string st = Rcpp::RObject(name).asStdString() ;
-	return Rcpp::RObject( env.bindingIsLocked(st) ) ;
+	std::string st = Rcpp::wrap(name).asStdString() ;
+	return Rcpp::wrap( env.bindingIsLocked(st) ) ;
 	', Rcpp=TRUE, verbose=FALSE)
 	
 	e <- new.env()
@@ -167,7 +167,7 @@
 test.environment.lockBinding <- function(){
 	funx <- cfunction(signature(x="environment", name = "character" ), '
 	Rcpp::Environment env(x) ;
-	std::string st = Rcpp::RObject(name).asStdString() ;
+	std::string st = Rcpp::wrap(name).asStdString() ;
 	env.lockBinding( st ) ;
 	return R_NilValue ;
 	', Rcpp=TRUE, verbose=FALSE)
@@ -186,7 +186,7 @@
 test.environment.unlockBinding <- function(){
 	funx <- cfunction(signature(x="environment", name = "character" ), '
 	Rcpp::Environment env(x) ;
-	std::string st = Rcpp::RObject(name).asStdString() ;
+	std::string st = Rcpp::wrap(name).asStdString() ;
 	env.unlockBinding( st ) ;
 	return R_NilValue ;
 	', Rcpp=TRUE, verbose=FALSE)
@@ -229,7 +229,7 @@
 
 test.environment.namespace.env <- function(){
 	funx <- cfunction(signature(env = "character" ),  '
-	std::string st = Rcpp::RObject(env).asStdString() ;
+	std::string st = Rcpp::wrap(env).asStdString() ;
 	return Rcpp::Environment::namespace_env(st); ', Rcpp=TRUE, verbose=FALSE)
 	checkEquals( funx("Rcpp"), asNamespace("Rcpp"), msg = "REnvironment::base_namespace" )
 	checkTrue( 

Modified: pkg/src/Evaluator.cpp
===================================================================
--- pkg/src/Evaluator.cpp	2010-01-01 07:01:02 UTC (rev 250)
+++ pkg/src/Evaluator.cpp	2010-01-01 08:25:55 UTC (rev 251)
@@ -35,11 +35,11 @@
 	void Evaluator::run(SEXP env ){
 		Environment rcpp = Environment::namespace_env("Rcpp") ;
 		SEXP call = Rf_lang3( Rf_install("protectedEval"), expression, env ) ;
-		result = RObject( Rf_eval( call, rcpp ) ); 
+		result = wrap( Rf_eval( call, rcpp ) ); 
 		result.preserve() ;
 		error_occured = LOGICAL( Rf_eval( Rf_lang1( Rf_install("errorOccured")) , rcpp) )[0] ;
 		if( error_occured ){
-			error = RObject( Rf_eval( Rf_lang1(Rf_install("getCurrentError")) , rcpp) );
+			error = wrap( Rf_eval( Rf_lang1(Rf_install("getCurrentError")) , rcpp) );
 			error.preserve() ;
 		}
 	}

Modified: pkg/src/RObject.cpp
===================================================================
--- pkg/src/RObject.cpp	2010-01-01 07:01:02 UTC (rev 250)
+++ pkg/src/RObject.cpp	2010-01-01 08:25:55 UTC (rev 251)
@@ -24,73 +24,93 @@
 
 namespace Rcpp {
 
-RObject::RObject(const bool & v) {
+RObject wrap(SEXP m_sexp=R_NilValue){
+    return RObject(m_sexp) ;
+}
+	
+RObject wrap(const bool & v){
     logTxt("RObject from bool\n");
-    m_sexp = Rf_ScalarLogical(v);
-    preserve() ;
+    RObject o(Rf_ScalarLogical(v));
+    o.preserve() ;
+    return o ;
 }
 
-RObject::RObject(const double & v) {
+RObject wrap(const double & v){
     logTxt("RObject from double\n");
-    m_sexp = Rf_ScalarReal(v);
-    preserve() ;
+    RObject o(Rf_ScalarReal(v));
+    o.preserve() ;
+    return o ;
 }
 
-RObject::RObject(const int & v) {
+RObject wrap(const int & v){
     logTxt("RObject from int\n");
-    m_sexp = Rf_ScalarInteger(v);
-    preserve() ;
+    RObject o(Rf_ScalarInteger(v));
+    o.preserve() ;
+    return o ;
 }
 
-RObject::RObject(const Rbyte & v) {
+RObject wrap(const Rbyte & v){
     logTxt("RObject from raw\n");
-    m_sexp = Rf_ScalarRaw(v);
-    preserve() ;
+    RObject o(Rf_ScalarRaw(v));
+    o.preserve() ;
+    return o ;
 }
 
-RObject::RObject(const std::string & v) {
+RObject wrap(const std::string & v){
     logTxt("RObject from std::string\n");
-    m_sexp = Rf_mkString(v.c_str());
-    preserve() ;
+    RObject o(Rf_mkString(v.c_str()));
+    o.preserve() ;
+    return o ;
 }
 
-RObject::RObject(const std::vector<bool> & v) {
+RObject wrap(const std::vector<bool> & v){
     logTxt("RObject from bool vector\n");
     int n = v.size();
-    m_sexp = Rf_allocVector(LGLSXP, n);
-    preserve() ;
+    SEXP m_sexp = PROTECT( Rf_allocVector(LGLSXP, n) );
     copy( v.begin(), v.end(), LOGICAL(m_sexp) ) ;
+    RObject o(m_sexp) ;
+    o.preserve() ;
+    UNPROTECT(1) ; /* m_sexp now preserved by o */
+    return o ;
 }
 
-RObject::RObject(const std::vector<int> & v) {
+RObject wrap(const std::vector<int> & v){
     logTxt("RObject from int vector\n");
     int n = v.size();
-    m_sexp = Rf_allocVector(INTSXP, n);
-    preserve() ;
+    SEXP m_sexp = PROTECT( Rf_allocVector(INTSXP, n) );
     copy( v.begin(), v.end(), INTEGER(m_sexp) ) ;
+    RObject o(m_sexp) ;
+    o.preserve() ;
+    UNPROTECT(1) ;
+    return o ;
 }
 
-RObject::RObject(const std::vector<double> & v) {
+RObject wrap(const std::vector<double> & v){
     logTxt("RObject from double vector\n");
     int n = v.size();
-    m_sexp = Rf_allocVector(REALSXP, n);
-    preserve() ;
+    SEXP m_sexp = PROTECT( Rf_allocVector(REALSXP, n) );
     copy( v.begin(), v.end(), REAL(m_sexp) ) ;
+    RObject o(m_sexp) ;
+    o.preserve() ;
+    UNPROTECT(1) ;
+    return o ;
 }
 
-RObject::RObject(const std::vector<Rbyte> & v) {
+RObject wrap(const std::vector<Rbyte> & v){
     logTxt("RObject from vector<Rbyte> \n");
     int n = v.size();
-    m_sexp = Rf_allocVector(RAWSXP, n);
-    preserve() ;
+    SEXP m_sexp = PROTECT(Rf_allocVector(RAWSXP, n));
     copy( v.begin(), v.end(), RAW(m_sexp) ) ;
+    RObject o(m_sexp) ;
+    o.preserve() ;
+    UNPROTECT(1) ;
+    return o ;
 }
 
-RObject::RObject(const std::vector<std::string> & v) {
+RObject wrap(const std::vector<std::string> & v){
     logTxt("RObject from std::string vector\n");
     int n = v.size();
-    m_sexp = Rf_allocVector(STRSXP, n);
-    preserve() ;
+    SEXP m_sexp = PROTECT(Rf_allocVector(STRSXP, n));
     int i=0; 
     std::vector<std::string>::const_iterator it = v.begin() ;
     while( i<n ){
@@ -98,39 +118,51 @@
     	i++ ;
     	it++; 
     }
+    RObject o(m_sexp) ;
+    o.preserve() ;
+    UNPROTECT(1) ;
+    return o ;
 }
 
 /* sets */
 
-RObject::RObject(const std::set<int> & v) {
+RObject wrap(const std::set<int> & v){
     logTxt("RObject from set<int>\n");
     int n = v.size();
-    m_sexp = Rf_allocVector(INTSXP, n);
-    preserve() ;
+    SEXP m_sexp = Rf_allocVector(INTSXP, n);
     copy( v.begin(), v.end(), INTEGER(m_sexp) ) ;
+    RObject o(m_sexp) ;
+    o.preserve() ;
+    UNPROTECT(1) ;
+    return o ;
 }
 
-RObject::RObject(const std::set<double> & v) {
+RObject wrap(const std::set<double> & v){
     logTxt("RObject from set<double>\n");
     int n = v.size();
-    m_sexp = Rf_allocVector(REALSXP, n);
-    preserve() ;
+    SEXP m_sexp = Rf_allocVector(REALSXP, n);
     copy( v.begin(), v.end(), REAL(m_sexp) ) ;
+    RObject o(m_sexp) ;
+    o.preserve() ;
+    UNPROTECT(1) ;
+    return o ;
 }
 
-RObject::RObject(const std::set<Rbyte> & v) {
+RObject wrap(const std::set<Rbyte> & v){
     logTxt("RObject from set<Rbyte> \n");
     int n = v.size();
-    m_sexp = Rf_allocVector(RAWSXP, n);
-    preserve() ;
+    SEXP m_sexp = Rf_allocVector(RAWSXP, n);
     copy( v.begin(), v.end(), RAW(m_sexp) ) ;
+    RObject o(m_sexp) ;
+    o.preserve() ;
+    UNPROTECT(1) ;
+    return o ;
 }
 
-RObject::RObject(const std::set<std::string> & v) {
+RObject wrap(const std::set<std::string> & v){
     logTxt("RObject from set<string>\n");
     int n = v.size();
-    m_sexp = Rf_allocVector(STRSXP, n);
-    preserve() ;
+    SEXP m_sexp = Rf_allocVector(STRSXP, n);
     int i=0;
     std::set<std::string>::iterator it = v.begin(); 
     while( i<n ){
@@ -138,11 +170,15 @@
     	i++ ;
     	it++; 
     }
+    RObject o(m_sexp) ;
+    o.preserve() ;
+    UNPROTECT(1) ;
+    return o ;
 }
 
 RObject::~RObject() {
+	logTxt("~RObject");
 	release() ;
-    logTxt("~RObject");
 }
 
 double RObject::asDouble() const {

Modified: pkg/src/Rcpp/RObject.h
===================================================================
--- pkg/src/Rcpp/RObject.h	2010-01-01 07:01:02 UTC (rev 250)
+++ pkg/src/Rcpp/RObject.h	2010-01-01 08:25:55 UTC (rev 251)
@@ -34,7 +34,9 @@
      * wraps a SEXP. The SEXP is not automatically 
      * protected from garbage collection because it might be 
      * protected from elsewhere (e.g. if it comes from the 
-     * R side). See protect and release for ways to protect
+     * R side). 
+     * 
+     * See preserve and release for ways to protect
      * the SEXP from garbage collection, and release to 
      * remove the protection
      */
@@ -42,29 +44,11 @@
     
     /**
      * if this object is protected rom R's GC, then it is released
-     * and become subject to garbage collection. See protect 
+     * and become subject to garbage collection. See preserve 
      * and release member functions.
      */
     ~RObject() ;
-    
-    RObject(const double & v);
-    RObject(const int & v);
-    RObject(const Rbyte & v);
-    RObject(const std::string & v);
-    RObject(const bool & v);
-    
-    RObject(const std::vector<int> & v);
-    RObject(const std::vector<double> & v);
-    RObject(const std::vector<std::string> & v);
-    RObject(const std::vector<Rbyte> & v);
-    RObject(const std::vector<bool> & v);
-    
-    RObject(const std::set<int> & v);
-    RObject(const std::set<double> & v);
-    RObject(const std::set<std::string> & v);
-    RObject(const std::set<Rbyte> & v);
-    
-    
+   
     /* we don't provide implicit converters because 
        of Item 5 in More Effective C++ */
     bool                     asBool() const;
@@ -175,6 +159,27 @@
     
 };
 
+// factories
+RObject wrap(SEXP m_sexp) ;
+
+RObject wrap(const bool & v);
+RObject wrap(const double & v);
+RObject wrap(const int & v);
+RObject wrap(const Rbyte & v);
+RObject wrap(const std::string & v);
+
+RObject wrap(const std::vector<int> & v);
+RObject wrap(const std::vector<double> & v);
+RObject wrap(const std::vector<std::string> & v);
+RObject wrap(const std::vector<Rbyte> & v);
+RObject wrap(const std::vector<bool> & v);
+
+RObject wrap(const std::set<int> & v);
+RObject wrap(const std::set<double> & v);
+RObject wrap(const std::set<std::string> & v);
+RObject wrap(const std::set<Rbyte> & v);
+
+
 } // namespace Rcpp
 
 // to provide some backwards compatibility with Rcpp 0.7.0 which has RcppSexp



More information about the Rcpp-commits mailing list