drop the .copy_constructor declaration. The availability of a copy

constructor is now automatic with the `has_copy_constructor` trait.

Author: romainfrancois

inst/NEWS.Rd

@@ -17,9 +17,7 @@
     \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. \code{copy} only
-      works if the copy constructor has been declared by the
-      \code{copy\_constructor} module declaration.
+      C++ class that has been exposed by modules. 
     }
   }
 }

inst/include/Rcpp/module/class.h

@@ -22,6 +22,21 @@
 #ifndef Rcpp_Module_CLASS_h
 #define Rcpp_Module_CLASS_h
 
+    template <typename Class, bool ok>
+    struct CopyConstructor {
+        static Class* get( Class* obj ){
+          return new Class(*obj) ;
+        }
+    } ;
+
+    template <typename Class>
+    struct CopyConstructor<Class,false> {
+        static Class* get( Class* obj){
+          stop("no copy constructor available") ;
+          return obj ;
+        }
+    } ;
+
     template <typename Class>
     class class_ : public class_Base {
     public:
@@ -60,8 +75,7 @@
             constructors(),
             factories(),
             class_pointer(0),
-            typeinfo_name(""),
-            has_copy_constructor(false)
+            typeinfo_name("")
         {
             class_pointer = get_instance() ;
         }
@@ -112,11 +126,6 @@
             return constructor( docstring, valid ) ;
         }
 
-        self& copy_constructor(){
-            class_pointer->has_copy_constructor = true ;
-            return *this ;
-        }
-
 #include <Rcpp/module/Module_generated_class_constructor.h>
 #include <Rcpp/module/Module_generated_class_factory.h>
 
@@ -156,12 +165,8 @@
 
         SEXP invoke_copy_constructor( SEXP object ){
             BEGIN_RCPP
-
-            if( !has_copy_constructor )
-                stop("copy constructor not exposed") ;
-
             XP xp(object) ;
-            return internal::make_new_object<Class>( new Class(*xp) ) ;
+            return internal::make_new_object<Class>( CopyConstructor< Class, traits::has_copy_constructor<Class>::value >::get(xp) ) ;
             END_RCPP
         }
 
@@ -493,8 +498,7 @@
         vec_signed_factory factories ;
         self* class_pointer ;
         std::string typeinfo_name ;
-        bool has_copy_constructor ;
-
+        
         class_( ) : class_Base(), vec_methods(), properties(), specials(0), constructors(), factories() {};
 
 

inst/include/Rcpp/module/class_Base.h

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

inst/include/Rcpp/traits/has_copy_constructor.h

@@ -0,0 +1,46 @@
+// -*- mode: C++; c-indent-level: 4; c-basic-offset: 4; tab-width: 8 -*-
+//
+// Copyright (C) 2016 Romain Francois
+//
+// This file is part of Rcpp.
+//
+// Rcpp is free software: you can redistribute it and/or modify it
+// under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 2 of the License, or
+// (at your option) any later version.
+//
+// Rcpp is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Rcpp.  If not, see <http://www.gnu.org/licenses/>.
+
+#ifndef Rcpp__traits__has_copy_constructor__h
+#define Rcpp__traits__has_copy_constructor__h
+
+namespace Rcpp{
+namespace traits{
+
+  template<typename T>
+  class _has_copy_constructor_helper : __sfinae_types {
+      template<typename U> struct _Wrap_type { };
+
+      template<typename U>
+        static __one __test(U);
+
+      template<typename U>
+        static __two __test(...);
+
+    public:
+      static const bool value = sizeof(__test<T>(0)) == 1;
+    };
+
+  template<typename T> struct has_copy_constructor :
+  	integral_constant<bool,_has_copy_constructor_helper<T>::value> { };
+
+} // traits
+} // Rcpp
+
+#endif

inst/include/Rcpp/traits/traits.h

@@ -3,7 +3,7 @@
 //
 // traits.h: Rcpp R/C++ interface class library -- traits to help wrap
 //
-// Copyright (C) 2012 - 2013 Dirk Eddelbuettel and Romain Francois
+// Copyright (C) 2012 - 2016 Dirk Eddelbuettel and Romain Francois
 //
 // This file is part of Rcpp.
 //
@@ -44,6 +44,7 @@ struct int2type { enum { value = I }; };
 #include <Rcpp/traits/named_object.h>
 #include <Rcpp/traits/is_convertible.h>
 #include <Rcpp/traits/has_iterator.h>
+#include <Rcpp/traits/has_copy_constructor.h>
 #include <Rcpp/traits/expands_to_logical.h>
 #include <Rcpp/traits/matrix_interface.h>
 #include <Rcpp/traits/is_sugar_expression.h>
@@ -77,4 +78,3 @@ struct int2type { enum { value = I }; };
 #include <Rcpp/traits/is_primitive.h>
 
 #endif
-

inst/unitTests/cpp/Module.cpp

@@ -204,7 +204,6 @@ RCPP_MODULE(demoModule) {
 
     class_<ModuleCopyConstructor>( "ModuleCopyConstructor")
         .constructor<int>()
-        .copy_constructor()
         .field( "x", &ModuleCopyConstructor::x)
     ;
 }

man/copy.Rd

@@ -4,9 +4,9 @@
   Invokes the copy constructor of the C++ class
 }
 \description{
-  Invokes the copy constructor of the C++ class if it has
-  been registered through the \code{.copy_constructor}
-  module declaration
+  Invokes the copy constructor of the C++ class. The function
+  fails if the underlying class does not have a copy
+  constructor.
 }
 \usage{
   copy(obj)
@@ -37,7 +37,6 @@
     RCPP_MODULE(test){
       class_<Foo>("Foo")
         .constructor<int>()
-        .copy_constructor()
         .field( "x", &Foo::x)
       ;
   }