[Rcpp-commits] r1342 - pkg/Rcpp/inst pkg/Rcpp/inst/include/Rcpp pkg/Rcpp/inst/include/Rcpp/module pkg/Rcpp/inst/unitTests scripts
noreply at r-forge.r-project.org
noreply at r-forge.r-project.org
Thu May 27 14:57:41 CEST 2010
Author: romain
Date: 2010-05-27 14:57:41 +0200 (Thu, 27 May 2010)
New Revision: 1342
Added:
pkg/Rcpp/inst/include/Rcpp/module/Module_generated_Pointer_CppMethod.h
pkg/Rcpp/inst/include/Rcpp/module/Module_generated_Pointer_method.h
scripts/generator_Module_PointerCppMethod.R
scripts/generator_Module_Pointer_method.R
Modified:
pkg/Rcpp/inst/ChangeLog
pkg/Rcpp/inst/include/Rcpp/Module.h
pkg/Rcpp/inst/unitTests/runit.Module.R
Log:
adding support for functions that take pointer to the wrapped class as first argument in class_
Modified: pkg/Rcpp/inst/ChangeLog
===================================================================
--- pkg/Rcpp/inst/ChangeLog 2010-05-27 11:50:25 UTC (rev 1341)
+++ pkg/Rcpp/inst/ChangeLog 2010-05-27 12:57:41 UTC (rev 1342)
@@ -1,3 +1,9 @@
+2010-05-27 Romain Francois <romain at r-enthusiasts.com>
+
+ * inst/include/Rcpp/Module.h: adding support for registering a free function
+ that takes a pointer to the class of the wrapped object as first argument
+ in class_
+
2010-05-26 Romain Francois <romain at r-enthusiasts.com>
* inst/include/Rcpp/Module.h:
Modified: pkg/Rcpp/inst/include/Rcpp/Module.h
===================================================================
--- pkg/Rcpp/inst/include/Rcpp/Module.h 2010-05-27 11:50:25 UTC (rev 1341)
+++ pkg/Rcpp/inst/include/Rcpp/Module.h 2010-05-27 12:57:41 UTC (rev 1342)
@@ -124,8 +124,8 @@
} ;
#include <Rcpp/module/Module_generated_CppMethod.h>
+#include <Rcpp/module/Module_generated_Pointer_CppMethod.h>
-
template <typename Class>
class class_ : public class_Base {
public:
@@ -171,7 +171,8 @@
}
#include <Rcpp/module/Module_generated_method.h>
-
+#include <Rcpp/module/Module_generated_Pointer_method.h>
+
inline bool has_method( const std::string& m){
return methods.find(m) != methods.end() ;
}
Added: pkg/Rcpp/inst/include/Rcpp/module/Module_generated_Pointer_CppMethod.h
===================================================================
--- pkg/Rcpp/inst/include/Rcpp/module/Module_generated_Pointer_CppMethod.h (rev 0)
+++ pkg/Rcpp/inst/include/Rcpp/module/Module_generated_Pointer_CppMethod.h 2010-05-27 12:57:41 UTC (rev 1342)
@@ -0,0 +1,2332 @@
+// -*- mode: C++; c-indent-level: 4; c-basic-offset: 4; tab-width: 8 -*-
+//
+// Module_generated_CppMethod.h: Rcpp R/C++ interface class library -- Rcpp modules
+//
+// Copyright (C) 2010 Dirk Eddelbuettel and 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_Module_generated_Pointer_CppMethod_h
+#define Rcpp_Module_generated_Pointer_CppMethod_h
+
+
+ template <typename Class, typename OUT> class Pointer_CppMethod0 : public CppMethod<Class> {
+ public:
+ typedef OUT (*Method)(Class*) ;
+ typedef CppMethod<Class> method_class ;
+ Pointer_CppMethod0( Method m) : method_class(), met(m){}
+ SEXP operator()( Class* object, SEXP* args){
+ return Rcpp::wrap( met(object) ) ;
+ }
+ inline int nargs(){ return 0 ; }
+ inline bool is_void(){ return false ; }
+ private:
+ Method met ;
+ } ;
+
+ template <typename Class> class Pointer_CppMethod0<Class,void> : public CppMethod<Class> {
+ public:
+ typedef void (*Method)(Class*) ;
+ typedef CppMethod<Class> method_class ;
+ Pointer_CppMethod0( Method m) : method_class(), met(m){}
+ SEXP operator()( Class* object, SEXP* args){
+ met( object ) ;
+ return R_NilValue ;
+ }
+ inline int nargs(){ return 0 ; }
+ inline bool is_void(){ return true ; }
+ private:
+ Method met ;
+ } ;
+
+
+
+ template < typename Class, typename OUT, typename U0 > class Pointer_CppMethod1 : public CppMethod<Class> {
+ public:
+ typedef OUT (*Method)(Class*, U0 u0) ;
+ typedef CppMethod<Class> method_class ;
+
+ Pointer_CppMethod1(Method m) : method_class(), met(m){}
+ SEXP operator()( Class* object, SEXP* args){
+ return Rcpp::wrap( met( object, Rcpp::as<U0>( args[0] ) ) ) ;
+ }
+ inline int nargs(){ return 1 ; }
+ inline bool is_void(){ return false ; }
+ private:
+ Method met ;
+ } ;
+
+ template < typename Class, typename U0 > class Pointer_CppMethod1<Class,void,U0> : public CppMethod<Class> {
+ public:
+ typedef void (*Method)(Class*, U0 u0) ;
+ typedef CppMethod<Class> method_class ;
+
+ Pointer_CppMethod1( Method m) : method_class(), met(m){}
+ SEXP operator()( Class* object, SEXP* args){
+ met( object, Rcpp::as<U0>( args[0] ) ) ;
+ return R_NilValue ;
+ }
+ inline int nargs(){ return 1 ; }
+ inline bool is_void(){ return true ; }
+ private:
+ Method met ;
+ } ;
+
+
+
+
+
+ template < typename Class, typename OUT, typename U0, typename U1 > class Pointer_CppMethod2 : public CppMethod<Class> {
+ public:
+ typedef OUT (*Method)(Class*, U0 u0, U1 u1) ;
+ typedef CppMethod<Class> method_class ;
+
+ Pointer_CppMethod2(Method m) : method_class(), met(m){}
+ SEXP operator()( Class* object, SEXP* args){
+ return Rcpp::wrap( met( object, Rcpp::as<U0>( args[0] ), Rcpp::as<U1>( args[1] ) ) ) ;
+ }
+ inline int nargs(){ return 2 ; }
+ inline bool is_void(){ return false ; }
+ private:
+ Method met ;
+ } ;
+
+ template < typename Class, typename U0, typename U1 > class Pointer_CppMethod2<Class,void,U0, U1> : public CppMethod<Class> {
+ public:
+ typedef void (*Method)(Class*, U0 u0, U1 u1) ;
+ typedef CppMethod<Class> method_class ;
+
+ Pointer_CppMethod2( Method m) : method_class(), met(m){}
+ SEXP operator()( Class* object, SEXP* args){
+ met( object, Rcpp::as<U0>( args[0] ), Rcpp::as<U1>( args[1] ) ) ;
+ return R_NilValue ;
+ }
+ inline int nargs(){ return 2 ; }
+ inline bool is_void(){ return true ; }
+ private:
+ Method met ;
+ } ;
+
+
+
+
+
+ template < typename Class, typename OUT, typename U0, typename U1, typename U2 > class Pointer_CppMethod3 : public CppMethod<Class> {
+ public:
+ typedef OUT (*Method)(Class*, U0 u0, U1 u1, U2 u2) ;
+ typedef CppMethod<Class> method_class ;
+
+ Pointer_CppMethod3(Method m) : method_class(), met(m){}
+ SEXP operator()( Class* object, SEXP* args){
+ return Rcpp::wrap( met( object, Rcpp::as<U0>( args[0] ), Rcpp::as<U1>( args[1] ), Rcpp::as<U2>( args[2] ) ) ) ;
+ }
+ inline int nargs(){ return 3 ; }
+ inline bool is_void(){ return false ; }
+ private:
+ Method met ;
+ } ;
+
+ template < typename Class, typename U0, typename U1, typename U2 > class Pointer_CppMethod3<Class,void,U0, U1, U2> : public CppMethod<Class> {
+ public:
+ typedef void (*Method)(Class*, U0 u0, U1 u1, U2 u2) ;
+ typedef CppMethod<Class> method_class ;
+
+ Pointer_CppMethod3( Method m) : method_class(), met(m){}
+ SEXP operator()( Class* object, SEXP* args){
+ met( object, Rcpp::as<U0>( args[0] ), Rcpp::as<U1>( args[1] ), Rcpp::as<U2>( args[2] ) ) ;
+ return R_NilValue ;
+ }
+ inline int nargs(){ return 3 ; }
+ inline bool is_void(){ return true ; }
+ private:
+ Method met ;
+ } ;
+
+
+
+
+
+ template < typename Class, typename OUT, typename U0, typename U1, typename U2, typename U3 > class Pointer_CppMethod4 : public CppMethod<Class> {
+ public:
+ typedef OUT (*Method)(Class*, U0 u0, U1 u1, U2 u2, U3 u3) ;
+ typedef CppMethod<Class> method_class ;
+
+ Pointer_CppMethod4(Method m) : method_class(), met(m){}
+ SEXP operator()( Class* object, SEXP* args){
+ return Rcpp::wrap( met( object, Rcpp::as<U0>( args[0] ), Rcpp::as<U1>( args[1] ), Rcpp::as<U2>( args[2] ), Rcpp::as<U3>( args[3] ) ) ) ;
+ }
+ inline int nargs(){ return 4 ; }
+ inline bool is_void(){ return false ; }
+ private:
+ Method met ;
+ } ;
+
+ template < typename Class, typename U0, typename U1, typename U2, typename U3 > class Pointer_CppMethod4<Class,void,U0, U1, U2, U3> : public CppMethod<Class> {
+ public:
+ typedef void (*Method)(Class*, U0 u0, U1 u1, U2 u2, U3 u3) ;
+ typedef CppMethod<Class> method_class ;
+
+ Pointer_CppMethod4( Method m) : method_class(), met(m){}
+ SEXP operator()( Class* object, SEXP* args){
+ met( object, Rcpp::as<U0>( args[0] ), Rcpp::as<U1>( args[1] ), Rcpp::as<U2>( args[2] ), Rcpp::as<U3>( args[3] ) ) ;
+ return R_NilValue ;
+ }
+ inline int nargs(){ return 4 ; }
+ inline bool is_void(){ return true ; }
+ private:
+ Method met ;
+ } ;
+
+
+
+
+
+ template < typename Class, typename OUT, typename U0, typename U1, typename U2, typename U3, typename U4 > class Pointer_CppMethod5 : public CppMethod<Class> {
+ public:
+ typedef OUT (*Method)(Class*, U0 u0, U1 u1, U2 u2, U3 u3, U4 u4) ;
+ typedef CppMethod<Class> method_class ;
+
+ Pointer_CppMethod5(Method m) : method_class(), met(m){}
+ SEXP operator()( Class* object, SEXP* args){
+ return Rcpp::wrap( met( object, Rcpp::as<U0>( args[0] ), Rcpp::as<U1>( args[1] ), Rcpp::as<U2>( args[2] ), Rcpp::as<U3>( args[3] ), Rcpp::as<U4>( args[4] ) ) ) ;
+ }
+ inline int nargs(){ return 5 ; }
+ inline bool is_void(){ return false ; }
+ private:
+ Method met ;
+ } ;
+
+ template < typename Class, typename U0, typename U1, typename U2, typename U3, typename U4 > class Pointer_CppMethod5<Class,void,U0, U1, U2, U3, U4> : public CppMethod<Class> {
+ public:
+ typedef void (*Method)(Class*, U0 u0, U1 u1, U2 u2, U3 u3, U4 u4) ;
+ typedef CppMethod<Class> method_class ;
+
+ Pointer_CppMethod5( Method m) : method_class(), met(m){}
+ SEXP operator()( Class* object, SEXP* args){
+ met( object, Rcpp::as<U0>( args[0] ), Rcpp::as<U1>( args[1] ), Rcpp::as<U2>( args[2] ), Rcpp::as<U3>( args[3] ), Rcpp::as<U4>( args[4] ) ) ;
+ return R_NilValue ;
+ }
+ inline int nargs(){ return 5 ; }
+ inline bool is_void(){ return true ; }
+ private:
+ Method met ;
+ } ;
+
+
+
+
+
+ template < typename Class, typename OUT, typename U0, typename U1, typename U2, typename U3, typename U4, typename U5 > class Pointer_CppMethod6 : public CppMethod<Class> {
+ public:
+ typedef OUT (*Method)(Class*, U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5) ;
+ typedef CppMethod<Class> method_class ;
+
+ Pointer_CppMethod6(Method m) : method_class(), met(m){}
+ SEXP operator()( Class* object, SEXP* args){
+ return Rcpp::wrap( met( object, Rcpp::as<U0>( args[0] ), Rcpp::as<U1>( args[1] ), Rcpp::as<U2>( args[2] ), Rcpp::as<U3>( args[3] ), Rcpp::as<U4>( args[4] ), Rcpp::as<U5>( args[5] ) ) ) ;
+ }
+ inline int nargs(){ return 6 ; }
+ inline bool is_void(){ return false ; }
+ private:
+ Method met ;
+ } ;
+
+ template < typename Class, typename U0, typename U1, typename U2, typename U3, typename U4, typename U5 > class Pointer_CppMethod6<Class,void,U0, U1, U2, U3, U4, U5> : public CppMethod<Class> {
+ public:
+ typedef void (*Method)(Class*, U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5) ;
+ typedef CppMethod<Class> method_class ;
+
+ Pointer_CppMethod6( Method m) : method_class(), met(m){}
+ SEXP operator()( Class* object, SEXP* args){
+ met( object, Rcpp::as<U0>( args[0] ), Rcpp::as<U1>( args[1] ), Rcpp::as<U2>( args[2] ), Rcpp::as<U3>( args[3] ), Rcpp::as<U4>( args[4] ), Rcpp::as<U5>( args[5] ) ) ;
+ return R_NilValue ;
+ }
+ inline int nargs(){ return 6 ; }
+ inline bool is_void(){ return true ; }
+ private:
+ Method met ;
+ } ;
+
+
+
+
+
+ template < typename Class, typename OUT, typename U0, typename U1, typename U2, typename U3, typename U4, typename U5, typename U6 > class Pointer_CppMethod7 : public CppMethod<Class> {
+ public:
+ typedef OUT (*Method)(Class*, U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6) ;
+ typedef CppMethod<Class> method_class ;
+
+ Pointer_CppMethod7(Method m) : method_class(), met(m){}
+ SEXP operator()( Class* object, SEXP* args){
+ return Rcpp::wrap( met( object, Rcpp::as<U0>( args[0] ), Rcpp::as<U1>( args[1] ), Rcpp::as<U2>( args[2] ), Rcpp::as<U3>( args[3] ), Rcpp::as<U4>( args[4] ), Rcpp::as<U5>( args[5] ), Rcpp::as<U6>( args[6] ) ) ) ;
+ }
+ inline int nargs(){ return 7 ; }
+ inline bool is_void(){ return false ; }
+ private:
+ Method met ;
+ } ;
+
+ template < typename Class, typename U0, typename U1, typename U2, typename U3, typename U4, typename U5, typename U6 > class Pointer_CppMethod7<Class,void,U0, U1, U2, U3, U4, U5, U6> : public CppMethod<Class> {
+ public:
+ typedef void (*Method)(Class*, U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6) ;
+ typedef CppMethod<Class> method_class ;
+
+ Pointer_CppMethod7( Method m) : method_class(), met(m){}
+ SEXP operator()( Class* object, SEXP* args){
+ met( object, Rcpp::as<U0>( args[0] ), Rcpp::as<U1>( args[1] ), Rcpp::as<U2>( args[2] ), Rcpp::as<U3>( args[3] ), Rcpp::as<U4>( args[4] ), Rcpp::as<U5>( args[5] ), Rcpp::as<U6>( args[6] ) ) ;
+ return R_NilValue ;
+ }
+ inline int nargs(){ return 7 ; }
+ inline bool is_void(){ return true ; }
+ private:
+ Method met ;
+ } ;
+
+
+
+
+
+ template < typename Class, typename OUT, typename U0, typename U1, typename U2, typename U3, typename U4, typename U5, typename U6, typename U7 > class Pointer_CppMethod8 : public CppMethod<Class> {
+ public:
+ typedef OUT (*Method)(Class*, U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6, U7 u7) ;
+ typedef CppMethod<Class> method_class ;
+
+ Pointer_CppMethod8(Method m) : method_class(), met(m){}
+ SEXP operator()( Class* object, SEXP* args){
+ return Rcpp::wrap( met( object, Rcpp::as<U0>( args[0] ), Rcpp::as<U1>( args[1] ), Rcpp::as<U2>( args[2] ), Rcpp::as<U3>( args[3] ), Rcpp::as<U4>( args[4] ), Rcpp::as<U5>( args[5] ), Rcpp::as<U6>( args[6] ), Rcpp::as<U7>( args[7] ) ) ) ;
+ }
+ inline int nargs(){ return 8 ; }
+ inline bool is_void(){ return false ; }
+ private:
+ Method met ;
+ } ;
+
+ template < typename Class, typename U0, typename U1, typename U2, typename U3, typename U4, typename U5, typename U6, typename U7 > class Pointer_CppMethod8<Class,void,U0, U1, U2, U3, U4, U5, U6, U7> : public CppMethod<Class> {
+ public:
+ typedef void (*Method)(Class*, U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6, U7 u7) ;
+ typedef CppMethod<Class> method_class ;
+
+ Pointer_CppMethod8( Method m) : method_class(), met(m){}
+ SEXP operator()( Class* object, SEXP* args){
+ met( object, Rcpp::as<U0>( args[0] ), Rcpp::as<U1>( args[1] ), Rcpp::as<U2>( args[2] ), Rcpp::as<U3>( args[3] ), Rcpp::as<U4>( args[4] ), Rcpp::as<U5>( args[5] ), Rcpp::as<U6>( args[6] ), Rcpp::as<U7>( args[7] ) ) ;
+ return R_NilValue ;
+ }
+ inline int nargs(){ return 8 ; }
+ inline bool is_void(){ return true ; }
+ private:
+ Method met ;
+ } ;
+
+
+
+
+
+ template < typename Class, typename OUT, typename U0, typename U1, typename U2, typename U3, typename U4, typename U5, typename U6, typename U7, typename U8 > class Pointer_CppMethod9 : public CppMethod<Class> {
+ public:
+ typedef OUT (*Method)(Class*, U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6, U7 u7, U8 u8) ;
+ typedef CppMethod<Class> method_class ;
+
+ Pointer_CppMethod9(Method m) : method_class(), met(m){}
+ SEXP operator()( Class* object, SEXP* args){
+ return Rcpp::wrap( met( object, Rcpp::as<U0>( args[0] ), Rcpp::as<U1>( args[1] ), Rcpp::as<U2>( args[2] ), Rcpp::as<U3>( args[3] ), Rcpp::as<U4>( args[4] ), Rcpp::as<U5>( args[5] ), Rcpp::as<U6>( args[6] ), Rcpp::as<U7>( args[7] ), Rcpp::as<U8>( args[8] ) ) ) ;
+ }
+ inline int nargs(){ return 9 ; }
+ inline bool is_void(){ return false ; }
+ private:
+ Method met ;
+ } ;
+
+ template < typename Class, typename U0, typename U1, typename U2, typename U3, typename U4, typename U5, typename U6, typename U7, typename U8 > class Pointer_CppMethod9<Class,void,U0, U1, U2, U3, U4, U5, U6, U7, U8> : public CppMethod<Class> {
+ public:
+ typedef void (*Method)(Class*, U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6, U7 u7, U8 u8) ;
+ typedef CppMethod<Class> method_class ;
+
+ Pointer_CppMethod9( Method m) : method_class(), met(m){}
+ SEXP operator()( Class* object, SEXP* args){
+ met( object, Rcpp::as<U0>( args[0] ), Rcpp::as<U1>( args[1] ), Rcpp::as<U2>( args[2] ), Rcpp::as<U3>( args[3] ), Rcpp::as<U4>( args[4] ), Rcpp::as<U5>( args[5] ), Rcpp::as<U6>( args[6] ), Rcpp::as<U7>( args[7] ), Rcpp::as<U8>( args[8] ) ) ;
+ return R_NilValue ;
+ }
+ inline int nargs(){ return 9 ; }
+ inline bool is_void(){ return true ; }
+ private:
+ Method met ;
+ } ;
+
+
+
+
+
+ template < typename Class, typename OUT, typename U0, typename U1, typename U2, typename U3, typename U4, typename U5, typename U6, typename U7, typename U8, typename U9 > class Pointer_CppMethod10 : public CppMethod<Class> {
+ public:
+ typedef OUT (*Method)(Class*, U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6, U7 u7, U8 u8, U9 u9) ;
+ typedef CppMethod<Class> method_class ;
+
+ Pointer_CppMethod10(Method m) : method_class(), met(m){}
+ SEXP operator()( Class* object, SEXP* args){
+ return Rcpp::wrap( met( object, Rcpp::as<U0>( args[0] ), Rcpp::as<U1>( args[1] ), Rcpp::as<U2>( args[2] ), Rcpp::as<U3>( args[3] ), Rcpp::as<U4>( args[4] ), Rcpp::as<U5>( args[5] ), Rcpp::as<U6>( args[6] ), Rcpp::as<U7>( args[7] ), Rcpp::as<U8>( args[8] ), Rcpp::as<U9>( args[9] ) ) ) ;
+ }
+ inline int nargs(){ return 10 ; }
+ inline bool is_void(){ return false ; }
+ private:
+ Method met ;
+ } ;
+
+ template < typename Class, typename U0, typename U1, typename U2, typename U3, typename U4, typename U5, typename U6, typename U7, typename U8, typename U9 > class Pointer_CppMethod10<Class,void,U0, U1, U2, U3, U4, U5, U6, U7, U8, U9> : public CppMethod<Class> {
+ public:
+ typedef void (*Method)(Class*, U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6, U7 u7, U8 u8, U9 u9) ;
+ typedef CppMethod<Class> method_class ;
+
+ Pointer_CppMethod10( Method m) : method_class(), met(m){}
+ SEXP operator()( Class* object, SEXP* args){
+ met( object, Rcpp::as<U0>( args[0] ), Rcpp::as<U1>( args[1] ), Rcpp::as<U2>( args[2] ), Rcpp::as<U3>( args[3] ), Rcpp::as<U4>( args[4] ), Rcpp::as<U5>( args[5] ), Rcpp::as<U6>( args[6] ), Rcpp::as<U7>( args[7] ), Rcpp::as<U8>( args[8] ), Rcpp::as<U9>( args[9] ) ) ;
+ return R_NilValue ;
+ }
+ inline int nargs(){ return 10 ; }
+ inline bool is_void(){ return true ; }
+ private:
+ Method met ;
+ } ;
+
+
+
+
+
+ template < typename Class, typename OUT, typename U0, typename U1, typename U2, typename U3, typename U4, typename U5, typename U6, typename U7, typename U8, typename U9, typename U10 > class Pointer_CppMethod11 : public CppMethod<Class> {
+ public:
+ typedef OUT (*Method)(Class*, U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6, U7 u7, U8 u8, U9 u9, U10 u10) ;
+ typedef CppMethod<Class> method_class ;
+
+ Pointer_CppMethod11(Method m) : method_class(), met(m){}
+ SEXP operator()( Class* object, SEXP* args){
+ return Rcpp::wrap( met( object, Rcpp::as<U0>( args[0] ), Rcpp::as<U1>( args[1] ), Rcpp::as<U2>( args[2] ), Rcpp::as<U3>( args[3] ), Rcpp::as<U4>( args[4] ), Rcpp::as<U5>( args[5] ), Rcpp::as<U6>( args[6] ), Rcpp::as<U7>( args[7] ), Rcpp::as<U8>( args[8] ), Rcpp::as<U9>( args[9] ), Rcpp::as<U10>( args[10] ) ) ) ;
+ }
+ inline int nargs(){ return 11 ; }
+ inline bool is_void(){ return false ; }
+ private:
+ Method met ;
+ } ;
+
+ template < typename Class, typename U0, typename U1, typename U2, typename U3, typename U4, typename U5, typename U6, typename U7, typename U8, typename U9, typename U10 > class Pointer_CppMethod11<Class,void,U0, U1, U2, U3, U4, U5, U6, U7, U8, U9, U10> : public CppMethod<Class> {
+ public:
+ typedef void (*Method)(Class*, U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6, U7 u7, U8 u8, U9 u9, U10 u10) ;
+ typedef CppMethod<Class> method_class ;
+
+ Pointer_CppMethod11( Method m) : method_class(), met(m){}
+ SEXP operator()( Class* object, SEXP* args){
+ met( object, Rcpp::as<U0>( args[0] ), Rcpp::as<U1>( args[1] ), Rcpp::as<U2>( args[2] ), Rcpp::as<U3>( args[3] ), Rcpp::as<U4>( args[4] ), Rcpp::as<U5>( args[5] ), Rcpp::as<U6>( args[6] ), Rcpp::as<U7>( args[7] ), Rcpp::as<U8>( args[8] ), Rcpp::as<U9>( args[9] ), Rcpp::as<U10>( args[10] ) ) ;
+ return R_NilValue ;
+ }
+ inline int nargs(){ return 11 ; }
+ inline bool is_void(){ return true ; }
+ private:
+ Method met ;
+ } ;
+
+
+
+
+
+ template < typename Class, typename OUT, typename U0, typename U1, typename U2, typename U3, typename U4, typename U5, typename U6, typename U7, typename U8, typename U9, typename U10, typename U11 > class Pointer_CppMethod12 : public CppMethod<Class> {
+ public:
+ typedef OUT (*Method)(Class*, U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6, U7 u7, U8 u8, U9 u9, U10 u10, U11 u11) ;
+ typedef CppMethod<Class> method_class ;
+
+ Pointer_CppMethod12(Method m) : method_class(), met(m){}
+ SEXP operator()( Class* object, SEXP* args){
+ return Rcpp::wrap( met( object, Rcpp::as<U0>( args[0] ), Rcpp::as<U1>( args[1] ), Rcpp::as<U2>( args[2] ), Rcpp::as<U3>( args[3] ), Rcpp::as<U4>( args[4] ), Rcpp::as<U5>( args[5] ), Rcpp::as<U6>( args[6] ), Rcpp::as<U7>( args[7] ), Rcpp::as<U8>( args[8] ), Rcpp::as<U9>( args[9] ), Rcpp::as<U10>( args[10] ), Rcpp::as<U11>( args[11] ) ) ) ;
+ }
+ inline int nargs(){ return 12 ; }
+ inline bool is_void(){ return false ; }
+ private:
+ Method met ;
+ } ;
+
+ template < typename Class, typename U0, typename U1, typename U2, typename U3, typename U4, typename U5, typename U6, typename U7, typename U8, typename U9, typename U10, typename U11 > class Pointer_CppMethod12<Class,void,U0, U1, U2, U3, U4, U5, U6, U7, U8, U9, U10, U11> : public CppMethod<Class> {
+ public:
+ typedef void (*Method)(Class*, U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6, U7 u7, U8 u8, U9 u9, U10 u10, U11 u11) ;
+ typedef CppMethod<Class> method_class ;
+
+ Pointer_CppMethod12( Method m) : method_class(), met(m){}
+ SEXP operator()( Class* object, SEXP* args){
+ met( object, Rcpp::as<U0>( args[0] ), Rcpp::as<U1>( args[1] ), Rcpp::as<U2>( args[2] ), Rcpp::as<U3>( args[3] ), Rcpp::as<U4>( args[4] ), Rcpp::as<U5>( args[5] ), Rcpp::as<U6>( args[6] ), Rcpp::as<U7>( args[7] ), Rcpp::as<U8>( args[8] ), Rcpp::as<U9>( args[9] ), Rcpp::as<U10>( args[10] ), Rcpp::as<U11>( args[11] ) ) ;
+ return R_NilValue ;
+ }
+ inline int nargs(){ return 12 ; }
+ inline bool is_void(){ return true ; }
+ private:
+ Method met ;
+ } ;
+
+
+
+
+
+ template < typename Class, typename OUT, typename U0, typename U1, typename U2, typename U3, typename U4, typename U5, typename U6, typename U7, typename U8, typename U9, typename U10, typename U11, typename U12 > class Pointer_CppMethod13 : public CppMethod<Class> {
+ public:
+ typedef OUT (*Method)(Class*, U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6, U7 u7, U8 u8, U9 u9, U10 u10, U11 u11, U12 u12) ;
+ typedef CppMethod<Class> method_class ;
+
+ Pointer_CppMethod13(Method m) : method_class(), met(m){}
+ SEXP operator()( Class* object, SEXP* args){
+ return Rcpp::wrap( met( object, Rcpp::as<U0>( args[0] ), Rcpp::as<U1>( args[1] ), Rcpp::as<U2>( args[2] ), Rcpp::as<U3>( args[3] ), Rcpp::as<U4>( args[4] ), Rcpp::as<U5>( args[5] ), Rcpp::as<U6>( args[6] ), Rcpp::as<U7>( args[7] ), Rcpp::as<U8>( args[8] ), Rcpp::as<U9>( args[9] ), Rcpp::as<U10>( args[10] ), Rcpp::as<U11>( args[11] ), Rcpp::as<U12>( args[12] ) ) ) ;
+ }
+ inline int nargs(){ return 13 ; }
+ inline bool is_void(){ return false ; }
+ private:
+ Method met ;
+ } ;
+
+ template < typename Class, typename U0, typename U1, typename U2, typename U3, typename U4, typename U5, typename U6, typename U7, typename U8, typename U9, typename U10, typename U11, typename U12 > class Pointer_CppMethod13<Class,void,U0, U1, U2, U3, U4, U5, U6, U7, U8, U9, U10, U11, U12> : public CppMethod<Class> {
+ public:
+ typedef void (*Method)(Class*, U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6, U7 u7, U8 u8, U9 u9, U10 u10, U11 u11, U12 u12) ;
+ typedef CppMethod<Class> method_class ;
+
+ Pointer_CppMethod13( Method m) : method_class(), met(m){}
+ SEXP operator()( Class* object, SEXP* args){
+ met( object, Rcpp::as<U0>( args[0] ), Rcpp::as<U1>( args[1] ), Rcpp::as<U2>( args[2] ), Rcpp::as<U3>( args[3] ), Rcpp::as<U4>( args[4] ), Rcpp::as<U5>( args[5] ), Rcpp::as<U6>( args[6] ), Rcpp::as<U7>( args[7] ), Rcpp::as<U8>( args[8] ), Rcpp::as<U9>( args[9] ), Rcpp::as<U10>( args[10] ), Rcpp::as<U11>( args[11] ), Rcpp::as<U12>( args[12] ) ) ;
+ return R_NilValue ;
+ }
+ inline int nargs(){ return 13 ; }
+ inline bool is_void(){ return true ; }
+ private:
+ Method met ;
+ } ;
+
+
+
+
+
+ template < typename Class, typename OUT, typename U0, typename U1, typename U2, typename U3, typename U4, typename U5, typename U6, typename U7, typename U8, typename U9, typename U10, typename U11, typename U12, typename U13 > class Pointer_CppMethod14 : public CppMethod<Class> {
+ public:
+ typedef OUT (*Method)(Class*, U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6, U7 u7, U8 u8, U9 u9, U10 u10, U11 u11, U12 u12, U13 u13) ;
+ typedef CppMethod<Class> method_class ;
+
+ Pointer_CppMethod14(Method m) : method_class(), met(m){}
+ SEXP operator()( Class* object, SEXP* args){
+ return Rcpp::wrap( met( object, Rcpp::as<U0>( args[0] ), Rcpp::as<U1>( args[1] ), Rcpp::as<U2>( args[2] ), Rcpp::as<U3>( args[3] ), Rcpp::as<U4>( args[4] ), Rcpp::as<U5>( args[5] ), Rcpp::as<U6>( args[6] ), Rcpp::as<U7>( args[7] ), Rcpp::as<U8>( args[8] ), Rcpp::as<U9>( args[9] ), Rcpp::as<U10>( args[10] ), Rcpp::as<U11>( args[11] ), Rcpp::as<U12>( args[12] ), Rcpp::as<U13>( args[13] ) ) ) ;
+ }
+ inline int nargs(){ return 14 ; }
+ inline bool is_void(){ return false ; }
+ private:
+ Method met ;
+ } ;
+
+ template < typename Class, typename U0, typename U1, typename U2, typename U3, typename U4, typename U5, typename U6, typename U7, typename U8, typename U9, typename U10, typename U11, typename U12, typename U13 > class Pointer_CppMethod14<Class,void,U0, U1, U2, U3, U4, U5, U6, U7, U8, U9, U10, U11, U12, U13> : public CppMethod<Class> {
+ public:
+ typedef void (*Method)(Class*, U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6, U7 u7, U8 u8, U9 u9, U10 u10, U11 u11, U12 u12, U13 u13) ;
+ typedef CppMethod<Class> method_class ;
+
+ Pointer_CppMethod14( Method m) : method_class(), met(m){}
+ SEXP operator()( Class* object, SEXP* args){
+ met( object, Rcpp::as<U0>( args[0] ), Rcpp::as<U1>( args[1] ), Rcpp::as<U2>( args[2] ), Rcpp::as<U3>( args[3] ), Rcpp::as<U4>( args[4] ), Rcpp::as<U5>( args[5] ), Rcpp::as<U6>( args[6] ), Rcpp::as<U7>( args[7] ), Rcpp::as<U8>( args[8] ), Rcpp::as<U9>( args[9] ), Rcpp::as<U10>( args[10] ), Rcpp::as<U11>( args[11] ), Rcpp::as<U12>( args[12] ), Rcpp::as<U13>( args[13] ) ) ;
+ return R_NilValue ;
+ }
+ inline int nargs(){ return 14 ; }
+ inline bool is_void(){ return true ; }
+ private:
+ Method met ;
+ } ;
+
+
+
+
+
+ template < typename Class, typename OUT, typename U0, typename U1, typename U2, typename U3, typename U4, typename U5, typename U6, typename U7, typename U8, typename U9, typename U10, typename U11, typename U12, typename U13, typename U14 > class Pointer_CppMethod15 : public CppMethod<Class> {
+ public:
+ typedef OUT (*Method)(Class*, U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6, U7 u7, U8 u8, U9 u9, U10 u10, U11 u11, U12 u12, U13 u13, U14 u14) ;
+ typedef CppMethod<Class> method_class ;
+
+ Pointer_CppMethod15(Method m) : method_class(), met(m){}
+ SEXP operator()( Class* object, SEXP* args){
+ return Rcpp::wrap( met( object, Rcpp::as<U0>( args[0] ), Rcpp::as<U1>( args[1] ), Rcpp::as<U2>( args[2] ), Rcpp::as<U3>( args[3] ), Rcpp::as<U4>( args[4] ), Rcpp::as<U5>( args[5] ), Rcpp::as<U6>( args[6] ), Rcpp::as<U7>( args[7] ), Rcpp::as<U8>( args[8] ), Rcpp::as<U9>( args[9] ), Rcpp::as<U10>( args[10] ), Rcpp::as<U11>( args[11] ), Rcpp::as<U12>( args[12] ), Rcpp::as<U13>( args[13] ), Rcpp::as<U14>( args[14] ) ) ) ;
+ }
+ inline int nargs(){ return 15 ; }
+ inline bool is_void(){ return false ; }
+ private:
+ Method met ;
+ } ;
+
+ template < typename Class, typename U0, typename U1, typename U2, typename U3, typename U4, typename U5, typename U6, typename U7, typename U8, typename U9, typename U10, typename U11, typename U12, typename U13, typename U14 > class Pointer_CppMethod15<Class,void,U0, U1, U2, U3, U4, U5, U6, U7, U8, U9, U10, U11, U12, U13, U14> : public CppMethod<Class> {
+ public:
+ typedef void (*Method)(Class*, U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6, U7 u7, U8 u8, U9 u9, U10 u10, U11 u11, U12 u12, U13 u13, U14 u14) ;
+ typedef CppMethod<Class> method_class ;
+
+ Pointer_CppMethod15( Method m) : method_class(), met(m){}
+ SEXP operator()( Class* object, SEXP* args){
+ met( object, Rcpp::as<U0>( args[0] ), Rcpp::as<U1>( args[1] ), Rcpp::as<U2>( args[2] ), Rcpp::as<U3>( args[3] ), Rcpp::as<U4>( args[4] ), Rcpp::as<U5>( args[5] ), Rcpp::as<U6>( args[6] ), Rcpp::as<U7>( args[7] ), Rcpp::as<U8>( args[8] ), Rcpp::as<U9>( args[9] ), Rcpp::as<U10>( args[10] ), Rcpp::as<U11>( args[11] ), Rcpp::as<U12>( args[12] ), Rcpp::as<U13>( args[13] ), Rcpp::as<U14>( args[14] ) ) ;
+ return R_NilValue ;
+ }
+ inline int nargs(){ return 15 ; }
+ inline bool is_void(){ return true ; }
+ private:
+ Method met ;
+ } ;
+
+
+
+
+
+ template < typename Class, typename OUT, typename U0, typename U1, typename U2, typename U3, typename U4, typename U5, typename U6, typename U7, typename U8, typename U9, typename U10, typename U11, typename U12, typename U13, typename U14, typename U15 > class Pointer_CppMethod16 : public CppMethod<Class> {
+ public:
+ typedef OUT (*Method)(Class*, U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6, U7 u7, U8 u8, U9 u9, U10 u10, U11 u11, U12 u12, U13 u13, U14 u14, U15 u15) ;
+ typedef CppMethod<Class> method_class ;
+
+ Pointer_CppMethod16(Method m) : method_class(), met(m){}
+ SEXP operator()( Class* object, SEXP* args){
+ return Rcpp::wrap( met( object, Rcpp::as<U0>( args[0] ), Rcpp::as<U1>( args[1] ), Rcpp::as<U2>( args[2] ), Rcpp::as<U3>( args[3] ), Rcpp::as<U4>( args[4] ), Rcpp::as<U5>( args[5] ), Rcpp::as<U6>( args[6] ), Rcpp::as<U7>( args[7] ), Rcpp::as<U8>( args[8] ), Rcpp::as<U9>( args[9] ), Rcpp::as<U10>( args[10] ), Rcpp::as<U11>( args[11] ), Rcpp::as<U12>( args[12] ), Rcpp::as<U13>( args[13] ), Rcpp::as<U14>( args[14] ), Rcpp::as<U15>( args[15] ) ) ) ;
+ }
+ inline int nargs(){ return 16 ; }
+ inline bool is_void(){ return false ; }
+ private:
+ Method met ;
+ } ;
+
+ template < typename Class, typename U0, typename U1, typename U2, typename U3, typename U4, typename U5, typename U6, typename U7, typename U8, typename U9, typename U10, typename U11, typename U12, typename U13, typename U14, typename U15 > class Pointer_CppMethod16<Class,void,U0, U1, U2, U3, U4, U5, U6, U7, U8, U9, U10, U11, U12, U13, U14, U15> : public CppMethod<Class> {
+ public:
+ typedef void (*Method)(Class*, U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6, U7 u7, U8 u8, U9 u9, U10 u10, U11 u11, U12 u12, U13 u13, U14 u14, U15 u15) ;
+ typedef CppMethod<Class> method_class ;
+
+ Pointer_CppMethod16( Method m) : method_class(), met(m){}
+ SEXP operator()( Class* object, SEXP* args){
+ met( object, Rcpp::as<U0>( args[0] ), Rcpp::as<U1>( args[1] ), Rcpp::as<U2>( args[2] ), Rcpp::as<U3>( args[3] ), Rcpp::as<U4>( args[4] ), Rcpp::as<U5>( args[5] ), Rcpp::as<U6>( args[6] ), Rcpp::as<U7>( args[7] ), Rcpp::as<U8>( args[8] ), Rcpp::as<U9>( args[9] ), Rcpp::as<U10>( args[10] ), Rcpp::as<U11>( args[11] ), Rcpp::as<U12>( args[12] ), Rcpp::as<U13>( args[13] ), Rcpp::as<U14>( args[14] ), Rcpp::as<U15>( args[15] ) ) ;
+ return R_NilValue ;
+ }
+ inline int nargs(){ return 16 ; }
+ inline bool is_void(){ return true ; }
+ private:
+ Method met ;
+ } ;
+
+
+
+
+
+ template < typename Class, typename OUT, typename U0, typename U1, typename U2, typename U3, typename U4, typename U5, typename U6, typename U7, typename U8, typename U9, typename U10, typename U11, typename U12, typename U13, typename U14, typename U15, typename U16 > class Pointer_CppMethod17 : public CppMethod<Class> {
+ public:
+ typedef OUT (*Method)(Class*, U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6, U7 u7, U8 u8, U9 u9, U10 u10, U11 u11, U12 u12, U13 u13, U14 u14, U15 u15, U16 u16) ;
+ typedef CppMethod<Class> method_class ;
+
+ Pointer_CppMethod17(Method m) : method_class(), met(m){}
+ SEXP operator()( Class* object, SEXP* args){
+ return Rcpp::wrap( met( object, Rcpp::as<U0>( args[0] ), Rcpp::as<U1>( args[1] ), Rcpp::as<U2>( args[2] ), Rcpp::as<U3>( args[3] ), Rcpp::as<U4>( args[4] ), Rcpp::as<U5>( args[5] ), Rcpp::as<U6>( args[6] ), Rcpp::as<U7>( args[7] ), Rcpp::as<U8>( args[8] ), Rcpp::as<U9>( args[9] ), Rcpp::as<U10>( args[10] ), Rcpp::as<U11>( args[11] ), Rcpp::as<U12>( args[12] ), Rcpp::as<U13>( args[13] ), Rcpp::as<U14>( args[14] ), Rcpp::as<U15>( args[15] ), Rcpp::as<U16>( args[16] ) ) ) ;
+ }
+ inline int nargs(){ return 17 ; }
+ inline bool is_void(){ return false ; }
+ private:
+ Method met ;
+ } ;
+
+ template < typename Class, typename U0, typename U1, typename U2, typename U3, typename U4, typename U5, typename U6, typename U7, typename U8, typename U9, typename U10, typename U11, typename U12, typename U13, typename U14, typename U15, typename U16 > class Pointer_CppMethod17<Class,void,U0, U1, U2, U3, U4, U5, U6, U7, U8, U9, U10, U11, U12, U13, U14, U15, U16> : public CppMethod<Class> {
+ public:
+ typedef void (*Method)(Class*, U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6, U7 u7, U8 u8, U9 u9, U10 u10, U11 u11, U12 u12, U13 u13, U14 u14, U15 u15, U16 u16) ;
+ typedef CppMethod<Class> method_class ;
+
+ Pointer_CppMethod17( Method m) : method_class(), met(m){}
+ SEXP operator()( Class* object, SEXP* args){
[TRUNCATED]
To get the complete diff run:
svnlook diff /svnroot/rcpp -r 1342
More information about the Rcpp-commits
mailing list