introduce traits::input_parameter so that we can have std::vector<T>& again

Author: romainfrancois

ChangeLog

@@ -1,9 +1,19 @@
+2013-09-15 Romain Francois <romain@r-enthusiasts.com>
+        
+	* include/Rcpp/InputParameter.h : added the traits::input_parameter trait
+	to add another layer of abstration. 
+	* include/Rcpp/macros/module.h : taking advantage of input_parameter to
+	specialize how to work with module objects
+	* src/attributes.cpp : using traits::input_parameter<T> instead of 
+	InputParameter<T>
+        
 2013-09-14  Dirk Eddelbuettel  <edd@debian.org>
 
+	* src/attributes.cpp : Precede closing '>' by space to avoid '>>'
 	* inst/include/Rcpp/platform/compiler.h: Further refine #if test for
 	'long long' by conditioning __LP64__ on also using clang/llvm
 
-	* src/attributes.cpp (Rcpp): Precede closing '>' by space to avoid '>>'
+	* src/attributes.cpp : Precede closing '>' by space to avoid '>>'
 
 2013-09-13  Romain Francois <romain@r-enthusiasts.com>
 

inst/include/Rcpp/InputParameter.h

@@ -22,8 +22,10 @@
 #ifndef Rcpp__InputParameter__h
 #define Rcpp__InputParameter__h
 
-namespace Rcpp {
+namespace Rcpp { 
 
+    // default implementation used for pass by value and modules objects
+    // as<> is called on the conversion operator
     template <typename T>
     class InputParameter {
     public:
@@ -35,6 +37,48 @@ namespace Rcpp {
         SEXP x ;
     } ;
 
+    // impl for references. It holds an object at the constructor and then 
+    // returns a reference in the reference operator
+    template <typename T>
+    class ReferenceInputParameter {
+    public:
+        typedef T& reference ;
+        ReferenceInputParameter(SEXP x_) : obj( as<T>(x_) ){}
+        
+        inline operator reference() { return obj ; }
+        
+    private:
+        T obj ;
+    } ;
+    
+    // same for const references
+    template <typename T>
+    class ConstReferenceInputParameter {
+    public:
+        typedef const T& const_reference ;
+        ConstReferenceInputParameter(SEXP x_) : obj( as<T>(x_) ){}
+        
+        inline operator const_reference() { return obj ; }
+        
+    private:
+        T obj ;
+    } ;
+    
+    namespace traits{
+        template <typename T>
+        struct input_parameter {
+            typedef typename Rcpp::InputParameter<T> type ;
+        } ;
+        template <typename T>
+        struct input_parameter<T&> {
+            typedef typename Rcpp::ReferenceInputParameter<T> type ;
+        } ;
+        template <typename T>
+        struct input_parameter<const T&> {
+            typedef typename Rcpp::ConstReferenceInputParameter<T> type ;
+        } ;
+    }    
+    
 }
 
 #endif

inst/include/Rcpp/macros/module.h

@@ -44,6 +44,21 @@
     template<> struct r_type_traits< const CLASS& >{                          \
         typedef r_type_module_object_const_reference_tag r_category ;         \
     } ;                                                                       \
+    template<> struct input_parameter< CLASS* >{                              \
+        typedef Rcpp::InputParameter<CLASS*> type ;                           \
+    } ;                                                                       \
+    template<> struct input_parameter< const CLASS* >{                        \
+        typedef Rcpp::InputParameter<const CLASS*> type ;                     \
+    } ;                                                                       \
+    template<> struct input_parameter< CLASS >{                               \
+        typedef Rcpp::InputParameter<CLASS> type ;                            \
+    } ;                                                                       \
+    template<> struct input_parameter< CLASS& >{                              \
+        typedef Rcpp::InputParameter<CLASS&> type ;                           \
+    } ;                                                                       \
+    template<> struct input_parameter< const CLASS& >{                        \
+        typedef Rcpp::InputParameter<const CLASS&> type ;                     \
+    } ;                                                                       \
     }}
 
 #define RCPP_EXPOSED_WRAP(CLASS) namespace Rcpp{ namespace traits{ template<> struct wrap_type_traits< CLASS >{typedef wrap_type_module_object_tag wrap_category ; } ; }}

src/attributes.cpp

@@ -2167,8 +2167,8 @@ namespace attributes {
             for (size_t i = 0; i<arguments.size(); i++) {
                 const Argument& argument = arguments[i];
 
-                ostr << "        Rcpp::InputParameter< " 
-                     << argument.type().full_name() << " > " << argument.name() 
+                ostr << "        Rcpp::traits::input_parameter< " 
+                     << argument.type().full_name() << " >::type " << argument.name() 
                      << "(" << argument.name() << "SEXP );" << std::endl;
             }