Added destruct and is_destructed to

  - explicitely destruct a C++ object (without waiting for the GC)
  - check if an object has been destructed

Author: romainfrancois

NAMESPACE

@@ -32,7 +32,9 @@ export(Module,
        cpp_object_initializer,
        cpp_object_dummy,
        Rcpp.plugin.maker,
-       copy
+       copy,
+       destruct,
+       is_destructed
        )
 S3method( print, bytes )
 exportClass(RcppClass)

R/Module.R

@@ -439,6 +439,14 @@ cpp_fields <- function( CLASS, where){
     paste0("Rcpp_",name)
 
 copy <- function( obj ){
-		xp <- .Call(copy_constructor, obj$.cppclass, obj$.pointer )
+		.Call(copy_constructor, obj$.cppclass, obj$.pointer )
+}
+
+destruct <- function(obj){
+		.Call(destructor, obj$.cppclass, obj$.pointer)
+		invisible(NULL)
+}
 
+is_destructed <- function(obj){
+		.Call(is_destructed_impl, obj$.pointer)
 }

inst/NEWS.Rd

@@ -17,7 +17,12 @@
     \item Changes in Rcpp Modules:
     \itemize{
       \item New function \code{copy} to invoke the copy constructor of a
-      C++ class that has been exposed by modules. 
+      C++ class that has been exposed by modules.
+      \item New function \code{destruct} to explicitely call the
+      destructor of the underlying C++ object without waiting for the
+      garbage collector.
+      \item New function \code{is\_destructed} to check if an object has been
+      destructed (presumably by \code{destruct} )
     }
   }
 }

inst/include/Rcpp/module/class.h

@@ -170,6 +170,14 @@
             END_RCPP
         }
 
+        SEXP invoke_destructor(SEXP object) {
+            BEGIN_RCPP
+            run_finalizer(object);
+            XP(object).release() ;
+            return R_NilValue ;
+            END_RCPP
+        }
+
         bool has_default_constructor(){
             int n = constructors.size() ;
             signed_constructor_class* p ;
@@ -498,7 +506,7 @@
         vec_signed_factory factories ;
         self* class_pointer ;
         std::string typeinfo_name ;
-        
+
         class_( ) : class_Base(), vec_methods(), properties(), specials(0), constructors(), factories() {};
 
 

inst/include/Rcpp/module/class_Base.h

@@ -38,6 +38,7 @@ class class_Base {
     virtual void run_finalizer(SEXP){ }
 
     virtual SEXP invoke_copy_constructor(SEXP) = 0 ;
+    virtual SEXP invoke_destructor(SEXP) = 0 ;
     virtual bool has_default_constructor(){ return false ; }
     virtual bool has_method( const std::string& ){
         return false ;

inst/unitTests/runit.Module.R

@@ -104,4 +104,11 @@ if( .runThisTest && Rcpp:::capabilities()[["Rcpp modules"]] ) {
         checkEquals( g$x, 4L)
     }
 
+    test.Module.destructor <- function(){
+        f <- new( ModuleCopyConstructor, 4L)
+        checkEquals( !is_destructed(f) )
+        destruct(f)
+        checkEquals( is_destructed(f) )
+    }
+
 }

man/copy.Rd

@@ -55,4 +55,4 @@
 
 }
 }
-\keyword{ ~kwd1 }
+\keyword{manip}

man/destruct.Rd

@@ -0,0 +1,54 @@
+\name{destruct}
+\alias{destruct}
+\alias{is_destructed}
+\title{
+Explicitely destructs the C++ object.
+}
+\description{
+Explicitely invokes the C++ object destructor. 
+}
+\usage{
+destruct(obj)
+is_destructed(obj)
+}
+\arguments{
+  \item{obj}{A C++ object}
+}
+\details{
+\code{destruct} explicitely destruct the C++ object
+\code{is_destructed} checks if it has been destructed
+}
+\value{
+\code{is_destructed} returns a logical.
+}
+\author{
+  Romain Francois <romain@r-enthusiasts.com>
+}
+\examples{
+\dontrun{
+
+  sourceCpp( code = '
+    #include <Rcpp.h>
+    using namespace Rcpp ;
+
+    class Foo{
+      public:
+        Foo( int x_ ) : x(x_){}
+        ~Foo(){ Rprintf("~Foo\\n") ; }
+        int x ;
+    } ;
+
+    RCPP_MODULE(test){
+      class_<Foo>("Foo")
+        .constructor<int>()
+        .field( "x", &Foo::x)
+      ;
+  }
+  ')
+  f <- new( Foo, 1 )
+  destruct(f)
+  is_destructed(f)
+
+}
+}
+\keyword{manip}

src/Module.cpp

@@ -117,6 +117,13 @@ RCPP_FUN_2( SEXP, copy_constructor, XP_Class cl, SEXP obj){
   return cl->invoke_copy_constructor(obj) ;
 }
 
+RCPP_FUN_2( SEXP, destructor, XP_Class cl, SEXP obj){
+  return cl->invoke_destructor(obj) ;
+}
+RCPP_FUN_1( SEXP, is_destructed_impl, SEXP obj){
+  return Rf_ScalarLogical( R_ExternalPtrAddr(obj) == NULL ) ;
+}
+
 // .External functions
 SEXP InternalFunction_invoke(SEXP args) {
 BEGIN_RCPP

src/Rcpp_init.cpp

@@ -54,6 +54,8 @@ static R_CallMethodDef callEntries[]  = {
     CALLDEF(CppField__get,3),
     CALLDEF(CppField__set,4),
     CALLDEF(copy_constructor,2),
+    CALLDEF(destructor, 2),
+    CALLDEF(is_destructed_impl, 1), 
 
     CALLDEF(rcpp_capabilities,0),
     CALLDEF(rcpp_can_use_cxx0x,0),